1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/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 char * program_name = "readelf";
169 static unsigned long archive_file_offset;
170 static unsigned long archive_file_size;
171 static bfd_size_type current_file_size;
172 static unsigned long dynamic_addr;
173 static bfd_size_type dynamic_size;
174 static size_t dynamic_nent;
175 static char * dynamic_strings;
176 static unsigned long dynamic_strings_length;
177 static char * string_table;
178 static unsigned long string_table_length;
179 static unsigned long num_dynamic_syms;
180 static Elf_Internal_Sym * dynamic_symbols;
181 static Elf_Internal_Syminfo * dynamic_syminfo;
182 static unsigned long dynamic_syminfo_offset;
183 static unsigned int dynamic_syminfo_nent;
184 static char program_interpreter[PATH_MAX];
185 static bfd_vma dynamic_info[DT_ENCODING];
186 static bfd_vma dynamic_info_DT_GNU_HASH;
187 static bfd_vma version_info[16];
188 static Elf_Internal_Ehdr elf_header;
189 static Elf_Internal_Shdr * section_headers;
190 static Elf_Internal_Phdr * program_headers;
191 static Elf_Internal_Dyn * dynamic_section;
192 static Elf_Internal_Shdr * symtab_shndx_hdr;
193 static int show_name;
194 static int do_dynamic;
196 static int do_dyn_syms;
198 static int do_sections;
199 static int do_section_groups;
200 static int do_section_details;
201 static int do_segments;
202 static int do_unwind;
203 static int do_using_dynamic;
204 static int do_header;
206 static int do_version;
207 static int do_histogram;
208 static int do_debugging;
211 static int do_archive_index;
212 static int is_32bit_elf;
216 struct group_list * next;
217 unsigned int section_index;
222 struct group_list * root;
223 unsigned int group_index;
226 static size_t group_count;
227 static struct group * section_groups;
228 static struct group ** section_headers_groups;
231 /* Flag bits indicating particular types of dump. */
232 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
233 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
236 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
238 typedef unsigned char dump_type;
240 /* A linked list of the section names for which dumps were requested. */
241 struct dump_list_entry
245 struct dump_list_entry * next;
247 static struct dump_list_entry * dump_sects_byname;
249 /* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251 static dump_type * cmdline_dump_sects = NULL;
252 static unsigned int num_cmdline_dump_sects = 0;
254 /* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
259 static dump_type * dump_sects = NULL;
260 static unsigned int num_dump_sects = 0;
263 /* How to print a vma value. */
264 typedef enum print_mode
276 /* Versioned symbol info. */
277 enum versioned_symbol_info
284 static const char *get_symbol_version_string
285 (FILE *file, int is_dynsym, const char *strtab,
286 unsigned long int strtab_size, unsigned int si,
287 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
288 unsigned short *vna_other);
292 #define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
296 : string_table + (X)->sh_name))
298 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
300 #define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
304 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
309 #define REMOVE_ARCH_BITS(ADDR) \
312 if (elf_header.e_machine == EM_ARM) \
317 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
322 and REASON is not NULL then emit an error message using REASON as part of the
326 get_data (void * var, FILE * file, unsigned long offset, size_t size, size_t nmemb,
330 size_t amt = size * nmemb;
332 if (size == 0 || nmemb == 0)
335 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
336 attempting to allocate memory when the read is bound to fail. */
337 if (amt > current_file_size
338 || offset + archive_file_offset + amt > current_file_size)
341 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
342 (unsigned long) amt, reason);
346 if (fseek (file, archive_file_offset + offset, SEEK_SET))
349 error (_("Unable to seek to 0x%lx for %s\n"),
350 (unsigned long) archive_file_offset + offset, reason);
357 /* Check for overflow. */
358 if (nmemb < (~(size_t) 0 - 1) / size)
359 /* + 1 so that we can '\0' terminate invalid string table sections. */
360 mvar = malloc (size * nmemb + 1);
365 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
366 (unsigned long)(size * nmemb), reason);
370 ((char *) mvar)[amt] = '\0';
373 if (fread (mvar, size, nmemb, file) != nmemb)
376 error (_("Unable to read in 0x%lx bytes of %s\n"),
377 (unsigned long) amt, reason);
386 /* Print a VMA value. */
389 print_vma (bfd_vma vma, print_mode mode)
402 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
409 return printf ("%5" BFD_VMA_FMT "d", vma);
417 return nc + printf ("%" BFD_VMA_FMT "x", vma);
420 return printf ("%" BFD_VMA_FMT "d", vma);
423 return printf ("%" BFD_VMA_FMT "u", vma);
428 /* Display a symbol on stdout. Handles the display of control characters and
429 multibye characters (assuming the host environment supports them).
431 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
433 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
434 padding as necessary.
436 Returns the number of emitted characters. */
439 print_symbol (int width, const char *symbol)
441 bfd_boolean extra_padding = FALSE;
443 #ifdef HAVE_MBSTATE_T
450 /* Keep the width positive. This also helps. */
452 extra_padding = TRUE;
457 /* Set the remaining width to a very large value.
458 This simplifies the code below. */
459 width_remaining = INT_MAX;
461 width_remaining = width;
463 #ifdef HAVE_MBSTATE_T
464 /* Initialise the multibyte conversion state. */
465 memset (& state, 0, sizeof (state));
468 while (width_remaining)
471 const char c = *symbol++;
476 /* Do not print control characters directly as they can affect terminal
477 settings. Such characters usually appear in the names generated
478 by the assembler for local labels. */
481 if (width_remaining < 2)
484 printf ("^%c", c + 0x40);
485 width_remaining -= 2;
488 else if (ISPRINT (c))
496 #ifdef HAVE_MBSTATE_T
499 /* Let printf do the hard work of displaying multibyte characters. */
500 printf ("%.1s", symbol - 1);
504 #ifdef HAVE_MBSTATE_T
505 /* Try to find out how many bytes made up the character that was
506 just printed. Advance the symbol pointer past the bytes that
508 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
512 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
517 if (extra_padding && num_printed < width)
519 /* Fill in the remaining spaces. */
520 printf ("%-*s", width - num_printed, " ");
527 /* Returns a pointer to a static buffer containing a printable version of
528 the given section's name. Like print_symbol, except that it does not try
529 to print multibyte characters, it just interprets them as hex values. */
532 printable_section_name (Elf_Internal_Shdr * sec)
534 #define MAX_PRINT_SEC_NAME_LEN 128
535 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
536 const char * name = SECTION_NAME (sec);
537 char * buf = sec_name_buf;
539 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
541 while ((c = * name ++) != 0)
552 else if (ISPRINT (c))
559 static char hex[17] = "0123456789ABCDEF";
564 * buf ++ = hex[(c & 0xf0) >> 4];
565 * buf ++ = hex[c & 0x0f];
579 printable_section_name_from_index (unsigned long ndx)
581 if (ndx >= elf_header.e_shnum)
582 return _("<corrupt>");
584 return printable_section_name (section_headers + ndx);
587 /* Return a pointer to section NAME, or NULL if no such section exists. */
589 static Elf_Internal_Shdr *
590 find_section (const char * name)
594 for (i = 0; i < elf_header.e_shnum; i++)
595 if (streq (SECTION_NAME (section_headers + i), name))
596 return section_headers + i;
601 /* Return a pointer to a section containing ADDR, or NULL if no such
604 static Elf_Internal_Shdr *
605 find_section_by_address (bfd_vma addr)
609 for (i = 0; i < elf_header.e_shnum; i++)
611 Elf_Internal_Shdr *sec = section_headers + i;
612 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
619 static Elf_Internal_Shdr *
620 find_section_by_type (unsigned int type)
624 for (i = 0; i < elf_header.e_shnum; i++)
626 Elf_Internal_Shdr *sec = section_headers + i;
627 if (sec->sh_type == type)
634 /* Return a pointer to section NAME, or NULL if no such section exists,
635 restricted to the list of sections given in SET. */
637 static Elf_Internal_Shdr *
638 find_section_in_set (const char * name, unsigned int * set)
644 while ((i = *set++) > 0)
645 if (streq (SECTION_NAME (section_headers + i), name))
646 return section_headers + i;
649 return find_section (name);
652 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
655 static inline unsigned long
656 read_uleb128 (unsigned char *data,
657 unsigned int *length_return,
658 const unsigned char * const end)
660 return read_leb128 (data, length_return, FALSE, end);
663 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
664 This OS has so many departures from the ELF standard that we test it at
670 return elf_header.e_machine == EM_IA_64
671 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
674 /* Guess the relocation size commonly used by the specific machines. */
677 guess_is_rela (unsigned int e_machine)
681 /* Targets that use REL relocations. */
696 /* Targets that use RELA relocations. */
700 case EM_ADAPTEVA_EPIPHANY:
702 case EM_ALTERA_NIOS2:
721 case EM_LATTICEMICO32:
730 case EM_CYGNUS_MN10200:
732 case EM_CYGNUS_MN10300:
766 case EM_MICROBLAZE_OLD:
787 warn (_("Don't know about relocations on this machine architecture\n"));
793 slurp_rela_relocs (FILE * file,
794 unsigned long rel_offset,
795 unsigned long rel_size,
796 Elf_Internal_Rela ** relasp,
797 unsigned long * nrelasp)
799 Elf_Internal_Rela * relas;
805 Elf32_External_Rela * erelas;
807 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
808 rel_size, _("32-bit relocation data"));
812 nrelas = rel_size / sizeof (Elf32_External_Rela);
814 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
815 sizeof (Elf_Internal_Rela));
820 error (_("out of memory parsing relocs\n"));
824 for (i = 0; i < nrelas; i++)
826 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
827 relas[i].r_info = BYTE_GET (erelas[i].r_info);
828 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
835 Elf64_External_Rela * erelas;
837 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
838 rel_size, _("64-bit relocation data"));
842 nrelas = rel_size / sizeof (Elf64_External_Rela);
844 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
845 sizeof (Elf_Internal_Rela));
850 error (_("out of memory parsing relocs\n"));
854 for (i = 0; i < nrelas; i++)
856 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
857 relas[i].r_info = BYTE_GET (erelas[i].r_info);
858 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
860 /* The #ifdef BFD64 below is to prevent a compile time
861 warning. We know that if we do not have a 64 bit data
862 type that we will never execute this code anyway. */
864 if (elf_header.e_machine == EM_MIPS
865 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
867 /* In little-endian objects, r_info isn't really a
868 64-bit little-endian value: it has a 32-bit
869 little-endian symbol index followed by four
870 individual byte fields. Reorder INFO
872 bfd_vma inf = relas[i].r_info;
873 inf = (((inf & 0xffffffff) << 32)
874 | ((inf >> 56) & 0xff)
875 | ((inf >> 40) & 0xff00)
876 | ((inf >> 24) & 0xff0000)
877 | ((inf >> 8) & 0xff000000));
878 relas[i].r_info = inf;
891 slurp_rel_relocs (FILE * file,
892 unsigned long rel_offset,
893 unsigned long rel_size,
894 Elf_Internal_Rela ** relsp,
895 unsigned long * nrelsp)
897 Elf_Internal_Rela * rels;
903 Elf32_External_Rel * erels;
905 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
906 rel_size, _("32-bit relocation data"));
910 nrels = rel_size / sizeof (Elf32_External_Rel);
912 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
917 error (_("out of memory parsing relocs\n"));
921 for (i = 0; i < nrels; i++)
923 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
924 rels[i].r_info = BYTE_GET (erels[i].r_info);
925 rels[i].r_addend = 0;
932 Elf64_External_Rel * erels;
934 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
935 rel_size, _("64-bit relocation data"));
939 nrels = rel_size / sizeof (Elf64_External_Rel);
941 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
946 error (_("out of memory parsing relocs\n"));
950 for (i = 0; i < nrels; i++)
952 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
953 rels[i].r_info = BYTE_GET (erels[i].r_info);
954 rels[i].r_addend = 0;
956 /* The #ifdef BFD64 below is to prevent a compile time
957 warning. We know that if we do not have a 64 bit data
958 type that we will never execute this code anyway. */
960 if (elf_header.e_machine == EM_MIPS
961 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
963 /* In little-endian objects, r_info isn't really a
964 64-bit little-endian value: it has a 32-bit
965 little-endian symbol index followed by four
966 individual byte fields. Reorder INFO
968 bfd_vma inf = rels[i].r_info;
969 inf = (((inf & 0xffffffff) << 32)
970 | ((inf >> 56) & 0xff)
971 | ((inf >> 40) & 0xff00)
972 | ((inf >> 24) & 0xff0000)
973 | ((inf >> 8) & 0xff000000));
974 rels[i].r_info = inf;
986 /* Returns the reloc type extracted from the reloc info field. */
989 get_reloc_type (bfd_vma reloc_info)
992 return ELF32_R_TYPE (reloc_info);
994 switch (elf_header.e_machine)
997 /* Note: We assume that reloc_info has already been adjusted for us. */
998 return ELF64_MIPS_R_TYPE (reloc_info);
1001 return ELF64_R_TYPE_ID (reloc_info);
1004 return ELF64_R_TYPE (reloc_info);
1008 /* Return the symbol index extracted from the reloc info field. */
1011 get_reloc_symindex (bfd_vma reloc_info)
1013 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1016 static inline bfd_boolean
1017 uses_msp430x_relocs (void)
1020 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1021 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1022 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1023 /* TI compiler uses ELFOSABI_NONE. */
1024 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1027 /* Display the contents of the relocation data found at the specified
1031 dump_relocations (FILE * file,
1032 unsigned long rel_offset,
1033 unsigned long rel_size,
1034 Elf_Internal_Sym * symtab,
1035 unsigned long nsyms,
1037 unsigned long strtablen,
1042 Elf_Internal_Rela * rels;
1044 if (is_rela == UNKNOWN)
1045 is_rela = guess_is_rela (elf_header.e_machine);
1049 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1054 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1063 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1065 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1070 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1072 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1080 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1082 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1087 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1089 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1093 for (i = 0; i < rel_size; i++)
1098 bfd_vma symtab_index;
1101 offset = rels[i].r_offset;
1102 inf = rels[i].r_info;
1104 type = get_reloc_type (inf);
1105 symtab_index = get_reloc_symindex (inf);
1109 printf ("%8.8lx %8.8lx ",
1110 (unsigned long) offset & 0xffffffff,
1111 (unsigned long) inf & 0xffffffff);
1115 #if BFD_HOST_64BIT_LONG
1117 ? "%16.16lx %16.16lx "
1118 : "%12.12lx %12.12lx ",
1120 #elif BFD_HOST_64BIT_LONG_LONG
1123 ? "%16.16llx %16.16llx "
1124 : "%12.12llx %12.12llx ",
1128 ? "%16.16I64x %16.16I64x "
1129 : "%12.12I64x %12.12I64x ",
1134 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1135 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1136 _bfd_int64_high (offset),
1137 _bfd_int64_low (offset),
1138 _bfd_int64_high (inf),
1139 _bfd_int64_low (inf));
1143 switch (elf_header.e_machine)
1150 rtype = elf_aarch64_reloc_type (type);
1154 case EM_CYGNUS_M32R:
1155 rtype = elf_m32r_reloc_type (type);
1160 rtype = elf_i386_reloc_type (type);
1165 rtype = elf_m68hc11_reloc_type (type);
1169 rtype = elf_m68k_reloc_type (type);
1173 rtype = elf_i960_reloc_type (type);
1178 rtype = elf_avr_reloc_type (type);
1181 case EM_OLD_SPARCV9:
1182 case EM_SPARC32PLUS:
1185 rtype = elf_sparc_reloc_type (type);
1189 rtype = elf_spu_reloc_type (type);
1193 rtype = v800_reloc_type (type);
1196 case EM_CYGNUS_V850:
1197 rtype = v850_reloc_type (type);
1201 case EM_CYGNUS_D10V:
1202 rtype = elf_d10v_reloc_type (type);
1206 case EM_CYGNUS_D30V:
1207 rtype = elf_d30v_reloc_type (type);
1211 rtype = elf_dlx_reloc_type (type);
1215 rtype = elf_sh_reloc_type (type);
1219 case EM_CYGNUS_MN10300:
1220 rtype = elf_mn10300_reloc_type (type);
1224 case EM_CYGNUS_MN10200:
1225 rtype = elf_mn10200_reloc_type (type);
1229 case EM_CYGNUS_FR30:
1230 rtype = elf_fr30_reloc_type (type);
1234 rtype = elf_frv_reloc_type (type);
1238 rtype = elf_mcore_reloc_type (type);
1242 rtype = elf_mmix_reloc_type (type);
1246 rtype = elf_moxie_reloc_type (type);
1250 if (uses_msp430x_relocs ())
1252 rtype = elf_msp430x_reloc_type (type);
1256 rtype = elf_msp430_reloc_type (type);
1260 rtype = elf_nds32_reloc_type (type);
1264 rtype = elf_ppc_reloc_type (type);
1268 rtype = elf_ppc64_reloc_type (type);
1272 case EM_MIPS_RS3_LE:
1273 rtype = elf_mips_reloc_type (type);
1277 rtype = elf_alpha_reloc_type (type);
1281 rtype = elf_arm_reloc_type (type);
1285 rtype = elf_arc_reloc_type (type);
1289 rtype = elf_hppa_reloc_type (type);
1295 rtype = elf_h8_reloc_type (type);
1299 rtype = elf_or1k_reloc_type (type);
1304 rtype = elf_pj_reloc_type (type);
1307 rtype = elf_ia64_reloc_type (type);
1311 rtype = elf_cris_reloc_type (type);
1315 rtype = elf_i860_reloc_type (type);
1321 rtype = elf_x86_64_reloc_type (type);
1325 rtype = i370_reloc_type (type);
1330 rtype = elf_s390_reloc_type (type);
1334 rtype = elf_score_reloc_type (type);
1338 rtype = elf_xstormy16_reloc_type (type);
1342 rtype = elf_crx_reloc_type (type);
1346 rtype = elf_vax_reloc_type (type);
1350 rtype = elf_visium_reloc_type (type);
1353 case EM_ADAPTEVA_EPIPHANY:
1354 rtype = elf_epiphany_reloc_type (type);
1359 rtype = elf_ip2k_reloc_type (type);
1363 rtype = elf_iq2000_reloc_type (type);
1368 rtype = elf_xtensa_reloc_type (type);
1371 case EM_LATTICEMICO32:
1372 rtype = elf_lm32_reloc_type (type);
1377 rtype = elf_m32c_reloc_type (type);
1381 rtype = elf_mt_reloc_type (type);
1385 rtype = elf_bfin_reloc_type (type);
1389 rtype = elf_mep_reloc_type (type);
1393 rtype = elf_cr16_reloc_type (type);
1397 case EM_MICROBLAZE_OLD:
1398 rtype = elf_microblaze_reloc_type (type);
1402 rtype = elf_rl78_reloc_type (type);
1406 rtype = elf_rx_reloc_type (type);
1410 rtype = elf_metag_reloc_type (type);
1415 rtype = elf_xc16x_reloc_type (type);
1419 rtype = elf_tic6x_reloc_type (type);
1423 rtype = elf_tilegx_reloc_type (type);
1427 rtype = elf_tilepro_reloc_type (type);
1431 rtype = elf_xgate_reloc_type (type);
1434 case EM_ALTERA_NIOS2:
1435 rtype = elf_nios2_reloc_type (type);
1440 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1442 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1444 if (elf_header.e_machine == EM_ALPHA
1446 && streq (rtype, "R_ALPHA_LITUSE")
1449 switch (rels[i].r_addend)
1451 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1452 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1453 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1454 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1455 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1456 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1457 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1458 default: rtype = NULL;
1461 printf (" (%s)", rtype);
1465 printf (_("<unknown addend: %lx>"),
1466 (unsigned long) rels[i].r_addend);
1469 else if (symtab_index)
1471 if (symtab == NULL || symtab_index >= nsyms)
1472 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1475 Elf_Internal_Sym * psym;
1476 const char * version_string;
1477 enum versioned_symbol_info sym_info;
1478 unsigned short vna_other;
1480 psym = symtab + symtab_index;
1483 = get_symbol_version_string (file, is_dynsym,
1492 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1496 unsigned int width = is_32bit_elf ? 8 : 14;
1498 /* Relocations against GNU_IFUNC symbols do not use the value
1499 of the symbol as the address to relocate against. Instead
1500 they invoke the function named by the symbol and use its
1501 result as the address for relocation.
1503 To indicate this to the user, do not display the value of
1504 the symbol in the "Symbols's Value" field. Instead show
1505 its name followed by () as a hint that the symbol is
1509 || psym->st_name == 0
1510 || psym->st_name >= strtablen)
1513 name = strtab + psym->st_name;
1515 len = print_symbol (width, name);
1517 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1519 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1523 print_vma (psym->st_value, LONG_HEX);
1525 printf (is_32bit_elf ? " " : " ");
1528 if (psym->st_name == 0)
1530 const char * sec_name = "<null>";
1533 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1535 if (psym->st_shndx < elf_header.e_shnum)
1536 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1537 else if (psym->st_shndx == SHN_ABS)
1539 else if (psym->st_shndx == SHN_COMMON)
1540 sec_name = "COMMON";
1541 else if ((elf_header.e_machine == EM_MIPS
1542 && psym->st_shndx == SHN_MIPS_SCOMMON)
1543 || (elf_header.e_machine == EM_TI_C6000
1544 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1545 sec_name = "SCOMMON";
1546 else if (elf_header.e_machine == EM_MIPS
1547 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1548 sec_name = "SUNDEF";
1549 else if ((elf_header.e_machine == EM_X86_64
1550 || elf_header.e_machine == EM_L1OM
1551 || elf_header.e_machine == EM_K1OM)
1552 && psym->st_shndx == SHN_X86_64_LCOMMON)
1553 sec_name = "LARGE_COMMON";
1554 else if (elf_header.e_machine == EM_IA_64
1555 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1556 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1557 sec_name = "ANSI_COM";
1558 else if (is_ia64_vms ()
1559 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1560 sec_name = "VMS_SYMVEC";
1563 sprintf (name_buf, "<section 0x%x>",
1564 (unsigned int) psym->st_shndx);
1565 sec_name = name_buf;
1568 print_symbol (22, sec_name);
1570 else if (strtab == NULL)
1571 printf (_("<string table index: %3ld>"), psym->st_name);
1572 else if (psym->st_name >= strtablen)
1573 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1576 print_symbol (22, strtab + psym->st_name);
1578 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1584 bfd_signed_vma off = rels[i].r_addend;
1587 printf (" - %" BFD_VMA_FMT "x", - off);
1589 printf (" + %" BFD_VMA_FMT "x", off);
1595 bfd_signed_vma off = rels[i].r_addend;
1597 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1599 printf ("-%" BFD_VMA_FMT "x", - off);
1601 printf ("%" BFD_VMA_FMT "x", off);
1604 if (elf_header.e_machine == EM_SPARCV9
1606 && streq (rtype, "R_SPARC_OLO10"))
1607 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1612 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1614 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1615 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1616 const char * rtype2 = elf_mips_reloc_type (type2);
1617 const char * rtype3 = elf_mips_reloc_type (type3);
1619 printf (" Type2: ");
1622 printf (_("unrecognized: %-7lx"),
1623 (unsigned long) type2 & 0xffffffff);
1625 printf ("%-17.17s", rtype2);
1627 printf ("\n Type3: ");
1630 printf (_("unrecognized: %-7lx"),
1631 (unsigned long) type3 & 0xffffffff);
1633 printf ("%-17.17s", rtype3);
1644 get_mips_dynamic_type (unsigned long type)
1648 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1649 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1650 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1651 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1652 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1653 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1654 case DT_MIPS_MSYM: return "MIPS_MSYM";
1655 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1656 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1657 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1658 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1659 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1660 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1661 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1662 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1663 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1664 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1665 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1666 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1667 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1668 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1669 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1670 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1671 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1672 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1673 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1674 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1675 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1676 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1677 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1678 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1679 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1680 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1681 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1682 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1683 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1684 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1685 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1686 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1687 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1688 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1689 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1690 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1691 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1692 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1699 get_sparc64_dynamic_type (unsigned long type)
1703 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1710 get_ppc_dynamic_type (unsigned long type)
1714 case DT_PPC_GOT: return "PPC_GOT";
1715 case DT_PPC_OPT: return "PPC_OPT";
1722 get_ppc64_dynamic_type (unsigned long type)
1726 case DT_PPC64_GLINK: return "PPC64_GLINK";
1727 case DT_PPC64_OPD: return "PPC64_OPD";
1728 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1729 case DT_PPC64_OPT: return "PPC64_OPT";
1736 get_parisc_dynamic_type (unsigned long type)
1740 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1741 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1742 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1743 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1744 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1745 case DT_HP_PREINIT: return "HP_PREINIT";
1746 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1747 case DT_HP_NEEDED: return "HP_NEEDED";
1748 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1749 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1750 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1751 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1752 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1753 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1754 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1755 case DT_HP_FILTERED: return "HP_FILTERED";
1756 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1757 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1758 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1759 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1760 case DT_PLT: return "PLT";
1761 case DT_PLT_SIZE: return "PLT_SIZE";
1762 case DT_DLT: return "DLT";
1763 case DT_DLT_SIZE: return "DLT_SIZE";
1770 get_ia64_dynamic_type (unsigned long type)
1774 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1775 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1776 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1777 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1778 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1779 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1780 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1781 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1782 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1783 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1784 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1785 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1786 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1787 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1788 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1789 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1790 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1791 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1792 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1793 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1794 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1795 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1796 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1797 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1798 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1799 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1800 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1801 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1802 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1803 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1804 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1811 get_alpha_dynamic_type (unsigned long type)
1815 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1822 get_score_dynamic_type (unsigned long type)
1826 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1827 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1828 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1829 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1830 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1831 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1838 get_tic6x_dynamic_type (unsigned long type)
1842 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1843 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1844 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1845 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1846 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1847 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1854 get_nios2_dynamic_type (unsigned long type)
1858 case DT_NIOS2_GP: return "NIOS2_GP";
1865 get_dynamic_type (unsigned long type)
1867 static char buff[64];
1871 case DT_NULL: return "NULL";
1872 case DT_NEEDED: return "NEEDED";
1873 case DT_PLTRELSZ: return "PLTRELSZ";
1874 case DT_PLTGOT: return "PLTGOT";
1875 case DT_HASH: return "HASH";
1876 case DT_STRTAB: return "STRTAB";
1877 case DT_SYMTAB: return "SYMTAB";
1878 case DT_RELA: return "RELA";
1879 case DT_RELASZ: return "RELASZ";
1880 case DT_RELAENT: return "RELAENT";
1881 case DT_STRSZ: return "STRSZ";
1882 case DT_SYMENT: return "SYMENT";
1883 case DT_INIT: return "INIT";
1884 case DT_FINI: return "FINI";
1885 case DT_SONAME: return "SONAME";
1886 case DT_RPATH: return "RPATH";
1887 case DT_SYMBOLIC: return "SYMBOLIC";
1888 case DT_REL: return "REL";
1889 case DT_RELSZ: return "RELSZ";
1890 case DT_RELENT: return "RELENT";
1891 case DT_PLTREL: return "PLTREL";
1892 case DT_DEBUG: return "DEBUG";
1893 case DT_TEXTREL: return "TEXTREL";
1894 case DT_JMPREL: return "JMPREL";
1895 case DT_BIND_NOW: return "BIND_NOW";
1896 case DT_INIT_ARRAY: return "INIT_ARRAY";
1897 case DT_FINI_ARRAY: return "FINI_ARRAY";
1898 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1899 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1900 case DT_RUNPATH: return "RUNPATH";
1901 case DT_FLAGS: return "FLAGS";
1903 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1904 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1906 case DT_CHECKSUM: return "CHECKSUM";
1907 case DT_PLTPADSZ: return "PLTPADSZ";
1908 case DT_MOVEENT: return "MOVEENT";
1909 case DT_MOVESZ: return "MOVESZ";
1910 case DT_FEATURE: return "FEATURE";
1911 case DT_POSFLAG_1: return "POSFLAG_1";
1912 case DT_SYMINSZ: return "SYMINSZ";
1913 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1915 case DT_ADDRRNGLO: return "ADDRRNGLO";
1916 case DT_CONFIG: return "CONFIG";
1917 case DT_DEPAUDIT: return "DEPAUDIT";
1918 case DT_AUDIT: return "AUDIT";
1919 case DT_PLTPAD: return "PLTPAD";
1920 case DT_MOVETAB: return "MOVETAB";
1921 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1923 case DT_VERSYM: return "VERSYM";
1925 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1926 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1927 case DT_RELACOUNT: return "RELACOUNT";
1928 case DT_RELCOUNT: return "RELCOUNT";
1929 case DT_FLAGS_1: return "FLAGS_1";
1930 case DT_VERDEF: return "VERDEF";
1931 case DT_VERDEFNUM: return "VERDEFNUM";
1932 case DT_VERNEED: return "VERNEED";
1933 case DT_VERNEEDNUM: return "VERNEEDNUM";
1935 case DT_AUXILIARY: return "AUXILIARY";
1936 case DT_USED: return "USED";
1937 case DT_FILTER: return "FILTER";
1939 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1940 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1941 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1942 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1943 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1944 case DT_GNU_HASH: return "GNU_HASH";
1947 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1949 const char * result;
1951 switch (elf_header.e_machine)
1954 case EM_MIPS_RS3_LE:
1955 result = get_mips_dynamic_type (type);
1958 result = get_sparc64_dynamic_type (type);
1961 result = get_ppc_dynamic_type (type);
1964 result = get_ppc64_dynamic_type (type);
1967 result = get_ia64_dynamic_type (type);
1970 result = get_alpha_dynamic_type (type);
1973 result = get_score_dynamic_type (type);
1976 result = get_tic6x_dynamic_type (type);
1978 case EM_ALTERA_NIOS2:
1979 result = get_nios2_dynamic_type (type);
1989 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1991 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1992 || (elf_header.e_machine == EM_PARISC
1993 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1995 const char * result;
1997 switch (elf_header.e_machine)
2000 result = get_parisc_dynamic_type (type);
2003 result = get_ia64_dynamic_type (type);
2013 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2017 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2024 get_file_type (unsigned e_type)
2026 static char buff[32];
2030 case ET_NONE: return _("NONE (None)");
2031 case ET_REL: return _("REL (Relocatable file)");
2032 case ET_EXEC: return _("EXEC (Executable file)");
2033 case ET_DYN: return _("DYN (Shared object file)");
2034 case ET_CORE: return _("CORE (Core file)");
2037 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2038 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2039 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2040 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2042 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2048 get_machine_name (unsigned e_machine)
2050 static char buff[64]; /* XXX */
2054 case EM_NONE: return _("None");
2055 case EM_AARCH64: return "AArch64";
2056 case EM_M32: return "WE32100";
2057 case EM_SPARC: return "Sparc";
2058 case EM_SPU: return "SPU";
2059 case EM_386: return "Intel 80386";
2060 case EM_68K: return "MC68000";
2061 case EM_88K: return "MC88000";
2062 case EM_486: return "Intel 80486";
2063 case EM_860: return "Intel 80860";
2064 case EM_MIPS: return "MIPS R3000";
2065 case EM_S370: return "IBM System/370";
2066 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2067 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2068 case EM_PARISC: return "HPPA";
2069 case EM_PPC_OLD: return "Power PC (old)";
2070 case EM_SPARC32PLUS: return "Sparc v8+" ;
2071 case EM_960: return "Intel 90860";
2072 case EM_PPC: return "PowerPC";
2073 case EM_PPC64: return "PowerPC64";
2074 case EM_FR20: return "Fujitsu FR20";
2075 case EM_RH32: return "TRW RH32";
2076 case EM_MCORE: return "MCORE";
2077 case EM_ARM: return "ARM";
2078 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2079 case EM_SH: return "Renesas / SuperH SH";
2080 case EM_SPARCV9: return "Sparc v9";
2081 case EM_TRICORE: return "Siemens Tricore";
2082 case EM_ARC: return "ARC";
2083 case EM_H8_300: return "Renesas H8/300";
2084 case EM_H8_300H: return "Renesas H8/300H";
2085 case EM_H8S: return "Renesas H8S";
2086 case EM_H8_500: return "Renesas H8/500";
2087 case EM_IA_64: return "Intel IA-64";
2088 case EM_MIPS_X: return "Stanford MIPS-X";
2089 case EM_COLDFIRE: return "Motorola Coldfire";
2090 case EM_ALPHA: return "Alpha";
2091 case EM_CYGNUS_D10V:
2092 case EM_D10V: return "d10v";
2093 case EM_CYGNUS_D30V:
2094 case EM_D30V: return "d30v";
2095 case EM_CYGNUS_M32R:
2096 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2097 case EM_CYGNUS_V850:
2098 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2099 case EM_V850: return "Renesas V850";
2100 case EM_CYGNUS_MN10300:
2101 case EM_MN10300: return "mn10300";
2102 case EM_CYGNUS_MN10200:
2103 case EM_MN10200: return "mn10200";
2104 case EM_MOXIE: return "Moxie";
2105 case EM_CYGNUS_FR30:
2106 case EM_FR30: return "Fujitsu FR30";
2107 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2109 case EM_PJ: return "picoJava";
2110 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2111 case EM_PCP: return "Siemens PCP";
2112 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2113 case EM_NDR1: return "Denso NDR1 microprocesspr";
2114 case EM_STARCORE: return "Motorola Star*Core processor";
2115 case EM_ME16: return "Toyota ME16 processor";
2116 case EM_ST100: return "STMicroelectronics ST100 processor";
2117 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2118 case EM_PDSP: return "Sony DSP processor";
2119 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2120 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2121 case EM_FX66: return "Siemens FX66 microcontroller";
2122 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2123 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2124 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2125 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2126 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2127 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2128 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2129 case EM_SVX: return "Silicon Graphics SVx";
2130 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2131 case EM_VAX: return "Digital VAX";
2132 case EM_VISIUM: return "CDS VISIUMcore processor";
2134 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2135 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2136 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2137 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2138 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2139 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2140 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2141 case EM_PRISM: return "Vitesse Prism";
2142 case EM_X86_64: return "Advanced Micro Devices X86-64";
2143 case EM_L1OM: return "Intel L1OM";
2144 case EM_K1OM: return "Intel K1OM";
2146 case EM_S390: return "IBM S/390";
2147 case EM_SCORE: return "SUNPLUS S+Core";
2148 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2149 case EM_OR1K: return "OpenRISC 1000";
2150 case EM_ARC_A5: return "ARC International ARCompact processor";
2151 case EM_CRX: return "National Semiconductor CRX microprocessor";
2152 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2153 case EM_DLX: return "OpenDLX";
2155 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2156 case EM_IQ2000: return "Vitesse IQ2000";
2158 case EM_XTENSA: return "Tensilica Xtensa Processor";
2159 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2160 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2161 case EM_NS32K: return "National Semiconductor 32000 series";
2162 case EM_TPC: return "Tenor Network TPC processor";
2163 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2164 case EM_MAX: return "MAX Processor";
2165 case EM_CR: return "National Semiconductor CompactRISC";
2166 case EM_F2MC16: return "Fujitsu F2MC16";
2167 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2168 case EM_LATTICEMICO32: return "Lattice Mico32";
2170 case EM_M32C: return "Renesas M32c";
2171 case EM_MT: return "Morpho Techologies MT processor";
2172 case EM_BLACKFIN: return "Analog Devices Blackfin";
2173 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2174 case EM_SEP: return "Sharp embedded microprocessor";
2175 case EM_ARCA: return "Arca RISC microprocessor";
2176 case EM_UNICORE: return "Unicore";
2177 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2178 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2179 case EM_NIOS32: return "Altera Nios";
2180 case EM_ALTERA_NIOS2: return "Altera Nios II";
2182 case EM_XC16X: return "Infineon Technologies xc16x";
2183 case EM_M16C: return "Renesas M16C series microprocessors";
2184 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2185 case EM_CE: return "Freescale Communication Engine RISC core";
2186 case EM_TSK3000: return "Altium TSK3000 core";
2187 case EM_RS08: return "Freescale RS08 embedded processor";
2188 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2189 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2190 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2191 case EM_SE_C17: return "Seiko Epson C17 family";
2192 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2193 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2194 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2195 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2196 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2197 case EM_R32C: return "Renesas R32C series microprocessors";
2198 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2199 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2200 case EM_8051: return "Intel 8051 and variants";
2201 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2202 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2203 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2204 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2205 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2206 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2207 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2208 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2211 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2212 case EM_RL78: return "Renesas RL78";
2213 case EM_RX: return "Renesas RX";
2214 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2215 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2216 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2217 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2218 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2219 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2220 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2221 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2222 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2223 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2224 case EM_CUDA: return "NVIDIA CUDA architecture";
2225 case EM_XGATE: return "Motorola XGATE embedded processor";
2227 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2233 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2238 eabi = EF_ARM_EABI_VERSION (e_flags);
2239 e_flags &= ~ EF_ARM_EABIMASK;
2241 /* Handle "generic" ARM flags. */
2242 if (e_flags & EF_ARM_RELEXEC)
2244 strcat (buf, ", relocatable executable");
2245 e_flags &= ~ EF_ARM_RELEXEC;
2248 if (e_flags & EF_ARM_HASENTRY)
2250 strcat (buf, ", has entry point");
2251 e_flags &= ~ EF_ARM_HASENTRY;
2254 /* Now handle EABI specific flags. */
2258 strcat (buf, ", <unrecognized EABI>");
2263 case EF_ARM_EABI_VER1:
2264 strcat (buf, ", Version1 EABI");
2269 /* Process flags one bit at a time. */
2270 flag = e_flags & - e_flags;
2275 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2276 strcat (buf, ", sorted symbol tables");
2286 case EF_ARM_EABI_VER2:
2287 strcat (buf, ", Version2 EABI");
2292 /* Process flags one bit at a time. */
2293 flag = e_flags & - e_flags;
2298 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2299 strcat (buf, ", sorted symbol tables");
2302 case EF_ARM_DYNSYMSUSESEGIDX:
2303 strcat (buf, ", dynamic symbols use segment index");
2306 case EF_ARM_MAPSYMSFIRST:
2307 strcat (buf, ", mapping symbols precede others");
2317 case EF_ARM_EABI_VER3:
2318 strcat (buf, ", Version3 EABI");
2321 case EF_ARM_EABI_VER4:
2322 strcat (buf, ", Version4 EABI");
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2334 strcat (buf, ", BE8");
2338 strcat (buf, ", LE8");
2349 case EF_ARM_EABI_VER5:
2350 strcat (buf, ", Version5 EABI");
2355 /* Process flags one bit at a time. */
2356 flag = e_flags & - e_flags;
2362 strcat (buf, ", BE8");
2366 strcat (buf, ", LE8");
2369 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2370 strcat (buf, ", soft-float ABI");
2373 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2374 strcat (buf, ", hard-float ABI");
2384 case EF_ARM_EABI_UNKNOWN:
2385 strcat (buf, ", GNU EABI");
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2396 case EF_ARM_INTERWORK:
2397 strcat (buf, ", interworking enabled");
2400 case EF_ARM_APCS_26:
2401 strcat (buf, ", uses APCS/26");
2404 case EF_ARM_APCS_FLOAT:
2405 strcat (buf, ", uses APCS/float");
2409 strcat (buf, ", position independent");
2413 strcat (buf, ", 8 bit structure alignment");
2416 case EF_ARM_NEW_ABI:
2417 strcat (buf, ", uses new ABI");
2420 case EF_ARM_OLD_ABI:
2421 strcat (buf, ", uses old ABI");
2424 case EF_ARM_SOFT_FLOAT:
2425 strcat (buf, ", software FP");
2428 case EF_ARM_VFP_FLOAT:
2429 strcat (buf, ", VFP");
2432 case EF_ARM_MAVERICK_FLOAT:
2433 strcat (buf, ", Maverick FP");
2444 strcat (buf,_(", <unknown>"));
2448 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2450 --size; /* Leave space for null terminator. */
2452 switch (e_flags & EF_AVR_MACH)
2454 case E_AVR_MACH_AVR1:
2455 strncat (buf, ", avr:1", size);
2457 case E_AVR_MACH_AVR2:
2458 strncat (buf, ", avr:2", size);
2460 case E_AVR_MACH_AVR25:
2461 strncat (buf, ", avr:25", size);
2463 case E_AVR_MACH_AVR3:
2464 strncat (buf, ", avr:3", size);
2466 case E_AVR_MACH_AVR31:
2467 strncat (buf, ", avr:31", size);
2469 case E_AVR_MACH_AVR35:
2470 strncat (buf, ", avr:35", size);
2472 case E_AVR_MACH_AVR4:
2473 strncat (buf, ", avr:4", size);
2475 case E_AVR_MACH_AVR5:
2476 strncat (buf, ", avr:5", size);
2478 case E_AVR_MACH_AVR51:
2479 strncat (buf, ", avr:51", size);
2481 case E_AVR_MACH_AVR6:
2482 strncat (buf, ", avr:6", size);
2484 case E_AVR_MACH_AVRTINY:
2485 strncat (buf, ", avr:100", size);
2487 case E_AVR_MACH_XMEGA1:
2488 strncat (buf, ", avr:101", size);
2490 case E_AVR_MACH_XMEGA2:
2491 strncat (buf, ", avr:102", size);
2493 case E_AVR_MACH_XMEGA3:
2494 strncat (buf, ", avr:103", size);
2496 case E_AVR_MACH_XMEGA4:
2497 strncat (buf, ", avr:104", size);
2499 case E_AVR_MACH_XMEGA5:
2500 strncat (buf, ", avr:105", size);
2502 case E_AVR_MACH_XMEGA6:
2503 strncat (buf, ", avr:106", size);
2505 case E_AVR_MACH_XMEGA7:
2506 strncat (buf, ", avr:107", size);
2509 strncat (buf, ", avr:<unknown>", size);
2513 size -= strlen (buf);
2514 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2515 strncat (buf, ", link-relax", size);
2519 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2528 static const char *ABI_STRINGS[] =
2530 "ABI v0", /* use r5 as return register; only used in N1213HC */
2531 "ABI v1", /* use r0 as return register */
2532 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2533 "ABI v2fp", /* for FPU */
2537 static const char *VER_STRINGS[] =
2539 "Andes ELF V1.3 or older",
2543 static const char *ARCH_STRINGS[] =
2552 abi = EF_NDS_ABI & e_flags;
2553 arch = EF_NDS_ARCH & e_flags;
2554 config = EF_NDS_INST & e_flags;
2555 version = EF_NDS32_ELF_VERSION & e_flags;
2557 memset (buf, 0, size);
2564 case E_NDS_ABI_V2FP:
2565 case E_NDS_ABI_AABI:
2566 case E_NDS_ABI_V2FP_PLUS:
2567 /* In case there are holes in the array. */
2568 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2572 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2578 case E_NDS32_ELF_VER_1_2:
2579 case E_NDS32_ELF_VER_1_3:
2580 case E_NDS32_ELF_VER_1_4:
2581 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2585 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2589 if (E_NDS_ABI_V0 == abi)
2591 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2592 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2593 if (arch == E_NDS_ARCH_STAR_V1_0)
2594 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2600 case E_NDS_ARCH_STAR_V1_0:
2601 case E_NDS_ARCH_STAR_V2_0:
2602 case E_NDS_ARCH_STAR_V3_0:
2603 case E_NDS_ARCH_STAR_V3_M:
2604 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2608 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2609 /* ARCH version determines how the e_flags are interpreted.
2610 If it is unknown, we cannot proceed. */
2614 /* Newer ABI; Now handle architecture specific flags. */
2615 if (arch == E_NDS_ARCH_STAR_V1_0)
2617 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2618 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2620 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2621 r += snprintf (buf + r, size -r, ", MAC");
2623 if (config & E_NDS32_HAS_DIV_INST)
2624 r += snprintf (buf + r, size -r, ", DIV");
2626 if (config & E_NDS32_HAS_16BIT_INST)
2627 r += snprintf (buf + r, size -r, ", 16b");
2631 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2633 if (version <= E_NDS32_ELF_VER_1_3)
2634 r += snprintf (buf + r, size -r, ", [B8]");
2636 r += snprintf (buf + r, size -r, ", EX9");
2639 if (config & E_NDS32_HAS_MAC_DX_INST)
2640 r += snprintf (buf + r, size -r, ", MAC_DX");
2642 if (config & E_NDS32_HAS_DIV_DX_INST)
2643 r += snprintf (buf + r, size -r, ", DIV_DX");
2645 if (config & E_NDS32_HAS_16BIT_INST)
2647 if (version <= E_NDS32_ELF_VER_1_3)
2648 r += snprintf (buf + r, size -r, ", 16b");
2650 r += snprintf (buf + r, size -r, ", IFC");
2654 if (config & E_NDS32_HAS_EXT_INST)
2655 r += snprintf (buf + r, size -r, ", PERF1");
2657 if (config & E_NDS32_HAS_EXT2_INST)
2658 r += snprintf (buf + r, size -r, ", PERF2");
2660 if (config & E_NDS32_HAS_FPU_INST)
2663 r += snprintf (buf + r, size -r, ", FPU_SP");
2666 if (config & E_NDS32_HAS_FPU_DP_INST)
2669 r += snprintf (buf + r, size -r, ", FPU_DP");
2672 if (config & E_NDS32_HAS_FPU_MAC_INST)
2675 r += snprintf (buf + r, size -r, ", FPU_MAC");
2680 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2682 case E_NDS32_FPU_REG_8SP_4DP:
2683 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2685 case E_NDS32_FPU_REG_16SP_8DP:
2686 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2688 case E_NDS32_FPU_REG_32SP_16DP:
2689 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2691 case E_NDS32_FPU_REG_32SP_32DP:
2692 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2697 if (config & E_NDS32_HAS_AUDIO_INST)
2698 r += snprintf (buf + r, size -r, ", AUDIO");
2700 if (config & E_NDS32_HAS_STRING_INST)
2701 r += snprintf (buf + r, size -r, ", STR");
2703 if (config & E_NDS32_HAS_REDUCED_REGS)
2704 r += snprintf (buf + r, size -r, ", 16REG");
2706 if (config & E_NDS32_HAS_VIDEO_INST)
2708 if (version <= E_NDS32_ELF_VER_1_3)
2709 r += snprintf (buf + r, size -r, ", VIDEO");
2711 r += snprintf (buf + r, size -r, ", SATURATION");
2714 if (config & E_NDS32_HAS_ENCRIPT_INST)
2715 r += snprintf (buf + r, size -r, ", ENCRP");
2717 if (config & E_NDS32_HAS_L2C_INST)
2718 r += snprintf (buf + r, size -r, ", L2C");
2722 get_machine_flags (unsigned e_flags, unsigned e_machine)
2724 static char buf[1024];
2736 decode_ARM_machine_flags (e_flags, buf);
2740 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2744 if (e_flags & EF_BFIN_PIC)
2745 strcat (buf, ", PIC");
2747 if (e_flags & EF_BFIN_FDPIC)
2748 strcat (buf, ", FDPIC");
2750 if (e_flags & EF_BFIN_CODE_IN_L1)
2751 strcat (buf, ", code in L1");
2753 if (e_flags & EF_BFIN_DATA_IN_L1)
2754 strcat (buf, ", data in L1");
2759 switch (e_flags & EF_FRV_CPU_MASK)
2761 case EF_FRV_CPU_GENERIC:
2765 strcat (buf, ", fr???");
2768 case EF_FRV_CPU_FR300:
2769 strcat (buf, ", fr300");
2772 case EF_FRV_CPU_FR400:
2773 strcat (buf, ", fr400");
2775 case EF_FRV_CPU_FR405:
2776 strcat (buf, ", fr405");
2779 case EF_FRV_CPU_FR450:
2780 strcat (buf, ", fr450");
2783 case EF_FRV_CPU_FR500:
2784 strcat (buf, ", fr500");
2786 case EF_FRV_CPU_FR550:
2787 strcat (buf, ", fr550");
2790 case EF_FRV_CPU_SIMPLE:
2791 strcat (buf, ", simple");
2793 case EF_FRV_CPU_TOMCAT:
2794 strcat (buf, ", tomcat");
2800 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2801 strcat (buf, ", m68000");
2802 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2803 strcat (buf, ", cpu32");
2804 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2805 strcat (buf, ", fido_a");
2808 char const * isa = _("unknown");
2809 char const * mac = _("unknown mac");
2810 char const * additional = NULL;
2812 switch (e_flags & EF_M68K_CF_ISA_MASK)
2814 case EF_M68K_CF_ISA_A_NODIV:
2816 additional = ", nodiv";
2818 case EF_M68K_CF_ISA_A:
2821 case EF_M68K_CF_ISA_A_PLUS:
2824 case EF_M68K_CF_ISA_B_NOUSP:
2826 additional = ", nousp";
2828 case EF_M68K_CF_ISA_B:
2831 case EF_M68K_CF_ISA_C:
2834 case EF_M68K_CF_ISA_C_NODIV:
2836 additional = ", nodiv";
2839 strcat (buf, ", cf, isa ");
2842 strcat (buf, additional);
2843 if (e_flags & EF_M68K_CF_FLOAT)
2844 strcat (buf, ", float");
2845 switch (e_flags & EF_M68K_CF_MAC_MASK)
2850 case EF_M68K_CF_MAC:
2853 case EF_M68K_CF_EMAC:
2856 case EF_M68K_CF_EMAC_B:
2869 if (e_flags & EF_PPC_EMB)
2870 strcat (buf, ", emb");
2872 if (e_flags & EF_PPC_RELOCATABLE)
2873 strcat (buf, _(", relocatable"));
2875 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2876 strcat (buf, _(", relocatable-lib"));
2880 if (e_flags & EF_PPC64_ABI)
2882 char abi[] = ", abiv0";
2884 abi[6] += e_flags & EF_PPC64_ABI;
2890 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2891 strcat (buf, ", RH850 ABI");
2893 if (e_flags & EF_V800_850E3)
2894 strcat (buf, ", V3 architecture");
2896 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2897 strcat (buf, ", FPU not used");
2899 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2900 strcat (buf, ", regmode: COMMON");
2902 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2903 strcat (buf, ", r4 not used");
2905 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2906 strcat (buf, ", r30 not used");
2908 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2909 strcat (buf, ", r5 not used");
2911 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2912 strcat (buf, ", r2 not used");
2914 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2916 switch (e_flags & - e_flags)
2918 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2919 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2920 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2921 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2922 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2923 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2924 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2925 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2926 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2927 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2928 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2929 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2930 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2931 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2932 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2933 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2940 case EM_CYGNUS_V850:
2941 switch (e_flags & EF_V850_ARCH)
2943 case E_V850E3V5_ARCH:
2944 strcat (buf, ", v850e3v5");
2946 case E_V850E2V3_ARCH:
2947 strcat (buf, ", v850e2v3");
2950 strcat (buf, ", v850e2");
2953 strcat (buf, ", v850e1");
2956 strcat (buf, ", v850e");
2959 strcat (buf, ", v850");
2962 strcat (buf, _(", unknown v850 architecture variant"));
2968 case EM_CYGNUS_M32R:
2969 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2970 strcat (buf, ", m32r");
2974 case EM_MIPS_RS3_LE:
2975 if (e_flags & EF_MIPS_NOREORDER)
2976 strcat (buf, ", noreorder");
2978 if (e_flags & EF_MIPS_PIC)
2979 strcat (buf, ", pic");
2981 if (e_flags & EF_MIPS_CPIC)
2982 strcat (buf, ", cpic");
2984 if (e_flags & EF_MIPS_UCODE)
2985 strcat (buf, ", ugen_reserved");
2987 if (e_flags & EF_MIPS_ABI2)
2988 strcat (buf, ", abi2");
2990 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2991 strcat (buf, ", odk first");
2993 if (e_flags & EF_MIPS_32BITMODE)
2994 strcat (buf, ", 32bitmode");
2996 if (e_flags & EF_MIPS_NAN2008)
2997 strcat (buf, ", nan2008");
2999 if (e_flags & EF_MIPS_FP64)
3000 strcat (buf, ", fp64");
3002 switch ((e_flags & EF_MIPS_MACH))
3004 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3005 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3006 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3007 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3008 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3009 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3010 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3011 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3012 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3013 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3014 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3015 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3016 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3017 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3018 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3019 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3020 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3022 /* We simply ignore the field in this case to avoid confusion:
3023 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3026 default: strcat (buf, _(", unknown CPU")); break;
3029 switch ((e_flags & EF_MIPS_ABI))
3031 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3032 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3033 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3034 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3036 /* We simply ignore the field in this case to avoid confusion:
3037 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3038 This means it is likely to be an o32 file, but not for
3041 default: strcat (buf, _(", unknown ABI")); break;
3044 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3045 strcat (buf, ", mdmx");
3047 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3048 strcat (buf, ", mips16");
3050 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3051 strcat (buf, ", micromips");
3053 switch ((e_flags & EF_MIPS_ARCH))
3055 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3056 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3057 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3058 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3059 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3060 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3061 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3062 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3063 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3064 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3065 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3066 default: strcat (buf, _(", unknown ISA")); break;
3071 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3075 switch ((e_flags & EF_SH_MACH_MASK))
3077 case EF_SH1: strcat (buf, ", sh1"); break;
3078 case EF_SH2: strcat (buf, ", sh2"); break;
3079 case EF_SH3: strcat (buf, ", sh3"); break;
3080 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3081 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3082 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3083 case EF_SH3E: strcat (buf, ", sh3e"); break;
3084 case EF_SH4: strcat (buf, ", sh4"); break;
3085 case EF_SH5: strcat (buf, ", sh5"); break;
3086 case EF_SH2E: strcat (buf, ", sh2e"); break;
3087 case EF_SH4A: strcat (buf, ", sh4a"); break;
3088 case EF_SH2A: strcat (buf, ", sh2a"); break;
3089 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3090 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3091 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3092 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3093 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3094 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3095 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3096 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3097 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3098 default: strcat (buf, _(", unknown ISA")); break;
3101 if (e_flags & EF_SH_PIC)
3102 strcat (buf, ", pic");
3104 if (e_flags & EF_SH_FDPIC)
3105 strcat (buf, ", fdpic");
3109 if (e_flags & EF_OR1K_NODELAY)
3110 strcat (buf, ", no delay");
3114 if (e_flags & EF_SPARC_32PLUS)
3115 strcat (buf, ", v8+");
3117 if (e_flags & EF_SPARC_SUN_US1)
3118 strcat (buf, ", ultrasparcI");
3120 if (e_flags & EF_SPARC_SUN_US3)
3121 strcat (buf, ", ultrasparcIII");
3123 if (e_flags & EF_SPARC_HAL_R1)
3124 strcat (buf, ", halr1");
3126 if (e_flags & EF_SPARC_LEDATA)
3127 strcat (buf, ", ledata");
3129 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3130 strcat (buf, ", tso");
3132 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3133 strcat (buf, ", pso");
3135 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3136 strcat (buf, ", rmo");
3140 switch (e_flags & EF_PARISC_ARCH)
3142 case EFA_PARISC_1_0:
3143 strcpy (buf, ", PA-RISC 1.0");
3145 case EFA_PARISC_1_1:
3146 strcpy (buf, ", PA-RISC 1.1");
3148 case EFA_PARISC_2_0:
3149 strcpy (buf, ", PA-RISC 2.0");
3154 if (e_flags & EF_PARISC_TRAPNIL)
3155 strcat (buf, ", trapnil");
3156 if (e_flags & EF_PARISC_EXT)
3157 strcat (buf, ", ext");
3158 if (e_flags & EF_PARISC_LSB)
3159 strcat (buf, ", lsb");
3160 if (e_flags & EF_PARISC_WIDE)
3161 strcat (buf, ", wide");
3162 if (e_flags & EF_PARISC_NO_KABP)
3163 strcat (buf, ", no kabp");
3164 if (e_flags & EF_PARISC_LAZYSWAP)
3165 strcat (buf, ", lazyswap");
3170 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3171 strcat (buf, ", new calling convention");
3173 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3174 strcat (buf, ", gnu calling convention");
3178 if ((e_flags & EF_IA_64_ABI64))
3179 strcat (buf, ", 64-bit");
3181 strcat (buf, ", 32-bit");
3182 if ((e_flags & EF_IA_64_REDUCEDFP))
3183 strcat (buf, ", reduced fp model");
3184 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3185 strcat (buf, ", no function descriptors, constant gp");
3186 else if ((e_flags & EF_IA_64_CONS_GP))
3187 strcat (buf, ", constant gp");
3188 if ((e_flags & EF_IA_64_ABSOLUTE))
3189 strcat (buf, ", absolute");
3190 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3192 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3193 strcat (buf, ", vms_linkages");
3194 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3196 case EF_IA_64_VMS_COMCOD_SUCCESS:
3198 case EF_IA_64_VMS_COMCOD_WARNING:
3199 strcat (buf, ", warning");
3201 case EF_IA_64_VMS_COMCOD_ERROR:
3202 strcat (buf, ", error");
3204 case EF_IA_64_VMS_COMCOD_ABORT:
3205 strcat (buf, ", abort");
3208 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3209 e_flags & EF_IA_64_VMS_COMCOD);
3210 strcat (buf, ", <unknown>");
3216 if ((e_flags & EF_VAX_NONPIC))
3217 strcat (buf, ", non-PIC");
3218 if ((e_flags & EF_VAX_DFLOAT))
3219 strcat (buf, ", D-Float");
3220 if ((e_flags & EF_VAX_GFLOAT))
3221 strcat (buf, ", G-Float");
3225 if (e_flags & EF_VISIUM_ARCH_MCM)
3226 strcat (buf, ", mcm");
3227 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3228 strcat (buf, ", mcm24");
3229 if (e_flags & EF_VISIUM_ARCH_GR6)
3230 strcat (buf, ", gr6");
3234 if (e_flags & E_FLAG_RL78_G10)
3235 strcat (buf, ", G10");
3236 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3237 strcat (buf, ", 64-bit doubles");
3241 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3242 strcat (buf, ", 64-bit doubles");
3243 if (e_flags & E_FLAG_RX_DSP)
3244 strcat (buf, ", dsp");
3245 if (e_flags & E_FLAG_RX_PID)
3246 strcat (buf, ", pid");
3247 if (e_flags & E_FLAG_RX_ABI)
3248 strcat (buf, ", RX ABI");
3252 if (e_flags & EF_S390_HIGH_GPRS)
3253 strcat (buf, ", highgprs");
3257 if ((e_flags & EF_C6000_REL))
3258 strcat (buf, ", relocatable module");
3262 strcat (buf, _(": architecture variant: "));
3263 switch (e_flags & EF_MSP430_MACH)
3265 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3266 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3267 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3268 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3269 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3270 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3271 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3272 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3273 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3274 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3275 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3276 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3277 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3278 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3279 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3281 strcat (buf, _(": unknown")); break;
3284 if (e_flags & ~ EF_MSP430_MACH)
3285 strcat (buf, _(": unknown extra flag bits also present"));
3293 get_osabi_name (unsigned int osabi)
3295 static char buff[32];
3299 case ELFOSABI_NONE: return "UNIX - System V";
3300 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3301 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3302 case ELFOSABI_GNU: return "UNIX - GNU";
3303 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3304 case ELFOSABI_AIX: return "UNIX - AIX";
3305 case ELFOSABI_IRIX: return "UNIX - IRIX";
3306 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3307 case ELFOSABI_TRU64: return "UNIX - TRU64";
3308 case ELFOSABI_MODESTO: return "Novell - Modesto";
3309 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3310 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3311 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3312 case ELFOSABI_AROS: return "AROS";
3313 case ELFOSABI_FENIXOS: return "FenixOS";
3316 switch (elf_header.e_machine)
3321 case ELFOSABI_ARM: return "ARM";
3332 case ELFOSABI_STANDALONE: return _("Standalone App");
3341 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3342 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3351 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3357 get_aarch64_segment_type (unsigned long type)
3361 case PT_AARCH64_ARCHEXT:
3362 return "AARCH64_ARCHEXT";
3371 get_arm_segment_type (unsigned long type)
3385 get_mips_segment_type (unsigned long type)
3389 case PT_MIPS_REGINFO:
3391 case PT_MIPS_RTPROC:
3393 case PT_MIPS_OPTIONS:
3395 case PT_MIPS_ABIFLAGS:
3405 get_parisc_segment_type (unsigned long type)
3409 case PT_HP_TLS: return "HP_TLS";
3410 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3411 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3412 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3413 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3414 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3415 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3416 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3417 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3418 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3419 case PT_HP_PARALLEL: return "HP_PARALLEL";
3420 case PT_HP_FASTBIND: return "HP_FASTBIND";
3421 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3422 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3423 case PT_HP_STACK: return "HP_STACK";
3424 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3425 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3426 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3427 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3436 get_ia64_segment_type (unsigned long type)
3440 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3441 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3442 case PT_HP_TLS: return "HP_TLS";
3443 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3444 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3445 case PT_IA_64_HP_STACK: return "HP_STACK";
3454 get_tic6x_segment_type (unsigned long type)
3458 case PT_C6000_PHATTR: return "C6000_PHATTR";
3467 get_segment_type (unsigned long p_type)
3469 static char buff[32];
3473 case PT_NULL: return "NULL";
3474 case PT_LOAD: return "LOAD";
3475 case PT_DYNAMIC: return "DYNAMIC";
3476 case PT_INTERP: return "INTERP";
3477 case PT_NOTE: return "NOTE";
3478 case PT_SHLIB: return "SHLIB";
3479 case PT_PHDR: return "PHDR";
3480 case PT_TLS: return "TLS";
3482 case PT_GNU_EH_FRAME:
3483 return "GNU_EH_FRAME";
3484 case PT_GNU_STACK: return "GNU_STACK";
3485 case PT_GNU_RELRO: return "GNU_RELRO";
3488 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3490 const char * result;
3492 switch (elf_header.e_machine)
3495 result = get_aarch64_segment_type (p_type);
3498 result = get_arm_segment_type (p_type);
3501 case EM_MIPS_RS3_LE:
3502 result = get_mips_segment_type (p_type);
3505 result = get_parisc_segment_type (p_type);
3508 result = get_ia64_segment_type (p_type);
3511 result = get_tic6x_segment_type (p_type);
3521 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3523 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3525 const char * result;
3527 switch (elf_header.e_machine)
3530 result = get_parisc_segment_type (p_type);
3533 result = get_ia64_segment_type (p_type);
3543 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3546 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3553 get_mips_section_type_name (unsigned int sh_type)
3557 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3558 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3559 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3560 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3561 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3562 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3563 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3564 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3565 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3566 case SHT_MIPS_RELD: return "MIPS_RELD";
3567 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3568 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3569 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3570 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3571 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3572 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3573 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3574 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3575 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3576 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3577 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3578 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3579 case SHT_MIPS_LINE: return "MIPS_LINE";
3580 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3581 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3582 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3583 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3584 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3585 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3586 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3587 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3588 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3589 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3590 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3591 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3592 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3593 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3594 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3595 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3596 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3604 get_parisc_section_type_name (unsigned int sh_type)
3608 case SHT_PARISC_EXT: return "PARISC_EXT";
3609 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3610 case SHT_PARISC_DOC: return "PARISC_DOC";
3611 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3612 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3613 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3614 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3622 get_ia64_section_type_name (unsigned int sh_type)
3624 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3625 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3626 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3630 case SHT_IA_64_EXT: return "IA_64_EXT";
3631 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3632 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3633 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3634 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3635 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3636 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3637 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3638 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3639 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3647 get_x86_64_section_type_name (unsigned int sh_type)
3651 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3659 get_aarch64_section_type_name (unsigned int sh_type)
3663 case SHT_AARCH64_ATTRIBUTES:
3664 return "AARCH64_ATTRIBUTES";
3672 get_arm_section_type_name (unsigned int sh_type)
3676 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3677 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3678 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3679 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3680 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3688 get_tic6x_section_type_name (unsigned int sh_type)
3692 case SHT_C6000_UNWIND:
3693 return "C6000_UNWIND";
3694 case SHT_C6000_PREEMPTMAP:
3695 return "C6000_PREEMPTMAP";
3696 case SHT_C6000_ATTRIBUTES:
3697 return "C6000_ATTRIBUTES";
3702 case SHT_TI_HANDLER:
3703 return "TI_HANDLER";
3704 case SHT_TI_INITINFO:
3705 return "TI_INITINFO";
3706 case SHT_TI_PHATTRS:
3707 return "TI_PHATTRS";
3715 get_msp430x_section_type_name (unsigned int sh_type)
3719 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3720 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3721 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3722 default: return NULL;
3727 get_section_type_name (unsigned int sh_type)
3729 static char buff[32];
3733 case SHT_NULL: return "NULL";
3734 case SHT_PROGBITS: return "PROGBITS";
3735 case SHT_SYMTAB: return "SYMTAB";
3736 case SHT_STRTAB: return "STRTAB";
3737 case SHT_RELA: return "RELA";
3738 case SHT_HASH: return "HASH";
3739 case SHT_DYNAMIC: return "DYNAMIC";
3740 case SHT_NOTE: return "NOTE";
3741 case SHT_NOBITS: return "NOBITS";
3742 case SHT_REL: return "REL";
3743 case SHT_SHLIB: return "SHLIB";
3744 case SHT_DYNSYM: return "DYNSYM";
3745 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3746 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3747 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3748 case SHT_GNU_HASH: return "GNU_HASH";
3749 case SHT_GROUP: return "GROUP";
3750 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3751 case SHT_GNU_verdef: return "VERDEF";
3752 case SHT_GNU_verneed: return "VERNEED";
3753 case SHT_GNU_versym: return "VERSYM";
3754 case 0x6ffffff0: return "VERSYM";
3755 case 0x6ffffffc: return "VERDEF";
3756 case 0x7ffffffd: return "AUXILIARY";
3757 case 0x7fffffff: return "FILTER";
3758 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3761 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3763 const char * result;
3765 switch (elf_header.e_machine)
3768 case EM_MIPS_RS3_LE:
3769 result = get_mips_section_type_name (sh_type);
3772 result = get_parisc_section_type_name (sh_type);
3775 result = get_ia64_section_type_name (sh_type);
3780 result = get_x86_64_section_type_name (sh_type);
3783 result = get_aarch64_section_type_name (sh_type);
3786 result = get_arm_section_type_name (sh_type);
3789 result = get_tic6x_section_type_name (sh_type);
3792 result = get_msp430x_section_type_name (sh_type);
3802 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3804 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3806 const char * result;
3808 switch (elf_header.e_machine)
3811 result = get_ia64_section_type_name (sh_type);
3821 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3823 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3824 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3826 /* This message is probably going to be displayed in a 15
3827 character wide field, so put the hex value first. */
3828 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3834 #define OPTION_DEBUG_DUMP 512
3835 #define OPTION_DYN_SYMS 513
3836 #define OPTION_DWARF_DEPTH 514
3837 #define OPTION_DWARF_START 515
3838 #define OPTION_DWARF_CHECK 516
3840 static struct option options[] =
3842 {"all", no_argument, 0, 'a'},
3843 {"file-header", no_argument, 0, 'h'},
3844 {"program-headers", no_argument, 0, 'l'},
3845 {"headers", no_argument, 0, 'e'},
3846 {"histogram", no_argument, 0, 'I'},
3847 {"segments", no_argument, 0, 'l'},
3848 {"sections", no_argument, 0, 'S'},
3849 {"section-headers", no_argument, 0, 'S'},
3850 {"section-groups", no_argument, 0, 'g'},
3851 {"section-details", no_argument, 0, 't'},
3852 {"full-section-name",no_argument, 0, 'N'},
3853 {"symbols", no_argument, 0, 's'},
3854 {"syms", no_argument, 0, 's'},
3855 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3856 {"relocs", no_argument, 0, 'r'},
3857 {"notes", no_argument, 0, 'n'},
3858 {"dynamic", no_argument, 0, 'd'},
3859 {"arch-specific", no_argument, 0, 'A'},
3860 {"version-info", no_argument, 0, 'V'},
3861 {"use-dynamic", no_argument, 0, 'D'},
3862 {"unwind", no_argument, 0, 'u'},
3863 {"archive-index", no_argument, 0, 'c'},
3864 {"hex-dump", required_argument, 0, 'x'},
3865 {"relocated-dump", required_argument, 0, 'R'},
3866 {"string-dump", required_argument, 0, 'p'},
3867 #ifdef SUPPORT_DISASSEMBLY
3868 {"instruction-dump", required_argument, 0, 'i'},
3870 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3872 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3873 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3874 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3876 {"version", no_argument, 0, 'v'},
3877 {"wide", no_argument, 0, 'W'},
3878 {"help", no_argument, 0, 'H'},
3879 {0, no_argument, 0, 0}
3883 usage (FILE * stream)
3885 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3886 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3887 fprintf (stream, _(" Options are:\n\
3888 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3889 -h --file-header Display the ELF file header\n\
3890 -l --program-headers Display the program headers\n\
3891 --segments An alias for --program-headers\n\
3892 -S --section-headers Display the sections' header\n\
3893 --sections An alias for --section-headers\n\
3894 -g --section-groups Display the section groups\n\
3895 -t --section-details Display the section details\n\
3896 -e --headers Equivalent to: -h -l -S\n\
3897 -s --syms Display the symbol table\n\
3898 --symbols An alias for --syms\n\
3899 --dyn-syms Display the dynamic symbol table\n\
3900 -n --notes Display the core notes (if present)\n\
3901 -r --relocs Display the relocations (if present)\n\
3902 -u --unwind Display the unwind info (if present)\n\
3903 -d --dynamic Display the dynamic section (if present)\n\
3904 -V --version-info Display the version sections (if present)\n\
3905 -A --arch-specific Display architecture specific information (if any)\n\
3906 -c --archive-index Display the symbol/file index in an archive\n\
3907 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3908 -x --hex-dump=<number|name>\n\
3909 Dump the contents of section <number|name> as bytes\n\
3910 -p --string-dump=<number|name>\n\
3911 Dump the contents of section <number|name> as strings\n\
3912 -R --relocated-dump=<number|name>\n\
3913 Dump the contents of section <number|name> as relocated bytes\n\
3914 -w[lLiaprmfFsoRt] or\n\
3915 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3916 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3917 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3919 Display the contents of DWARF2 debug sections\n"));
3920 fprintf (stream, _("\
3921 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3922 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3924 #ifdef SUPPORT_DISASSEMBLY
3925 fprintf (stream, _("\
3926 -i --instruction-dump=<number|name>\n\
3927 Disassemble the contents of section <number|name>\n"));
3929 fprintf (stream, _("\
3930 -I --histogram Display histogram of bucket list lengths\n\
3931 -W --wide Allow output width to exceed 80 characters\n\
3932 @<file> Read options from <file>\n\
3933 -H --help Display this information\n\
3934 -v --version Display the version number of readelf\n"));
3936 if (REPORT_BUGS_TO[0] && stream == stdout)
3937 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3939 exit (stream == stdout ? 0 : 1);
3942 /* Record the fact that the user wants the contents of section number
3943 SECTION to be displayed using the method(s) encoded as flags bits
3944 in TYPE. Note, TYPE can be zero if we are creating the array for
3948 request_dump_bynumber (unsigned int section, dump_type type)
3950 if (section >= num_dump_sects)
3952 dump_type * new_dump_sects;
3954 new_dump_sects = (dump_type *) calloc (section + 1,
3955 sizeof (* dump_sects));
3957 if (new_dump_sects == NULL)
3958 error (_("Out of memory allocating dump request table.\n"));
3961 /* Copy current flag settings. */
3962 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3966 dump_sects = new_dump_sects;
3967 num_dump_sects = section + 1;
3972 dump_sects[section] |= type;
3977 /* Request a dump by section name. */
3980 request_dump_byname (const char * section, dump_type type)
3982 struct dump_list_entry * new_request;
3984 new_request = (struct dump_list_entry *)
3985 malloc (sizeof (struct dump_list_entry));
3987 error (_("Out of memory allocating dump request table.\n"));
3989 new_request->name = strdup (section);
3990 if (!new_request->name)
3991 error (_("Out of memory allocating dump request table.\n"));
3993 new_request->type = type;
3995 new_request->next = dump_sects_byname;
3996 dump_sects_byname = new_request;
4000 request_dump (dump_type type)
4006 section = strtoul (optarg, & cp, 0);
4008 if (! *cp && section >= 0)
4009 request_dump_bynumber (section, type);
4011 request_dump_byname (optarg, type);
4016 parse_args (int argc, char ** argv)
4023 while ((c = getopt_long
4024 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4042 do_section_groups++;
4050 do_section_groups++;
4055 do_section_details++;
4099 request_dump (HEX_DUMP);
4102 request_dump (STRING_DUMP);
4105 request_dump (RELOC_DUMP);
4112 dwarf_select_sections_all ();
4117 dwarf_select_sections_by_letters (optarg);
4120 case OPTION_DEBUG_DUMP:
4127 dwarf_select_sections_by_names (optarg);
4130 case OPTION_DWARF_DEPTH:
4134 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4137 case OPTION_DWARF_START:
4141 dwarf_start_die = strtoul (optarg, & cp, 0);
4144 case OPTION_DWARF_CHECK:
4147 case OPTION_DYN_SYMS:
4150 #ifdef SUPPORT_DISASSEMBLY
4152 request_dump (DISASS_DUMP);
4156 print_version (program_name);
4165 /* xgettext:c-format */
4166 error (_("Invalid option '-%c'\n"), c);
4173 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4174 && !do_segments && !do_header && !do_dump && !do_version
4175 && !do_histogram && !do_debugging && !do_arch && !do_notes
4176 && !do_section_groups && !do_archive_index
4181 warn (_("Nothing to do.\n"));
4187 get_elf_class (unsigned int elf_class)
4189 static char buff[32];
4193 case ELFCLASSNONE: return _("none");
4194 case ELFCLASS32: return "ELF32";
4195 case ELFCLASS64: return "ELF64";
4197 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4203 get_data_encoding (unsigned int encoding)
4205 static char buff[32];
4209 case ELFDATANONE: return _("none");
4210 case ELFDATA2LSB: return _("2's complement, little endian");
4211 case ELFDATA2MSB: return _("2's complement, big endian");
4213 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4218 /* Decode the data held in 'elf_header'. */
4221 process_file_header (void)
4223 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4224 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4225 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4226 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4229 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4233 init_dwarf_regnames (elf_header.e_machine);
4239 printf (_("ELF Header:\n"));
4240 printf (_(" Magic: "));
4241 for (i = 0; i < EI_NIDENT; i++)
4242 printf ("%2.2x ", elf_header.e_ident[i]);
4244 printf (_(" Class: %s\n"),
4245 get_elf_class (elf_header.e_ident[EI_CLASS]));
4246 printf (_(" Data: %s\n"),
4247 get_data_encoding (elf_header.e_ident[EI_DATA]));
4248 printf (_(" Version: %d %s\n"),
4249 elf_header.e_ident[EI_VERSION],
4250 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4252 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4253 ? _("<unknown: %lx>")
4255 printf (_(" OS/ABI: %s\n"),
4256 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4257 printf (_(" ABI Version: %d\n"),
4258 elf_header.e_ident[EI_ABIVERSION]);
4259 printf (_(" Type: %s\n"),
4260 get_file_type (elf_header.e_type));
4261 printf (_(" Machine: %s\n"),
4262 get_machine_name (elf_header.e_machine));
4263 printf (_(" Version: 0x%lx\n"),
4264 (unsigned long) elf_header.e_version);
4266 printf (_(" Entry point address: "));
4267 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4268 printf (_("\n Start of program headers: "));
4269 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4270 printf (_(" (bytes into file)\n Start of section headers: "));
4271 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4272 printf (_(" (bytes into file)\n"));
4274 printf (_(" Flags: 0x%lx%s\n"),
4275 (unsigned long) elf_header.e_flags,
4276 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4277 printf (_(" Size of this header: %ld (bytes)\n"),
4278 (long) elf_header.e_ehsize);
4279 printf (_(" Size of program headers: %ld (bytes)\n"),
4280 (long) elf_header.e_phentsize);
4281 printf (_(" Number of program headers: %ld"),
4282 (long) elf_header.e_phnum);
4283 if (section_headers != NULL
4284 && elf_header.e_phnum == PN_XNUM
4285 && section_headers[0].sh_info != 0)
4286 printf (" (%ld)", (long) section_headers[0].sh_info);
4287 putc ('\n', stdout);
4288 printf (_(" Size of section headers: %ld (bytes)\n"),
4289 (long) elf_header.e_shentsize);
4290 printf (_(" Number of section headers: %ld"),
4291 (long) elf_header.e_shnum);
4292 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4293 printf (" (%ld)", (long) section_headers[0].sh_size);
4294 putc ('\n', stdout);
4295 printf (_(" Section header string table index: %ld"),
4296 (long) elf_header.e_shstrndx);
4297 if (section_headers != NULL
4298 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4299 printf (" (%u)", section_headers[0].sh_link);
4300 else if (elf_header.e_shstrndx != SHN_UNDEF
4301 && elf_header.e_shstrndx >= elf_header.e_shnum)
4302 printf (_(" <corrupt: out of range>"));
4303 putc ('\n', stdout);
4306 if (section_headers != NULL)
4308 if (elf_header.e_phnum == PN_XNUM
4309 && section_headers[0].sh_info != 0)
4310 elf_header.e_phnum = section_headers[0].sh_info;
4311 if (elf_header.e_shnum == SHN_UNDEF)
4312 elf_header.e_shnum = section_headers[0].sh_size;
4313 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4314 elf_header.e_shstrndx = section_headers[0].sh_link;
4315 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4316 elf_header.e_shstrndx = SHN_UNDEF;
4317 free (section_headers);
4318 section_headers = NULL;
4325 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4327 Elf32_External_Phdr * phdrs;
4328 Elf32_External_Phdr * external;
4329 Elf_Internal_Phdr * internal;
4331 unsigned int size = elf_header.e_phentsize;
4332 unsigned int num = elf_header.e_phnum;
4334 /* PR binutils/17531: Cope with unexpected section header sizes. */
4335 if (size == 0 || num == 0)
4337 if (size < sizeof * phdrs)
4339 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4342 if (size > sizeof * phdrs)
4343 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4345 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4346 size, num, _("program headers"));
4350 for (i = 0, internal = pheaders, external = phdrs;
4351 i < elf_header.e_phnum;
4352 i++, internal++, external++)
4354 internal->p_type = BYTE_GET (external->p_type);
4355 internal->p_offset = BYTE_GET (external->p_offset);
4356 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4357 internal->p_paddr = BYTE_GET (external->p_paddr);
4358 internal->p_filesz = BYTE_GET (external->p_filesz);
4359 internal->p_memsz = BYTE_GET (external->p_memsz);
4360 internal->p_flags = BYTE_GET (external->p_flags);
4361 internal->p_align = BYTE_GET (external->p_align);
4369 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4371 Elf64_External_Phdr * phdrs;
4372 Elf64_External_Phdr * external;
4373 Elf_Internal_Phdr * internal;
4375 unsigned int size = elf_header.e_phentsize;
4376 unsigned int num = elf_header.e_phnum;
4378 /* PR binutils/17531: Cope with unexpected section header sizes. */
4379 if (size == 0 || num == 0)
4381 if (size < sizeof * phdrs)
4383 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4386 if (size > sizeof * phdrs)
4387 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4389 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4390 size, num, _("program headers"));
4394 for (i = 0, internal = pheaders, external = phdrs;
4395 i < elf_header.e_phnum;
4396 i++, internal++, external++)
4398 internal->p_type = BYTE_GET (external->p_type);
4399 internal->p_flags = BYTE_GET (external->p_flags);
4400 internal->p_offset = BYTE_GET (external->p_offset);
4401 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4402 internal->p_paddr = BYTE_GET (external->p_paddr);
4403 internal->p_filesz = BYTE_GET (external->p_filesz);
4404 internal->p_memsz = BYTE_GET (external->p_memsz);
4405 internal->p_align = BYTE_GET (external->p_align);
4412 /* Returns 1 if the program headers were read into `program_headers'. */
4415 get_program_headers (FILE * file)
4417 Elf_Internal_Phdr * phdrs;
4419 /* Check cache of prior read. */
4420 if (program_headers != NULL)
4423 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4424 sizeof (Elf_Internal_Phdr));
4428 error (_("Out of memory reading %u program headers\n"),
4429 elf_header.e_phnum);
4434 ? get_32bit_program_headers (file, phdrs)
4435 : get_64bit_program_headers (file, phdrs))
4437 program_headers = phdrs;
4445 /* Returns 1 if the program headers were loaded. */
4448 process_program_headers (FILE * file)
4450 Elf_Internal_Phdr * segment;
4453 if (elf_header.e_phnum == 0)
4455 /* PR binutils/12467. */
4456 if (elf_header.e_phoff != 0)
4457 warn (_("possibly corrupt ELF header - it has a non-zero program"
4458 " header offset, but no program headers"));
4459 else if (do_segments)
4460 printf (_("\nThere are no program headers in this file.\n"));
4464 if (do_segments && !do_header)
4466 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4467 printf (_("Entry point "));
4468 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4469 printf (_("\nThere are %d program headers, starting at offset "),
4470 elf_header.e_phnum);
4471 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4475 if (! get_program_headers (file))
4480 if (elf_header.e_phnum > 1)
4481 printf (_("\nProgram Headers:\n"));
4483 printf (_("\nProgram Headers:\n"));
4487 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4490 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4494 (_(" Type Offset VirtAddr PhysAddr\n"));
4496 (_(" FileSiz MemSiz Flags Align\n"));
4503 for (i = 0, segment = program_headers;
4504 i < elf_header.e_phnum;
4509 printf (" %-14.14s ", get_segment_type (segment->p_type));
4513 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4514 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4515 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4516 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4517 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4519 (segment->p_flags & PF_R ? 'R' : ' '),
4520 (segment->p_flags & PF_W ? 'W' : ' '),
4521 (segment->p_flags & PF_X ? 'E' : ' '));
4522 printf ("%#lx", (unsigned long) segment->p_align);
4526 if ((unsigned long) segment->p_offset == segment->p_offset)
4527 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4530 print_vma (segment->p_offset, FULL_HEX);
4534 print_vma (segment->p_vaddr, FULL_HEX);
4536 print_vma (segment->p_paddr, FULL_HEX);
4539 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4540 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4543 print_vma (segment->p_filesz, FULL_HEX);
4547 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4548 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4551 print_vma (segment->p_memsz, FULL_HEX);
4555 (segment->p_flags & PF_R ? 'R' : ' '),
4556 (segment->p_flags & PF_W ? 'W' : ' '),
4557 (segment->p_flags & PF_X ? 'E' : ' '));
4559 if ((unsigned long) segment->p_align == segment->p_align)
4560 printf ("%#lx", (unsigned long) segment->p_align);
4563 print_vma (segment->p_align, PREFIX_HEX);
4568 print_vma (segment->p_offset, FULL_HEX);
4570 print_vma (segment->p_vaddr, FULL_HEX);
4572 print_vma (segment->p_paddr, FULL_HEX);
4574 print_vma (segment->p_filesz, FULL_HEX);
4576 print_vma (segment->p_memsz, FULL_HEX);
4578 (segment->p_flags & PF_R ? 'R' : ' '),
4579 (segment->p_flags & PF_W ? 'W' : ' '),
4580 (segment->p_flags & PF_X ? 'E' : ' '));
4581 print_vma (segment->p_align, HEX);
4586 putc ('\n', stdout);
4588 switch (segment->p_type)
4592 error (_("more than one dynamic segment\n"));
4594 /* By default, assume that the .dynamic section is the first
4595 section in the DYNAMIC segment. */
4596 dynamic_addr = segment->p_offset;
4597 dynamic_size = segment->p_filesz;
4598 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4599 if (dynamic_addr + dynamic_size >= current_file_size)
4601 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4602 dynamic_addr = dynamic_size = 0;
4605 /* Try to locate the .dynamic section. If there is
4606 a section header table, we can easily locate it. */
4607 if (section_headers != NULL)
4609 Elf_Internal_Shdr * sec;
4611 sec = find_section (".dynamic");
4612 if (sec == NULL || sec->sh_size == 0)
4614 /* A corresponding .dynamic section is expected, but on
4615 IA-64/OpenVMS it is OK for it to be missing. */
4616 if (!is_ia64_vms ())
4617 error (_("no .dynamic section in the dynamic segment\n"));
4621 if (sec->sh_type == SHT_NOBITS)
4627 dynamic_addr = sec->sh_offset;
4628 dynamic_size = sec->sh_size;
4630 if (dynamic_addr < segment->p_offset
4631 || dynamic_addr > segment->p_offset + segment->p_filesz)
4632 warn (_("the .dynamic section is not contained"
4633 " within the dynamic segment\n"));
4634 else if (dynamic_addr > segment->p_offset)
4635 warn (_("the .dynamic section is not the first section"
4636 " in the dynamic segment.\n"));
4641 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4643 error (_("Unable to find program interpreter name\n"));
4647 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4649 if (ret >= (int) sizeof (fmt) || ret < 0)
4650 error (_("Internal error: failed to create format string to display program interpreter\n"));
4652 program_interpreter[0] = 0;
4653 if (fscanf (file, fmt, program_interpreter) <= 0)
4654 error (_("Unable to read program interpreter name\n"));
4657 printf (_(" [Requesting program interpreter: %s]\n"),
4658 program_interpreter);
4664 if (do_segments && section_headers != NULL && string_table != NULL)
4666 printf (_("\n Section to Segment mapping:\n"));
4667 printf (_(" Segment Sections...\n"));
4669 for (i = 0; i < elf_header.e_phnum; i++)
4672 Elf_Internal_Shdr * section;
4674 segment = program_headers + i;
4675 section = section_headers + 1;
4677 printf (" %2.2d ", i);
4679 for (j = 1; j < elf_header.e_shnum; j++, section++)
4681 if (!ELF_TBSS_SPECIAL (section, segment)
4682 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4683 printf ("%s ", printable_section_name (section));
4694 /* Find the file offset corresponding to VMA by using the program headers. */
4697 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4699 Elf_Internal_Phdr * seg;
4701 if (! get_program_headers (file))
4703 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4707 for (seg = program_headers;
4708 seg < program_headers + elf_header.e_phnum;
4711 if (seg->p_type != PT_LOAD)
4714 if (vma >= (seg->p_vaddr & -seg->p_align)
4715 && vma + size <= seg->p_vaddr + seg->p_filesz)
4716 return vma - seg->p_vaddr + seg->p_offset;
4719 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4720 (unsigned long) vma);
4725 /* Allocate memory and load the sections headers into the global pointer
4726 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4727 generate any error messages if the load fails. */
4730 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4732 Elf32_External_Shdr * shdrs;
4733 Elf_Internal_Shdr * internal;
4735 unsigned int size = elf_header.e_shentsize;
4736 unsigned int num = probe ? 1 : elf_header.e_shnum;
4738 /* PR binutils/17531: Cope with unexpected section header sizes. */
4739 if (size == 0 || num == 0)
4741 if (size < sizeof * shdrs)
4744 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4747 if (!probe && size > sizeof * shdrs)
4748 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4750 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4752 probe ? NULL : _("section headers"));
4756 if (section_headers != NULL)
4757 free (section_headers);
4758 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4759 sizeof (Elf_Internal_Shdr));
4760 if (section_headers == NULL)
4763 error (_("Out of memory reading %u section headers\n"), num);
4767 for (i = 0, internal = section_headers;
4771 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4772 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4773 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4774 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4775 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4776 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4777 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4778 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4779 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4780 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4788 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4790 Elf64_External_Shdr * shdrs;
4791 Elf_Internal_Shdr * internal;
4793 unsigned int size = elf_header.e_shentsize;
4794 unsigned int num = probe ? 1 : elf_header.e_shnum;
4796 /* PR binutils/17531: Cope with unexpected section header sizes. */
4797 if (size == 0 || num == 0)
4799 if (size < sizeof * shdrs)
4802 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4805 if (! probe && size > sizeof * shdrs)
4806 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4808 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4810 probe ? NULL : _("section headers"));
4814 if (section_headers != NULL)
4815 free (section_headers);
4816 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4817 sizeof (Elf_Internal_Shdr));
4818 if (section_headers == NULL)
4821 error (_("Out of memory reading %u section headers\n"), num);
4825 for (i = 0, internal = section_headers;
4829 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4830 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4831 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4832 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4833 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4834 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4835 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4836 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4837 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4838 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4845 static Elf_Internal_Sym *
4846 get_32bit_elf_symbols (FILE * file,
4847 Elf_Internal_Shdr * section,
4848 unsigned long * num_syms_return)
4850 unsigned long number = 0;
4851 Elf32_External_Sym * esyms = NULL;
4852 Elf_External_Sym_Shndx * shndx = NULL;
4853 Elf_Internal_Sym * isyms = NULL;
4854 Elf_Internal_Sym * psym;
4857 if (section->sh_size == 0)
4859 if (num_syms_return != NULL)
4860 * num_syms_return = 0;
4864 /* Run some sanity checks first. */
4865 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4867 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4868 printable_section_name (section), (unsigned long) section->sh_entsize);
4872 if (section->sh_size > current_file_size)
4874 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4875 printable_section_name (section), (unsigned long) section->sh_size);
4879 number = section->sh_size / section->sh_entsize;
4881 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4883 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4884 (unsigned long) section->sh_size,
4885 printable_section_name (section),
4886 (unsigned long) section->sh_entsize);
4890 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4891 section->sh_size, _("symbols"));
4896 if (symtab_shndx_hdr != NULL
4897 && (symtab_shndx_hdr->sh_link
4898 == (unsigned long) (section - section_headers)))
4900 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4901 symtab_shndx_hdr->sh_offset,
4902 1, symtab_shndx_hdr->sh_size,
4903 _("symbol table section indicies"));
4906 /* PR17531: file: heap-buffer-overflow */
4907 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4909 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4910 printable_section_name (symtab_shndx_hdr),
4911 (unsigned long) symtab_shndx_hdr->sh_size,
4912 (unsigned long) section->sh_size);
4917 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4921 error (_("Out of memory reading %lu symbols\n"),
4922 (unsigned long) number);
4926 for (j = 0, psym = isyms; j < number; j++, psym++)
4928 psym->st_name = BYTE_GET (esyms[j].st_name);
4929 psym->st_value = BYTE_GET (esyms[j].st_value);
4930 psym->st_size = BYTE_GET (esyms[j].st_size);
4931 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4932 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4934 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4935 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4936 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4937 psym->st_info = BYTE_GET (esyms[j].st_info);
4938 psym->st_other = BYTE_GET (esyms[j].st_other);
4947 if (num_syms_return != NULL)
4948 * num_syms_return = isyms == NULL ? 0 : number;
4953 static Elf_Internal_Sym *
4954 get_64bit_elf_symbols (FILE * file,
4955 Elf_Internal_Shdr * section,
4956 unsigned long * num_syms_return)
4958 unsigned long number = 0;
4959 Elf64_External_Sym * esyms = NULL;
4960 Elf_External_Sym_Shndx * shndx = NULL;
4961 Elf_Internal_Sym * isyms = NULL;
4962 Elf_Internal_Sym * psym;
4965 if (section->sh_size == 0)
4967 if (num_syms_return != NULL)
4968 * num_syms_return = 0;
4972 /* Run some sanity checks first. */
4973 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4975 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4976 printable_section_name (section),
4977 (unsigned long) section->sh_entsize);
4981 if (section->sh_size > current_file_size)
4983 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4984 printable_section_name (section),
4985 (unsigned long) section->sh_size);
4989 number = section->sh_size / section->sh_entsize;
4991 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4993 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4994 (unsigned long) section->sh_size,
4995 printable_section_name (section),
4996 (unsigned long) section->sh_entsize);
5000 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5001 section->sh_size, _("symbols"));
5005 if (symtab_shndx_hdr != NULL
5006 && (symtab_shndx_hdr->sh_link
5007 == (unsigned long) (section - section_headers)))
5009 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5010 symtab_shndx_hdr->sh_offset,
5011 1, symtab_shndx_hdr->sh_size,
5012 _("symbol table section indicies"));
5015 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5017 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5018 printable_section_name (symtab_shndx_hdr),
5019 (unsigned long) symtab_shndx_hdr->sh_size,
5020 (unsigned long) section->sh_size);
5025 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5029 error (_("Out of memory reading %lu symbols\n"),
5030 (unsigned long) number);
5034 for (j = 0, psym = isyms; j < number; j++, psym++)
5036 psym->st_name = BYTE_GET (esyms[j].st_name);
5037 psym->st_info = BYTE_GET (esyms[j].st_info);
5038 psym->st_other = BYTE_GET (esyms[j].st_other);
5039 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5041 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5043 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5044 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5045 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5047 psym->st_value = BYTE_GET (esyms[j].st_value);
5048 psym->st_size = BYTE_GET (esyms[j].st_size);
5057 if (num_syms_return != NULL)
5058 * num_syms_return = isyms == NULL ? 0 : number;
5064 get_elf_section_flags (bfd_vma sh_flags)
5066 static char buff[1024];
5068 int field_size = is_32bit_elf ? 8 : 16;
5070 int size = sizeof (buff) - (field_size + 4 + 1);
5071 bfd_vma os_flags = 0;
5072 bfd_vma proc_flags = 0;
5073 bfd_vma unknown_flags = 0;
5081 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5082 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5083 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5084 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5085 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5086 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5087 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5088 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5089 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5090 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5091 /* IA-64 specific. */
5092 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5093 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5094 /* IA-64 OpenVMS specific. */
5095 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5096 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5097 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5098 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5099 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5100 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5102 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5103 /* SPARC specific. */
5104 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5107 if (do_section_details)
5109 sprintf (buff, "[%*.*lx]: ",
5110 field_size, field_size, (unsigned long) sh_flags);
5111 p += field_size + 4;
5118 flag = sh_flags & - sh_flags;
5121 if (do_section_details)
5125 case SHF_WRITE: sindex = 0; break;
5126 case SHF_ALLOC: sindex = 1; break;
5127 case SHF_EXECINSTR: sindex = 2; break;
5128 case SHF_MERGE: sindex = 3; break;
5129 case SHF_STRINGS: sindex = 4; break;
5130 case SHF_INFO_LINK: sindex = 5; break;
5131 case SHF_LINK_ORDER: sindex = 6; break;
5132 case SHF_OS_NONCONFORMING: sindex = 7; break;
5133 case SHF_GROUP: sindex = 8; break;
5134 case SHF_TLS: sindex = 9; break;
5135 case SHF_EXCLUDE: sindex = 18; break;
5139 switch (elf_header.e_machine)
5142 if (flag == SHF_IA_64_SHORT)
5144 else if (flag == SHF_IA_64_NORECOV)
5147 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5150 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5151 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5152 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5153 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5154 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5155 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5166 case EM_OLD_SPARCV9:
5167 case EM_SPARC32PLUS:
5170 if (flag == SHF_ORDERED)
5180 if (p != buff + field_size + 4)
5182 if (size < (10 + 2))
5184 warn (_("Internal error: not enough buffer room for section flag info"));
5185 return _("<unknown>");
5192 size -= flags [sindex].len;
5193 p = stpcpy (p, flags [sindex].str);
5195 else if (flag & SHF_MASKOS)
5197 else if (flag & SHF_MASKPROC)
5200 unknown_flags |= flag;
5206 case SHF_WRITE: *p = 'W'; break;
5207 case SHF_ALLOC: *p = 'A'; break;
5208 case SHF_EXECINSTR: *p = 'X'; break;
5209 case SHF_MERGE: *p = 'M'; break;
5210 case SHF_STRINGS: *p = 'S'; break;
5211 case SHF_INFO_LINK: *p = 'I'; break;
5212 case SHF_LINK_ORDER: *p = 'L'; break;
5213 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5214 case SHF_GROUP: *p = 'G'; break;
5215 case SHF_TLS: *p = 'T'; break;
5216 case SHF_EXCLUDE: *p = 'E'; break;
5219 if ((elf_header.e_machine == EM_X86_64
5220 || elf_header.e_machine == EM_L1OM
5221 || elf_header.e_machine == EM_K1OM)
5222 && flag == SHF_X86_64_LARGE)
5224 else if (flag & SHF_MASKOS)
5227 sh_flags &= ~ SHF_MASKOS;
5229 else if (flag & SHF_MASKPROC)
5232 sh_flags &= ~ SHF_MASKPROC;
5242 if (do_section_details)
5246 size -= 5 + field_size;
5247 if (p != buff + field_size + 4)
5251 warn (_("Internal error: not enough buffer room for section flag info"));
5252 return _("<unknown>");
5258 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5259 (unsigned long) os_flags);
5260 p += 5 + field_size;
5264 size -= 7 + field_size;
5265 if (p != buff + field_size + 4)
5269 warn (_("Internal error: not enough buffer room for section flag info"));
5270 return _("<unknown>");
5276 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5277 (unsigned long) proc_flags);
5278 p += 7 + field_size;
5282 size -= 10 + field_size;
5283 if (p != buff + field_size + 4)
5287 warn (_("Internal error: not enough buffer room for section flag info"));
5288 return _("<unknown>");
5294 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5295 (unsigned long) unknown_flags);
5296 p += 10 + field_size;
5305 process_section_headers (FILE * file)
5307 Elf_Internal_Shdr * section;
5310 section_headers = NULL;
5312 if (elf_header.e_shnum == 0)
5314 /* PR binutils/12467. */
5315 if (elf_header.e_shoff != 0)
5316 warn (_("possibly corrupt ELF file header - it has a non-zero"
5317 " section header offset, but no section headers\n"));
5318 else if (do_sections)
5319 printf (_("\nThere are no sections in this file.\n"));
5324 if (do_sections && !do_header)
5325 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5326 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5330 if (! get_32bit_section_headers (file, FALSE))
5333 else if (! get_64bit_section_headers (file, FALSE))
5336 /* Read in the string table, so that we have names to display. */
5337 if (elf_header.e_shstrndx != SHN_UNDEF
5338 && elf_header.e_shstrndx < elf_header.e_shnum)
5340 section = section_headers + elf_header.e_shstrndx;
5342 if (section->sh_size != 0)
5344 string_table = (char *) get_data (NULL, file, section->sh_offset,
5345 1, section->sh_size,
5348 string_table_length = string_table != NULL ? section->sh_size : 0;
5352 /* Scan the sections for the dynamic symbol table
5353 and dynamic string table and debug sections. */
5354 dynamic_symbols = NULL;
5355 dynamic_strings = NULL;
5356 dynamic_syminfo = NULL;
5357 symtab_shndx_hdr = NULL;
5359 eh_addr_size = is_32bit_elf ? 4 : 8;
5360 switch (elf_header.e_machine)
5363 case EM_MIPS_RS3_LE:
5364 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5365 FDE addresses. However, the ABI also has a semi-official ILP32
5366 variant for which the normal FDE address size rules apply.
5368 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5369 section, where XX is the size of longs in bits. Unfortunately,
5370 earlier compilers provided no way of distinguishing ILP32 objects
5371 from LP64 objects, so if there's any doubt, we should assume that
5372 the official LP64 form is being used. */
5373 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5374 && find_section (".gcc_compiled_long32") == NULL)
5380 switch (elf_header.e_flags & EF_H8_MACH)
5382 case E_H8_MACH_H8300:
5383 case E_H8_MACH_H8300HN:
5384 case E_H8_MACH_H8300SN:
5385 case E_H8_MACH_H8300SXN:
5388 case E_H8_MACH_H8300H:
5389 case E_H8_MACH_H8300S:
5390 case E_H8_MACH_H8300SX:
5398 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5400 case EF_M32C_CPU_M16C:
5407 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5410 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5411 if (section->sh_entsize != expected_entsize) \
5414 sprintf_vma (buf, section->sh_entsize); \
5415 /* Note: coded this way so that there is a single string for \
5417 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5418 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5419 (unsigned) expected_entsize); \
5420 section->sh_entsize = expected_entsize; \
5425 #define CHECK_ENTSIZE(section, i, type) \
5426 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5427 sizeof (Elf64_External_##type))
5429 for (i = 0, section = section_headers;
5430 i < elf_header.e_shnum;
5433 char * name = SECTION_NAME (section);
5435 if (section->sh_type == SHT_DYNSYM)
5437 if (dynamic_symbols != NULL)
5439 error (_("File contains multiple dynamic symbol tables\n"));
5443 CHECK_ENTSIZE (section, i, Sym);
5444 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5446 else if (section->sh_type == SHT_STRTAB
5447 && streq (name, ".dynstr"))
5449 if (dynamic_strings != NULL)
5451 error (_("File contains multiple dynamic string tables\n"));
5455 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5456 1, section->sh_size,
5457 _("dynamic strings"));
5458 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5460 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5462 if (symtab_shndx_hdr != NULL)
5464 error (_("File contains multiple symtab shndx tables\n"));
5467 symtab_shndx_hdr = section;
5469 else if (section->sh_type == SHT_SYMTAB)
5470 CHECK_ENTSIZE (section, i, Sym);
5471 else if (section->sh_type == SHT_GROUP)
5472 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5473 else if (section->sh_type == SHT_REL)
5474 CHECK_ENTSIZE (section, i, Rel);
5475 else if (section->sh_type == SHT_RELA)
5476 CHECK_ENTSIZE (section, i, Rela);
5477 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5478 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5479 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5480 || do_debug_str || do_debug_loc || do_debug_ranges
5481 || do_debug_addr || do_debug_cu_index)
5482 && (const_strneq (name, ".debug_")
5483 || const_strneq (name, ".zdebug_")))
5486 name += sizeof (".zdebug_") - 1;
5488 name += sizeof (".debug_") - 1;
5491 || (do_debug_info && const_strneq (name, "info"))
5492 || (do_debug_info && const_strneq (name, "types"))
5493 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5494 || (do_debug_lines && strcmp (name, "line") == 0)
5495 || (do_debug_lines && const_strneq (name, "line."))
5496 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5497 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5498 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5499 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5500 || (do_debug_aranges && const_strneq (name, "aranges"))
5501 || (do_debug_ranges && const_strneq (name, "ranges"))
5502 || (do_debug_frames && const_strneq (name, "frame"))
5503 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5504 || (do_debug_macinfo && const_strneq (name, "macro"))
5505 || (do_debug_str && const_strneq (name, "str"))
5506 || (do_debug_loc && const_strneq (name, "loc"))
5507 || (do_debug_addr && const_strneq (name, "addr"))
5508 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5509 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5511 request_dump_bynumber (i, DEBUG_DUMP);
5513 /* Linkonce section to be combined with .debug_info at link time. */
5514 else if ((do_debugging || do_debug_info)
5515 && const_strneq (name, ".gnu.linkonce.wi."))
5516 request_dump_bynumber (i, DEBUG_DUMP);
5517 else if (do_debug_frames && streq (name, ".eh_frame"))
5518 request_dump_bynumber (i, DEBUG_DUMP);
5519 else if (do_gdb_index && streq (name, ".gdb_index"))
5520 request_dump_bynumber (i, DEBUG_DUMP);
5521 /* Trace sections for Itanium VMS. */
5522 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5523 || do_trace_aranges)
5524 && const_strneq (name, ".trace_"))
5526 name += sizeof (".trace_") - 1;
5529 || (do_trace_info && streq (name, "info"))
5530 || (do_trace_abbrevs && streq (name, "abbrev"))
5531 || (do_trace_aranges && streq (name, "aranges"))
5533 request_dump_bynumber (i, DEBUG_DUMP);
5540 if (elf_header.e_shnum > 1)
5541 printf (_("\nSection Headers:\n"));
5543 printf (_("\nSection Header:\n"));
5547 if (do_section_details)
5549 printf (_(" [Nr] Name\n"));
5550 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5554 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5558 if (do_section_details)
5560 printf (_(" [Nr] Name\n"));
5561 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5565 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5569 if (do_section_details)
5571 printf (_(" [Nr] Name\n"));
5572 printf (_(" Type Address Offset Link\n"));
5573 printf (_(" Size EntSize Info Align\n"));
5577 printf (_(" [Nr] Name Type Address Offset\n"));
5578 printf (_(" Size EntSize Flags Link Info Align\n"));
5582 if (do_section_details)
5583 printf (_(" Flags\n"));
5585 for (i = 0, section = section_headers;
5586 i < elf_header.e_shnum;
5589 printf (" [%2u] ", i);
5590 if (do_section_details)
5591 printf ("%s\n ", printable_section_name (section));
5593 print_symbol (-17, SECTION_NAME (section));
5595 printf (do_wide ? " %-15s " : " %-15.15s ",
5596 get_section_type_name (section->sh_type));
5600 const char * link_too_big = NULL;
5602 print_vma (section->sh_addr, LONG_HEX);
5604 printf ( " %6.6lx %6.6lx %2.2lx",
5605 (unsigned long) section->sh_offset,
5606 (unsigned long) section->sh_size,
5607 (unsigned long) section->sh_entsize);
5609 if (do_section_details)
5610 fputs (" ", stdout);
5612 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5614 if (section->sh_link >= elf_header.e_shnum)
5617 /* The sh_link value is out of range. Normally this indicates
5618 an error but it can have special values in Solaris binaries. */
5619 switch (elf_header.e_machine)
5626 case EM_OLD_SPARCV9:
5627 case EM_SPARC32PLUS:
5630 if (section->sh_link == (SHN_BEFORE & 0xffff))
5631 link_too_big = "BEFORE";
5632 else if (section->sh_link == (SHN_AFTER & 0xffff))
5633 link_too_big = "AFTER";
5640 if (do_section_details)
5642 if (link_too_big != NULL && * link_too_big)
5643 printf ("<%s> ", link_too_big);
5645 printf ("%2u ", section->sh_link);
5646 printf ("%3u %2lu\n", section->sh_info,
5647 (unsigned long) section->sh_addralign);
5650 printf ("%2u %3u %2lu\n",
5653 (unsigned long) section->sh_addralign);
5655 if (link_too_big && ! * link_too_big)
5656 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5657 i, section->sh_link);
5661 print_vma (section->sh_addr, LONG_HEX);
5663 if ((long) section->sh_offset == section->sh_offset)
5664 printf (" %6.6lx", (unsigned long) section->sh_offset);
5668 print_vma (section->sh_offset, LONG_HEX);
5671 if ((unsigned long) section->sh_size == section->sh_size)
5672 printf (" %6.6lx", (unsigned long) section->sh_size);
5676 print_vma (section->sh_size, LONG_HEX);
5679 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5680 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5684 print_vma (section->sh_entsize, LONG_HEX);
5687 if (do_section_details)
5688 fputs (" ", stdout);
5690 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5692 printf ("%2u %3u ", section->sh_link, section->sh_info);
5694 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5695 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5698 print_vma (section->sh_addralign, DEC);
5702 else if (do_section_details)
5704 printf (" %-15.15s ",
5705 get_section_type_name (section->sh_type));
5706 print_vma (section->sh_addr, LONG_HEX);
5707 if ((long) section->sh_offset == section->sh_offset)
5708 printf (" %16.16lx", (unsigned long) section->sh_offset);
5712 print_vma (section->sh_offset, LONG_HEX);
5714 printf (" %u\n ", section->sh_link);
5715 print_vma (section->sh_size, LONG_HEX);
5717 print_vma (section->sh_entsize, LONG_HEX);
5719 printf (" %-16u %lu\n",
5721 (unsigned long) section->sh_addralign);
5726 print_vma (section->sh_addr, LONG_HEX);
5727 if ((long) section->sh_offset == section->sh_offset)
5728 printf (" %8.8lx", (unsigned long) section->sh_offset);
5732 print_vma (section->sh_offset, LONG_HEX);
5735 print_vma (section->sh_size, LONG_HEX);
5737 print_vma (section->sh_entsize, LONG_HEX);
5739 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5741 printf (" %2u %3u %lu\n",
5744 (unsigned long) section->sh_addralign);
5747 if (do_section_details)
5748 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5751 if (!do_section_details)
5753 if (elf_header.e_machine == EM_X86_64
5754 || elf_header.e_machine == EM_L1OM
5755 || elf_header.e_machine == EM_K1OM)
5756 printf (_("Key to Flags:\n\
5757 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5758 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5759 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5761 printf (_("Key to Flags:\n\
5762 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5763 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5764 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5771 get_group_flags (unsigned int flags)
5773 static char buff[32];
5783 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5790 process_section_groups (FILE * file)
5792 Elf_Internal_Shdr * section;
5794 struct group * group;
5795 Elf_Internal_Shdr * symtab_sec;
5796 Elf_Internal_Shdr * strtab_sec;
5797 Elf_Internal_Sym * symtab;
5798 unsigned long num_syms;
5802 /* Don't process section groups unless needed. */
5803 if (!do_unwind && !do_section_groups)
5806 if (elf_header.e_shnum == 0)
5808 if (do_section_groups)
5809 printf (_("\nThere are no sections to group in this file.\n"));
5814 if (section_headers == NULL)
5816 error (_("Section headers are not available!\n"));
5817 /* PR 13622: This can happen with a corrupt ELF header. */
5821 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5822 sizeof (struct group *));
5824 if (section_headers_groups == NULL)
5826 error (_("Out of memory reading %u section group headers\n"),
5827 elf_header.e_shnum);
5831 /* Scan the sections for the group section. */
5833 for (i = 0, section = section_headers;
5834 i < elf_header.e_shnum;
5836 if (section->sh_type == SHT_GROUP)
5839 if (group_count == 0)
5841 if (do_section_groups)
5842 printf (_("\nThere are no section groups in this file.\n"));
5847 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5849 if (section_groups == NULL)
5851 error (_("Out of memory reading %lu groups\n"),
5852 (unsigned long) group_count);
5862 for (i = 0, section = section_headers, group = section_groups;
5863 i < elf_header.e_shnum;
5866 if (section->sh_type == SHT_GROUP)
5868 const char * name = printable_section_name (section);
5869 const char * group_name;
5870 unsigned char * start;
5871 unsigned char * indices;
5872 unsigned int entry, j, size;
5873 Elf_Internal_Shdr * sec;
5874 Elf_Internal_Sym * sym;
5876 /* Get the symbol table. */
5877 if (section->sh_link >= elf_header.e_shnum
5878 || ((sec = section_headers + section->sh_link)->sh_type
5881 error (_("Bad sh_link in group section `%s'\n"), name);
5885 if (symtab_sec != sec)
5890 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5895 error (_("Corrupt header in group section `%s'\n"), name);
5899 if (section->sh_info >= num_syms)
5901 error (_("Bad sh_info in group section `%s'\n"), name);
5905 sym = symtab + section->sh_info;
5907 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5909 if (sym->st_shndx == 0
5910 || sym->st_shndx >= elf_header.e_shnum)
5912 error (_("Bad sh_info in group section `%s'\n"), name);
5916 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5925 /* Get the string table. */
5926 if (symtab_sec->sh_link >= elf_header.e_shnum)
5935 != (sec = section_headers + symtab_sec->sh_link))
5941 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5942 1, strtab_sec->sh_size,
5944 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5946 group_name = sym->st_name < strtab_size
5947 ? strtab + sym->st_name : _("<corrupt>");
5950 /* PR 17531: file: loop. */
5951 if (section->sh_entsize > section->sh_size)
5953 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5954 printable_section_name (section),
5955 (unsigned long) section->sh_entsize,
5956 (unsigned long) section->sh_size);
5960 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5961 1, section->sh_size,
5967 size = (section->sh_size / section->sh_entsize) - 1;
5968 entry = byte_get (indices, 4);
5971 if (do_section_groups)
5973 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5974 get_group_flags (entry), i, name, group_name, size);
5976 printf (_(" [Index] Name\n"));
5979 group->group_index = i;
5981 for (j = 0; j < size; j++)
5983 struct group_list * g;
5985 entry = byte_get (indices, 4);
5988 if (entry >= elf_header.e_shnum)
5990 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5991 entry, i, elf_header.e_shnum - 1);
5995 if (section_headers_groups [entry] != NULL)
5999 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6001 section_headers_groups [entry]->group_index);
6006 /* Intel C/C++ compiler may put section 0 in a
6007 section group. We just warn it the first time
6008 and ignore it afterwards. */
6009 static int warned = 0;
6012 error (_("section 0 in group section [%5u]\n"),
6013 section_headers_groups [entry]->group_index);
6019 section_headers_groups [entry] = group;
6021 if (do_section_groups)
6023 sec = section_headers + entry;
6024 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6027 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6028 g->section_index = entry;
6029 g->next = group->root;
6047 /* Data used to display dynamic fixups. */
6049 struct ia64_vms_dynfixup
6051 bfd_vma needed_ident; /* Library ident number. */
6052 bfd_vma needed; /* Index in the dstrtab of the library name. */
6053 bfd_vma fixup_needed; /* Index of the library. */
6054 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6055 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6058 /* Data used to display dynamic relocations. */
6060 struct ia64_vms_dynimgrela
6062 bfd_vma img_rela_cnt; /* Number of relocations. */
6063 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6066 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6070 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6071 const char *strtab, unsigned int strtab_sz)
6073 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6075 const char *lib_name;
6077 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6078 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6079 _("dynamic section image fixups"));
6083 if (fixup->needed < strtab_sz)
6084 lib_name = strtab + fixup->needed;
6087 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6088 (unsigned long) fixup->needed);
6091 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6092 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6094 (_("Seg Offset Type SymVec DataType\n"));
6096 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6101 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6102 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6103 type = BYTE_GET (imfs [i].type);
6104 rtype = elf_ia64_reloc_type (type);
6106 printf (" 0x%08x ", type);
6108 printf (" %-32s ", rtype);
6109 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6110 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6116 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6119 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6121 Elf64_External_VMS_IMAGE_RELA *imrs;
6124 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6125 1, imgrela->img_rela_cnt * sizeof (*imrs),
6126 _("dynamic section image relocations"));
6130 printf (_("\nImage relocs\n"));
6132 (_("Seg Offset Type Addend Seg Sym Off\n"));
6134 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6139 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6140 printf ("%08" BFD_VMA_FMT "x ",
6141 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6142 type = BYTE_GET (imrs [i].type);
6143 rtype = elf_ia64_reloc_type (type);
6145 printf ("0x%08x ", type);
6147 printf ("%-31s ", rtype);
6148 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6149 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6150 printf ("%08" BFD_VMA_FMT "x\n",
6151 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6157 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6160 process_ia64_vms_dynamic_relocs (FILE *file)
6162 struct ia64_vms_dynfixup fixup;
6163 struct ia64_vms_dynimgrela imgrela;
6164 Elf_Internal_Dyn *entry;
6166 bfd_vma strtab_off = 0;
6167 bfd_vma strtab_sz = 0;
6168 char *strtab = NULL;
6170 memset (&fixup, 0, sizeof (fixup));
6171 memset (&imgrela, 0, sizeof (imgrela));
6173 /* Note: the order of the entries is specified by the OpenVMS specs. */
6174 for (entry = dynamic_section;
6175 entry < dynamic_section + dynamic_nent;
6178 switch (entry->d_tag)
6180 case DT_IA_64_VMS_STRTAB_OFFSET:
6181 strtab_off = entry->d_un.d_val;
6184 strtab_sz = entry->d_un.d_val;
6186 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6187 1, strtab_sz, _("dynamic string section"));
6190 case DT_IA_64_VMS_NEEDED_IDENT:
6191 fixup.needed_ident = entry->d_un.d_val;
6194 fixup.needed = entry->d_un.d_val;
6196 case DT_IA_64_VMS_FIXUP_NEEDED:
6197 fixup.fixup_needed = entry->d_un.d_val;
6199 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6200 fixup.fixup_rela_cnt = entry->d_un.d_val;
6202 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6203 fixup.fixup_rela_off = entry->d_un.d_val;
6205 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6208 case DT_IA_64_VMS_IMG_RELA_CNT:
6209 imgrela.img_rela_cnt = entry->d_un.d_val;
6211 case DT_IA_64_VMS_IMG_RELA_OFF:
6212 imgrela.img_rela_off = entry->d_un.d_val;
6214 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6234 } dynamic_relocations [] =
6236 { "REL", DT_REL, DT_RELSZ, FALSE },
6237 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6238 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6241 /* Process the reloc section. */
6244 process_relocs (FILE * file)
6246 unsigned long rel_size;
6247 unsigned long rel_offset;
6253 if (do_using_dynamic)
6257 int has_dynamic_reloc;
6260 has_dynamic_reloc = 0;
6262 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6264 is_rela = dynamic_relocations [i].rela;
6265 name = dynamic_relocations [i].name;
6266 rel_size = dynamic_info [dynamic_relocations [i].size];
6267 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6269 has_dynamic_reloc |= rel_size;
6271 if (is_rela == UNKNOWN)
6273 if (dynamic_relocations [i].reloc == DT_JMPREL)
6274 switch (dynamic_info[DT_PLTREL])
6288 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6289 name, rel_offset, rel_size);
6291 dump_relocations (file,
6292 offset_from_vma (file, rel_offset, rel_size),
6294 dynamic_symbols, num_dynamic_syms,
6295 dynamic_strings, dynamic_strings_length,
6301 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6303 if (! has_dynamic_reloc)
6304 printf (_("\nThere are no dynamic relocations in this file.\n"));
6308 Elf_Internal_Shdr * section;
6312 for (i = 0, section = section_headers;
6313 i < elf_header.e_shnum;
6316 if ( section->sh_type != SHT_RELA
6317 && section->sh_type != SHT_REL)
6320 rel_offset = section->sh_offset;
6321 rel_size = section->sh_size;
6325 Elf_Internal_Shdr * strsec;
6328 printf (_("\nRelocation section "));
6330 if (string_table == NULL)
6331 printf ("%d", section->sh_name);
6333 printf ("'%s'", printable_section_name (section));
6335 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6336 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6338 is_rela = section->sh_type == SHT_RELA;
6340 if (section->sh_link != 0
6341 && section->sh_link < elf_header.e_shnum)
6343 Elf_Internal_Shdr * symsec;
6344 Elf_Internal_Sym * symtab;
6345 unsigned long nsyms;
6346 unsigned long strtablen = 0;
6347 char * strtab = NULL;
6349 symsec = section_headers + section->sh_link;
6350 if (symsec->sh_type != SHT_SYMTAB
6351 && symsec->sh_type != SHT_DYNSYM)
6354 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6359 if (symsec->sh_link != 0
6360 && symsec->sh_link < elf_header.e_shnum)
6362 strsec = section_headers + symsec->sh_link;
6364 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6367 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6370 dump_relocations (file, rel_offset, rel_size,
6371 symtab, nsyms, strtab, strtablen,
6373 symsec->sh_type == SHT_DYNSYM);
6379 dump_relocations (file, rel_offset, rel_size,
6380 NULL, 0, NULL, 0, is_rela, 0);
6387 printf (_("\nThere are no relocations in this file.\n"));
6393 /* Process the unwind section. */
6395 #include "unwind-ia64.h"
6397 /* An absolute address consists of a section and an offset. If the
6398 section is NULL, the offset itself is the address, otherwise, the
6399 address equals to LOAD_ADDRESS(section) + offset. */
6403 unsigned short section;
6407 #define ABSADDR(a) \
6409 ? section_headers [(a).section].sh_addr + (a).offset \
6412 struct ia64_unw_table_entry
6414 struct absaddr start;
6416 struct absaddr info;
6419 struct ia64_unw_aux_info
6422 struct ia64_unw_table_entry *table; /* Unwind table. */
6423 unsigned long table_len; /* Length of unwind table. */
6424 unsigned char * info; /* Unwind info. */
6425 unsigned long info_size; /* Size of unwind info. */
6426 bfd_vma info_addr; /* starting address of unwind info. */
6427 bfd_vma seg_base; /* Starting address of segment. */
6428 Elf_Internal_Sym * symtab; /* The symbol table. */
6429 unsigned long nsyms; /* Number of symbols. */
6430 char * strtab; /* The string table. */
6431 unsigned long strtab_size; /* Size of string table. */
6435 find_symbol_for_address (Elf_Internal_Sym * symtab,
6436 unsigned long nsyms,
6437 const char * strtab,
6438 unsigned long strtab_size,
6439 struct absaddr addr,
6440 const char ** symname,
6443 bfd_vma dist = 0x100000;
6444 Elf_Internal_Sym * sym;
6445 Elf_Internal_Sym * best = NULL;
6448 REMOVE_ARCH_BITS (addr.offset);
6450 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6452 bfd_vma value = sym->st_value;
6454 REMOVE_ARCH_BITS (value);
6456 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6457 && sym->st_name != 0
6458 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6459 && addr.offset >= value
6460 && addr.offset - value < dist)
6463 dist = addr.offset - value;
6471 *symname = (best->st_name >= strtab_size
6472 ? _("<corrupt>") : strtab + best->st_name);
6478 *offset = addr.offset;
6482 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6484 struct ia64_unw_table_entry * tp;
6487 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6491 const unsigned char * dp;
6492 const unsigned char * head;
6493 const unsigned char * end;
6494 const char * procname;
6496 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6497 aux->strtab_size, tp->start, &procname, &offset);
6499 fputs ("\n<", stdout);
6503 fputs (procname, stdout);
6506 printf ("+%lx", (unsigned long) offset);
6509 fputs (">: [", stdout);
6510 print_vma (tp->start.offset, PREFIX_HEX);
6511 fputc ('-', stdout);
6512 print_vma (tp->end.offset, PREFIX_HEX);
6513 printf ("], info at +0x%lx\n",
6514 (unsigned long) (tp->info.offset - aux->seg_base));
6516 /* PR 17531: file: 86232b32. */
6517 if (aux->info == NULL)
6520 /* PR 17531: file: 0997b4d1. */
6521 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6523 warn (_("Invalid offset %lx in table entry %ld\n"),
6524 (long) tp->info.offset, (long) (tp - aux->table));
6528 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6529 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6531 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6532 (unsigned) UNW_VER (stamp),
6533 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6534 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6535 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6536 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6538 if (UNW_VER (stamp) != 1)
6540 printf (_("\tUnknown version.\n"));
6545 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6546 /* PR 17531: file: 16ceda89. */
6547 if (end > aux->info + aux->info_size)
6548 end = aux->info + aux->info_size;
6549 for (dp = head + 8; dp < end;)
6550 dp = unw_decode (dp, in_body, & in_body);
6555 slurp_ia64_unwind_table (FILE * file,
6556 struct ia64_unw_aux_info * aux,
6557 Elf_Internal_Shdr * sec)
6559 unsigned long size, nrelas, i;
6560 Elf_Internal_Phdr * seg;
6561 struct ia64_unw_table_entry * tep;
6562 Elf_Internal_Shdr * relsec;
6563 Elf_Internal_Rela * rela;
6564 Elf_Internal_Rela * rp;
6565 unsigned char * table;
6567 Elf_Internal_Sym * sym;
6568 const char * relname;
6572 /* First, find the starting address of the segment that includes
6575 if (elf_header.e_phnum)
6577 if (! get_program_headers (file))
6580 for (seg = program_headers;
6581 seg < program_headers + elf_header.e_phnum;
6584 if (seg->p_type != PT_LOAD)
6587 if (sec->sh_addr >= seg->p_vaddr
6588 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6590 aux->seg_base = seg->p_vaddr;
6596 /* Second, build the unwind table from the contents of the unwind section: */
6597 size = sec->sh_size;
6598 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6603 aux->table_len = size / (3 * eh_addr_size);
6604 aux->table = (struct ia64_unw_table_entry *)
6605 xcmalloc (aux->table_len, sizeof (aux->table[0]));
6608 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6610 tep->start.section = SHN_UNDEF;
6611 tep->end.section = SHN_UNDEF;
6612 tep->info.section = SHN_UNDEF;
6613 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6614 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6615 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6616 tep->start.offset += aux->seg_base;
6617 tep->end.offset += aux->seg_base;
6618 tep->info.offset += aux->seg_base;
6622 /* Third, apply any relocations to the unwind table: */
6623 for (relsec = section_headers;
6624 relsec < section_headers + elf_header.e_shnum;
6627 if (relsec->sh_type != SHT_RELA
6628 || relsec->sh_info >= elf_header.e_shnum
6629 || section_headers + relsec->sh_info != sec)
6632 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6641 for (rp = rela; rp < rela + nrelas; ++rp)
6643 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6644 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6646 if (! const_strneq (relname, "R_IA64_SEGREL"))
6648 warn (_("Skipping unexpected relocation type %s\n"), relname);
6652 i = rp->r_offset / (3 * eh_addr_size);
6654 /* PR 17531: file: 5bc8d9bf. */
6655 if (i >= aux->table_len)
6657 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6661 switch (rp->r_offset / eh_addr_size % 3)
6664 aux->table[i].start.section = sym->st_shndx;
6665 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6668 aux->table[i].end.section = sym->st_shndx;
6669 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6672 aux->table[i].info.section = sym->st_shndx;
6673 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6687 ia64_process_unwind (FILE * file)
6689 Elf_Internal_Shdr * sec;
6690 Elf_Internal_Shdr * unwsec = NULL;
6691 Elf_Internal_Shdr * strsec;
6692 unsigned long i, unwcount = 0, unwstart = 0;
6693 struct ia64_unw_aux_info aux;
6695 memset (& aux, 0, sizeof (aux));
6697 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6699 if (sec->sh_type == SHT_SYMTAB
6700 && sec->sh_link < elf_header.e_shnum)
6702 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6704 strsec = section_headers + sec->sh_link;
6705 if (aux.strtab != NULL)
6707 error (_("Multiple auxillary string tables encountered\n"));
6710 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6713 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6715 else if (sec->sh_type == SHT_IA_64_UNWIND)
6720 printf (_("\nThere are no unwind sections in this file.\n"));
6722 while (unwcount-- > 0)
6727 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6728 i < elf_header.e_shnum; ++i, ++sec)
6729 if (sec->sh_type == SHT_IA_64_UNWIND)
6734 /* We have already counted the number of SHT_IA64_UNWIND
6735 sections so the loop above should never fail. */
6736 assert (unwsec != NULL);
6739 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6741 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6743 /* We need to find which section group it is in. */
6744 struct group_list * g;
6746 if (section_headers_groups == NULL
6747 || section_headers_groups [i] == NULL)
6748 i = elf_header.e_shnum;
6751 g = section_headers_groups [i]->root;
6753 for (; g != NULL; g = g->next)
6755 sec = section_headers + g->section_index;
6757 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6762 i = elf_header.e_shnum;
6765 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6767 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6768 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6769 suffix = SECTION_NAME (unwsec) + len;
6770 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6772 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6773 && streq (SECTION_NAME (sec) + len2, suffix))
6778 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6779 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6780 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6781 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6783 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6784 suffix = SECTION_NAME (unwsec) + len;
6785 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6787 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6788 && streq (SECTION_NAME (sec) + len2, suffix))
6792 if (i == elf_header.e_shnum)
6794 printf (_("\nCould not find unwind info section for "));
6796 if (string_table == NULL)
6797 printf ("%d", unwsec->sh_name);
6799 printf ("'%s'", printable_section_name (unwsec));
6803 aux.info_addr = sec->sh_addr;
6804 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6807 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6809 printf (_("\nUnwind section "));
6811 if (string_table == NULL)
6812 printf ("%d", unwsec->sh_name);
6814 printf ("'%s'", printable_section_name (unwsec));
6816 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6817 (unsigned long) unwsec->sh_offset,
6818 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6820 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6821 && aux.table_len > 0)
6822 dump_ia64_unwind (& aux);
6825 free ((char *) aux.table);
6827 free ((char *) aux.info);
6836 free ((char *) aux.strtab);
6839 struct hppa_unw_table_entry
6841 struct absaddr start;
6843 unsigned int Cannot_unwind:1; /* 0 */
6844 unsigned int Millicode:1; /* 1 */
6845 unsigned int Millicode_save_sr0:1; /* 2 */
6846 unsigned int Region_description:2; /* 3..4 */
6847 unsigned int reserved1:1; /* 5 */
6848 unsigned int Entry_SR:1; /* 6 */
6849 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6850 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6851 unsigned int Args_stored:1; /* 16 */
6852 unsigned int Variable_Frame:1; /* 17 */
6853 unsigned int Separate_Package_Body:1; /* 18 */
6854 unsigned int Frame_Extension_Millicode:1; /* 19 */
6855 unsigned int Stack_Overflow_Check:1; /* 20 */
6856 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6857 unsigned int Ada_Region:1; /* 22 */
6858 unsigned int cxx_info:1; /* 23 */
6859 unsigned int cxx_try_catch:1; /* 24 */
6860 unsigned int sched_entry_seq:1; /* 25 */
6861 unsigned int reserved2:1; /* 26 */
6862 unsigned int Save_SP:1; /* 27 */
6863 unsigned int Save_RP:1; /* 28 */
6864 unsigned int Save_MRP_in_frame:1; /* 29 */
6865 unsigned int extn_ptr_defined:1; /* 30 */
6866 unsigned int Cleanup_defined:1; /* 31 */
6868 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6869 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6870 unsigned int Large_frame:1; /* 2 */
6871 unsigned int Pseudo_SP_Set:1; /* 3 */
6872 unsigned int reserved4:1; /* 4 */
6873 unsigned int Total_frame_size:27; /* 5..31 */
6876 struct hppa_unw_aux_info
6878 struct hppa_unw_table_entry *table; /* Unwind table. */
6879 unsigned long table_len; /* Length of unwind table. */
6880 bfd_vma seg_base; /* Starting address of segment. */
6881 Elf_Internal_Sym * symtab; /* The symbol table. */
6882 unsigned long nsyms; /* Number of symbols. */
6883 char * strtab; /* The string table. */
6884 unsigned long strtab_size; /* Size of string table. */
6888 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6890 struct hppa_unw_table_entry * tp;
6892 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6895 const char * procname;
6897 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6898 aux->strtab_size, tp->start, &procname,
6901 fputs ("\n<", stdout);
6905 fputs (procname, stdout);
6908 printf ("+%lx", (unsigned long) offset);
6911 fputs (">: [", stdout);
6912 print_vma (tp->start.offset, PREFIX_HEX);
6913 fputc ('-', stdout);
6914 print_vma (tp->end.offset, PREFIX_HEX);
6917 #define PF(_m) if (tp->_m) printf (#_m " ");
6918 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6921 PF(Millicode_save_sr0);
6922 /* PV(Region_description); */
6928 PF(Separate_Package_Body);
6929 PF(Frame_Extension_Millicode);
6930 PF(Stack_Overflow_Check);
6931 PF(Two_Instruction_SP_Increment);
6935 PF(sched_entry_seq);
6938 PF(Save_MRP_in_frame);
6939 PF(extn_ptr_defined);
6940 PF(Cleanup_defined);
6941 PF(MPE_XL_interrupt_marker);
6942 PF(HP_UX_interrupt_marker);
6945 PV(Total_frame_size);
6954 slurp_hppa_unwind_table (FILE * file,
6955 struct hppa_unw_aux_info * aux,
6956 Elf_Internal_Shdr * sec)
6958 unsigned long size, unw_ent_size, nentries, nrelas, i;
6959 Elf_Internal_Phdr * seg;
6960 struct hppa_unw_table_entry * tep;
6961 Elf_Internal_Shdr * relsec;
6962 Elf_Internal_Rela * rela;
6963 Elf_Internal_Rela * rp;
6964 unsigned char * table;
6966 Elf_Internal_Sym * sym;
6967 const char * relname;
6969 /* First, find the starting address of the segment that includes
6972 if (elf_header.e_phnum)
6974 if (! get_program_headers (file))
6977 for (seg = program_headers;
6978 seg < program_headers + elf_header.e_phnum;
6981 if (seg->p_type != PT_LOAD)
6984 if (sec->sh_addr >= seg->p_vaddr
6985 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6987 aux->seg_base = seg->p_vaddr;
6993 /* Second, build the unwind table from the contents of the unwind
6995 size = sec->sh_size;
6996 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7002 nentries = size / unw_ent_size;
7003 size = unw_ent_size * nentries;
7005 tep = aux->table = (struct hppa_unw_table_entry *)
7006 xcmalloc (nentries, sizeof (aux->table[0]));
7008 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7010 unsigned int tmp1, tmp2;
7012 tep->start.section = SHN_UNDEF;
7013 tep->end.section = SHN_UNDEF;
7015 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7016 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7017 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7018 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7020 tep->start.offset += aux->seg_base;
7021 tep->end.offset += aux->seg_base;
7023 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7024 tep->Millicode = (tmp1 >> 30) & 0x1;
7025 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7026 tep->Region_description = (tmp1 >> 27) & 0x3;
7027 tep->reserved1 = (tmp1 >> 26) & 0x1;
7028 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7029 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7030 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7031 tep->Args_stored = (tmp1 >> 15) & 0x1;
7032 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7033 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7034 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7035 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7036 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7037 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7038 tep->cxx_info = (tmp1 >> 8) & 0x1;
7039 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7040 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7041 tep->reserved2 = (tmp1 >> 5) & 0x1;
7042 tep->Save_SP = (tmp1 >> 4) & 0x1;
7043 tep->Save_RP = (tmp1 >> 3) & 0x1;
7044 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7045 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7046 tep->Cleanup_defined = tmp1 & 0x1;
7048 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7049 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7050 tep->Large_frame = (tmp2 >> 29) & 0x1;
7051 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7052 tep->reserved4 = (tmp2 >> 27) & 0x1;
7053 tep->Total_frame_size = tmp2 & 0x7ffffff;
7057 /* Third, apply any relocations to the unwind table. */
7058 for (relsec = section_headers;
7059 relsec < section_headers + elf_header.e_shnum;
7062 if (relsec->sh_type != SHT_RELA
7063 || relsec->sh_info >= elf_header.e_shnum
7064 || section_headers + relsec->sh_info != sec)
7067 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7071 for (rp = rela; rp < rela + nrelas; ++rp)
7073 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7074 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7076 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7077 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7079 warn (_("Skipping unexpected relocation type %s\n"), relname);
7083 i = rp->r_offset / unw_ent_size;
7085 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7088 aux->table[i].start.section = sym->st_shndx;
7089 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7092 aux->table[i].end.section = sym->st_shndx;
7093 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7103 aux->table_len = nentries;
7109 hppa_process_unwind (FILE * file)
7111 struct hppa_unw_aux_info aux;
7112 Elf_Internal_Shdr * unwsec = NULL;
7113 Elf_Internal_Shdr * strsec;
7114 Elf_Internal_Shdr * sec;
7117 if (string_table == NULL)
7120 memset (& aux, 0, sizeof (aux));
7122 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7124 if (sec->sh_type == SHT_SYMTAB
7125 && sec->sh_link < elf_header.e_shnum)
7127 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7129 strsec = section_headers + sec->sh_link;
7130 if (aux.strtab != NULL)
7132 error (_("Multiple auxillary string tables encountered\n"));
7135 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7138 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7140 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7145 printf (_("\nThere are no unwind sections in this file.\n"));
7147 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7149 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7151 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7152 printable_section_name (sec),
7153 (unsigned long) sec->sh_offset,
7154 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7156 slurp_hppa_unwind_table (file, &aux, sec);
7157 if (aux.table_len > 0)
7158 dump_hppa_unwind (&aux);
7161 free ((char *) aux.table);
7169 free ((char *) aux.strtab);
7174 unsigned char * data; /* The unwind data. */
7175 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7176 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7177 unsigned long nrelas; /* The number of relocations. */
7178 unsigned int rel_type; /* REL or RELA ? */
7179 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7182 struct arm_unw_aux_info
7184 FILE * file; /* The file containing the unwind sections. */
7185 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7186 unsigned long nsyms; /* Number of symbols. */
7187 char * strtab; /* The file's string table. */
7188 unsigned long strtab_size; /* Size of string table. */
7192 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7193 bfd_vma fn, struct absaddr addr)
7195 const char *procname;
7198 if (addr.section == SHN_UNDEF)
7201 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7202 aux->strtab_size, addr, &procname,
7205 print_vma (fn, PREFIX_HEX);
7209 fputs (" <", stdout);
7210 fputs (procname, stdout);
7213 printf ("+0x%lx", (unsigned long) sym_offset);
7214 fputc ('>', stdout);
7221 arm_free_section (struct arm_section *arm_sec)
7223 if (arm_sec->data != NULL)
7224 free (arm_sec->data);
7226 if (arm_sec->rela != NULL)
7227 free (arm_sec->rela);
7230 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7231 cached section and install SEC instead.
7232 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7233 and return its valued in * WORDP, relocating if necessary.
7234 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7235 relocation's offset in ADDR.
7236 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7237 into the string table of the symbol associated with the reloc. If no
7238 reloc was applied store -1 there.
7239 5) Return TRUE upon success, FALSE otherwise. */
7242 get_unwind_section_word (struct arm_unw_aux_info * aux,
7243 struct arm_section * arm_sec,
7244 Elf_Internal_Shdr * sec,
7245 bfd_vma word_offset,
7246 unsigned int * wordp,
7247 struct absaddr * addr,
7250 Elf_Internal_Rela *rp;
7251 Elf_Internal_Sym *sym;
7252 const char * relname;
7254 bfd_boolean wrapped;
7256 if (sec == NULL || arm_sec == NULL)
7259 addr->section = SHN_UNDEF;
7262 if (sym_name != NULL)
7263 *sym_name = (bfd_vma) -1;
7265 /* If necessary, update the section cache. */
7266 if (sec != arm_sec->sec)
7268 Elf_Internal_Shdr *relsec;
7270 arm_free_section (arm_sec);
7273 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7274 sec->sh_size, _("unwind data"));
7275 arm_sec->rela = NULL;
7276 arm_sec->nrelas = 0;
7278 for (relsec = section_headers;
7279 relsec < section_headers + elf_header.e_shnum;
7282 if (relsec->sh_info >= elf_header.e_shnum
7283 || section_headers + relsec->sh_info != sec
7284 /* PR 15745: Check the section type as well. */
7285 || (relsec->sh_type != SHT_REL
7286 && relsec->sh_type != SHT_RELA))
7289 arm_sec->rel_type = relsec->sh_type;
7290 if (relsec->sh_type == SHT_REL)
7292 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7294 & arm_sec->rela, & arm_sec->nrelas))
7297 else /* relsec->sh_type == SHT_RELA */
7299 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7301 & arm_sec->rela, & arm_sec->nrelas))
7307 arm_sec->next_rela = arm_sec->rela;
7310 /* If there is no unwind data we can do nothing. */
7311 if (arm_sec->data == NULL)
7314 /* If the offset is invalid then fail. */
7315 if (word_offset > sec->sh_size - 4)
7318 /* Get the word at the required offset. */
7319 word = byte_get (arm_sec->data + word_offset, 4);
7321 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7322 if (arm_sec->rela == NULL)
7328 /* Look through the relocs to find the one that applies to the provided offset. */
7330 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7332 bfd_vma prelval, offset;
7334 if (rp->r_offset > word_offset && !wrapped)
7339 if (rp->r_offset > word_offset)
7342 if (rp->r_offset & 3)
7344 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7345 (unsigned long) rp->r_offset);
7349 if (rp->r_offset < word_offset)
7352 /* PR 17531: file: 027-161405-0.004 */
7353 if (aux->symtab == NULL)
7356 if (arm_sec->rel_type == SHT_REL)
7358 offset = word & 0x7fffffff;
7359 if (offset & 0x40000000)
7360 offset |= ~ (bfd_vma) 0x7fffffff;
7362 else if (arm_sec->rel_type == SHT_RELA)
7363 offset = rp->r_addend;
7366 error (_("Unknown section relocation type %d encountered\n"),
7371 /* PR 17531 file: 027-1241568-0.004. */
7372 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7374 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7375 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7379 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7380 offset += sym->st_value;
7381 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7383 /* Check that we are processing the expected reloc type. */
7384 if (elf_header.e_machine == EM_ARM)
7386 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7387 if (relname == NULL)
7389 warn (_("Skipping unknown ARM relocation type: %d\n"),
7390 (int) ELF32_R_TYPE (rp->r_info));
7394 if (streq (relname, "R_ARM_NONE"))
7397 if (! streq (relname, "R_ARM_PREL31"))
7399 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7403 else if (elf_header.e_machine == EM_TI_C6000)
7405 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7406 if (relname == NULL)
7408 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7409 (int) ELF32_R_TYPE (rp->r_info));
7413 if (streq (relname, "R_C6000_NONE"))
7416 if (! streq (relname, "R_C6000_PREL31"))
7418 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7426 /* This function currently only supports ARM and TI unwinders. */
7427 warn (_("Only TI and ARM unwinders are currently supported\n"));
7431 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7432 addr->section = sym->st_shndx;
7433 addr->offset = offset;
7436 * sym_name = sym->st_name;
7441 arm_sec->next_rela = rp;
7446 static const char *tic6x_unwind_regnames[16] =
7448 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7449 "A14", "A13", "A12", "A11", "A10",
7450 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7454 decode_tic6x_unwind_regmask (unsigned int mask)
7458 for (i = 12; mask; mask >>= 1, i--)
7462 fputs (tic6x_unwind_regnames[i], stdout);
7464 fputs (", ", stdout);
7470 if (remaining == 0 && more_words) \
7473 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7474 data_offset, & word, & addr, NULL)) \
7480 #define GET_OP(OP) \
7485 (OP) = word >> 24; \
7490 printf (_("[Truncated opcode]\n")); \
7493 printf ("0x%02x ", OP)
7496 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7497 unsigned int word, unsigned int remaining,
7498 unsigned int more_words,
7499 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7500 struct arm_section *data_arm_sec)
7502 struct absaddr addr;
7504 /* Decode the unwinding instructions. */
7507 unsigned int op, op2;
7516 printf (" 0x%02x ", op);
7518 if ((op & 0xc0) == 0x00)
7520 int offset = ((op & 0x3f) << 2) + 4;
7522 printf (" vsp = vsp + %d", offset);
7524 else if ((op & 0xc0) == 0x40)
7526 int offset = ((op & 0x3f) << 2) + 4;
7528 printf (" vsp = vsp - %d", offset);
7530 else if ((op & 0xf0) == 0x80)
7533 if (op == 0x80 && op2 == 0)
7534 printf (_("Refuse to unwind"));
7537 unsigned int mask = ((op & 0x0f) << 8) | op2;
7542 for (i = 0; i < 12; i++)
7543 if (mask & (1 << i))
7549 printf ("r%d", 4 + i);
7554 else if ((op & 0xf0) == 0x90)
7556 if (op == 0x9d || op == 0x9f)
7557 printf (_(" [Reserved]"));
7559 printf (" vsp = r%d", op & 0x0f);
7561 else if ((op & 0xf0) == 0xa0)
7563 int end = 4 + (op & 0x07);
7568 for (i = 4; i <= end; i++)
7584 else if (op == 0xb0)
7585 printf (_(" finish"));
7586 else if (op == 0xb1)
7589 if (op2 == 0 || (op2 & 0xf0) != 0)
7590 printf (_("[Spare]"));
7593 unsigned int mask = op2 & 0x0f;
7598 for (i = 0; i < 12; i++)
7599 if (mask & (1 << i))
7610 else if (op == 0xb2)
7612 unsigned char buf[9];
7613 unsigned int i, len;
7614 unsigned long offset;
7616 for (i = 0; i < sizeof (buf); i++)
7619 if ((buf[i] & 0x80) == 0)
7622 if (i == sizeof (buf))
7623 printf (_("corrupt change to vsp"));
7626 offset = read_uleb128 (buf, &len, buf + i + 1);
7627 assert (len == i + 1);
7628 offset = offset * 4 + 0x204;
7629 printf ("vsp = vsp + %ld", offset);
7632 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7634 unsigned int first, last;
7641 printf ("pop {D%d", first);
7643 printf ("-D%d", first + last);
7646 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7648 unsigned int count = op & 0x07;
7652 printf ("-D%d", 8 + count);
7655 else if (op >= 0xc0 && op <= 0xc5)
7657 unsigned int count = op & 0x07;
7659 printf (" pop {wR10");
7661 printf ("-wR%d", 10 + count);
7664 else if (op == 0xc6)
7666 unsigned int first, last;
7671 printf ("pop {wR%d", first);
7673 printf ("-wR%d", first + last);
7676 else if (op == 0xc7)
7679 if (op2 == 0 || (op2 & 0xf0) != 0)
7680 printf (_("[Spare]"));
7683 unsigned int mask = op2 & 0x0f;
7688 for (i = 0; i < 4; i++)
7689 if (mask & (1 << i))
7695 printf ("wCGR%d", i);
7701 printf (_(" [unsupported opcode]"));
7707 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7708 unsigned int word, unsigned int remaining,
7709 unsigned int more_words,
7710 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7711 struct arm_section *data_arm_sec)
7713 struct absaddr addr;
7715 /* Decode the unwinding instructions. */
7718 unsigned int op, op2;
7727 printf (" 0x%02x ", op);
7729 if ((op & 0xc0) == 0x00)
7731 int offset = ((op & 0x3f) << 3) + 8;
7732 printf (" sp = sp + %d", offset);
7734 else if ((op & 0xc0) == 0x80)
7737 if (op == 0x80 && op2 == 0)
7738 printf (_("Refuse to unwind"));
7741 unsigned int mask = ((op & 0x1f) << 8) | op2;
7743 printf ("pop compact {");
7747 decode_tic6x_unwind_regmask (mask);
7751 else if ((op & 0xf0) == 0xc0)
7759 unsigned int offset;
7763 /* Scan entire instruction first so that GET_OP output is not
7764 interleaved with disassembly. */
7766 for (i = 0; nregs < (op & 0xf); i++)
7772 regpos[nregs].offset = i * 2;
7773 regpos[nregs].reg = reg;
7780 regpos[nregs].offset = i * 2 + 1;
7781 regpos[nregs].reg = reg;
7786 printf (_("pop frame {"));
7788 for (i = i * 2; i > 0; i--)
7790 if (regpos[reg].offset == i - 1)
7792 name = tic6x_unwind_regnames[regpos[reg].reg];
7799 fputs (name, stdout);
7806 else if (op == 0xd0)
7807 printf (" MOV FP, SP");
7808 else if (op == 0xd1)
7809 printf (" __c6xabi_pop_rts");
7810 else if (op == 0xd2)
7812 unsigned char buf[9];
7813 unsigned int i, len;
7814 unsigned long offset;
7816 for (i = 0; i < sizeof (buf); i++)
7819 if ((buf[i] & 0x80) == 0)
7822 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7823 if (i == sizeof (buf))
7825 printf ("<corrupt sp adjust>\n");
7826 warn (_("Corrupt stack pointer adjustment detected\n"));
7830 offset = read_uleb128 (buf, &len, buf + i + 1);
7831 assert (len == i + 1);
7832 offset = offset * 8 + 0x408;
7833 printf (_("sp = sp + %ld"), offset);
7835 else if ((op & 0xf0) == 0xe0)
7837 if ((op & 0x0f) == 7)
7840 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7844 printf (_(" [unsupported opcode]"));
7851 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7855 offset = word & 0x7fffffff;
7856 if (offset & 0x40000000)
7857 offset |= ~ (bfd_vma) 0x7fffffff;
7859 if (elf_header.e_machine == EM_TI_C6000)
7862 return offset + where;
7866 decode_arm_unwind (struct arm_unw_aux_info * aux,
7868 unsigned int remaining,
7869 bfd_vma data_offset,
7870 Elf_Internal_Shdr * data_sec,
7871 struct arm_section * data_arm_sec)
7874 unsigned int more_words = 0;
7875 struct absaddr addr;
7876 bfd_vma sym_name = (bfd_vma) -1;
7880 /* Fetch the first word.
7881 Note - when decoding an object file the address extracted
7882 here will always be 0. So we also pass in the sym_name
7883 parameter so that we can find the symbol associated with
7884 the personality routine. */
7885 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7886 & word, & addr, & sym_name))
7892 if ((word & 0x80000000) == 0)
7894 /* Expand prel31 for personality routine. */
7896 const char *procname;
7898 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7899 printf (_(" Personality routine: "));
7901 && addr.section == SHN_UNDEF && addr.offset == 0
7902 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7904 procname = aux->strtab + sym_name;
7905 print_vma (fn, PREFIX_HEX);
7908 fputs (" <", stdout);
7909 fputs (procname, stdout);
7910 fputc ('>', stdout);
7914 procname = arm_print_vma_and_name (aux, fn, addr);
7915 fputc ('\n', stdout);
7917 /* The GCC personality routines use the standard compact
7918 encoding, starting with one byte giving the number of
7920 if (procname != NULL
7921 && (const_strneq (procname, "__gcc_personality_v0")
7922 || const_strneq (procname, "__gxx_personality_v0")
7923 || const_strneq (procname, "__gcj_personality_v0")
7924 || const_strneq (procname, "__gnu_objc_personality_v0")))
7931 printf (_(" [Truncated data]\n"));
7934 more_words = word >> 24;
7944 /* ARM EHABI Section 6.3:
7946 An exception-handling table entry for the compact model looks like:
7950 1 0 index Data for personalityRoutine[index] */
7952 if (elf_header.e_machine == EM_ARM
7953 && (word & 0x70000000))
7954 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7956 per_index = (word >> 24) & 0x7f;
7957 printf (_(" Compact model index: %d\n"), per_index);
7964 else if (per_index < 3)
7966 more_words = (word >> 16) & 0xff;
7972 switch (elf_header.e_machine)
7977 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7978 data_offset, data_sec, data_arm_sec);
7982 warn (_("Unknown ARM compact model index encountered\n"));
7983 printf (_(" [reserved]\n"));
7990 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7991 data_offset, data_sec, data_arm_sec);
7993 else if (per_index < 5)
7995 if (((word >> 17) & 0x7f) == 0x7f)
7996 printf (_(" Restore stack from frame pointer\n"));
7998 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7999 printf (_(" Registers restored: "));
8001 printf (" (compact) ");
8002 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8004 printf (_(" Return register: %s\n"),
8005 tic6x_unwind_regnames[word & 0xf]);
8008 printf (_(" [reserved (%d)]\n"), per_index);
8012 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8013 elf_header.e_machine);
8016 /* Decode the descriptors. Not implemented. */
8020 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8022 struct arm_section exidx_arm_sec, extab_arm_sec;
8023 unsigned int i, exidx_len;
8025 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8026 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8027 exidx_len = exidx_sec->sh_size / 8;
8029 for (i = 0; i < exidx_len; i++)
8031 unsigned int exidx_fn, exidx_entry;
8032 struct absaddr fn_addr, entry_addr;
8035 fputc ('\n', stdout);
8037 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8038 8 * i, & exidx_fn, & fn_addr, NULL)
8039 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8040 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8042 arm_free_section (& exidx_arm_sec);
8043 arm_free_section (& extab_arm_sec);
8047 /* ARM EHABI, Section 5:
8048 An index table entry consists of 2 words.
8049 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8050 if (exidx_fn & 0x80000000)
8051 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8053 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8055 arm_print_vma_and_name (aux, fn, fn_addr);
8056 fputs (": ", stdout);
8058 if (exidx_entry == 1)
8060 print_vma (exidx_entry, PREFIX_HEX);
8061 fputs (" [cantunwind]\n", stdout);
8063 else if (exidx_entry & 0x80000000)
8065 print_vma (exidx_entry, PREFIX_HEX);
8066 fputc ('\n', stdout);
8067 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8071 bfd_vma table, table_offset = 0;
8072 Elf_Internal_Shdr *table_sec;
8074 fputs ("@", stdout);
8075 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8076 print_vma (table, PREFIX_HEX);
8079 /* Locate the matching .ARM.extab. */
8080 if (entry_addr.section != SHN_UNDEF
8081 && entry_addr.section < elf_header.e_shnum)
8083 table_sec = section_headers + entry_addr.section;
8084 table_offset = entry_addr.offset;
8088 table_sec = find_section_by_address (table);
8089 if (table_sec != NULL)
8090 table_offset = table - table_sec->sh_addr;
8092 if (table_sec == NULL)
8094 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8095 (unsigned long) table);
8098 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8105 arm_free_section (&exidx_arm_sec);
8106 arm_free_section (&extab_arm_sec);
8109 /* Used for both ARM and C6X unwinding tables. */
8112 arm_process_unwind (FILE *file)
8114 struct arm_unw_aux_info aux;
8115 Elf_Internal_Shdr *unwsec = NULL;
8116 Elf_Internal_Shdr *strsec;
8117 Elf_Internal_Shdr *sec;
8119 unsigned int sec_type;
8121 switch (elf_header.e_machine)
8124 sec_type = SHT_ARM_EXIDX;
8128 sec_type = SHT_C6000_UNWIND;
8132 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8133 elf_header.e_machine);
8137 if (string_table == NULL)
8140 memset (& aux, 0, sizeof (aux));
8143 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8145 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8147 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8149 strsec = section_headers + sec->sh_link;
8151 /* PR binutils/17531 file: 011-12666-0.004. */
8152 if (aux.strtab != NULL)
8154 error (_("Multiple string tables found in file.\n"));
8157 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8158 1, strsec->sh_size, _("string table"));
8159 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8161 else if (sec->sh_type == sec_type)
8166 printf (_("\nThere are no unwind sections in this file.\n"));
8168 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8170 if (sec->sh_type == sec_type)
8172 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8173 printable_section_name (sec),
8174 (unsigned long) sec->sh_offset,
8175 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8177 dump_arm_unwind (&aux, sec);
8184 free ((char *) aux.strtab);
8188 process_unwind (FILE * file)
8190 struct unwind_handler
8193 void (* handler)(FILE *);
8196 { EM_ARM, arm_process_unwind },
8197 { EM_IA_64, ia64_process_unwind },
8198 { EM_PARISC, hppa_process_unwind },
8199 { EM_TI_C6000, arm_process_unwind },
8207 for (i = 0; handlers[i].handler != NULL; i++)
8208 if (elf_header.e_machine == handlers[i].machtype)
8210 handlers[i].handler (file);
8214 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8215 get_machine_name (elf_header.e_machine));
8219 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8221 switch (entry->d_tag)
8224 if (entry->d_un.d_val == 0)
8228 static const char * opts[] =
8230 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8231 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8232 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8233 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8239 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8240 if (entry->d_un.d_val & (1 << cnt))
8242 printf ("%s%s", first ? "" : " ", opts[cnt]);
8248 case DT_MIPS_IVERSION:
8249 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8250 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8254 sprintf_vma (buf, entry->d_un.d_ptr);
8255 /* Note: coded this way so that there is a single string for translation. */
8256 printf (_("<corrupt: %s>"), buf);
8260 case DT_MIPS_TIME_STAMP:
8265 time_t atime = entry->d_un.d_val;
8266 tmp = gmtime (&atime);
8267 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8268 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8269 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8270 printf (_("Time Stamp: %s"), timebuf);
8274 case DT_MIPS_RLD_VERSION:
8275 case DT_MIPS_LOCAL_GOTNO:
8276 case DT_MIPS_CONFLICTNO:
8277 case DT_MIPS_LIBLISTNO:
8278 case DT_MIPS_SYMTABNO:
8279 case DT_MIPS_UNREFEXTNO:
8280 case DT_MIPS_HIPAGENO:
8281 case DT_MIPS_DELTA_CLASS_NO:
8282 case DT_MIPS_DELTA_INSTANCE_NO:
8283 case DT_MIPS_DELTA_RELOC_NO:
8284 case DT_MIPS_DELTA_SYM_NO:
8285 case DT_MIPS_DELTA_CLASSSYM_NO:
8286 case DT_MIPS_COMPACT_SIZE:
8287 print_vma (entry->d_un.d_ptr, DEC);
8291 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8297 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8299 switch (entry->d_tag)
8301 case DT_HP_DLD_FLAGS:
8310 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8311 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8312 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8313 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8314 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8315 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8316 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8317 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8318 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8319 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8320 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8321 { DT_HP_GST, "HP_GST" },
8322 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8323 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8324 { DT_HP_NODELETE, "HP_NODELETE" },
8325 { DT_HP_GROUP, "HP_GROUP" },
8326 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8330 bfd_vma val = entry->d_un.d_val;
8332 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8333 if (val & flags[cnt].bit)
8337 fputs (flags[cnt].str, stdout);
8339 val ^= flags[cnt].bit;
8342 if (val != 0 || first)
8346 print_vma (val, HEX);
8352 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8360 /* VMS vs Unix time offset and factor. */
8362 #define VMS_EPOCH_OFFSET 35067168000000000LL
8363 #define VMS_GRANULARITY_FACTOR 10000000
8365 /* Display a VMS time in a human readable format. */
8368 print_vms_time (bfd_int64_t vmstime)
8373 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8374 tm = gmtime (&unxtime);
8375 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8376 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8377 tm->tm_hour, tm->tm_min, tm->tm_sec);
8382 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8384 switch (entry->d_tag)
8386 case DT_IA_64_PLT_RESERVE:
8387 /* First 3 slots reserved. */
8388 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8390 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8393 case DT_IA_64_VMS_LINKTIME:
8395 print_vms_time (entry->d_un.d_val);
8399 case DT_IA_64_VMS_LNKFLAGS:
8400 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8401 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8402 printf (" CALL_DEBUG");
8403 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8404 printf (" NOP0BUFS");
8405 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8406 printf (" P0IMAGE");
8407 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8408 printf (" MKTHREADS");
8409 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8410 printf (" UPCALLS");
8411 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8413 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8414 printf (" INITIALIZE");
8415 if (entry->d_un.d_val & VMS_LF_MAIN)
8417 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8418 printf (" EXE_INIT");
8419 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8420 printf (" TBK_IN_IMG");
8421 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8422 printf (" DBG_IN_IMG");
8423 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8424 printf (" TBK_IN_DSF");
8425 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8426 printf (" DBG_IN_DSF");
8427 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8428 printf (" SIGNATURES");
8429 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8430 printf (" REL_SEG_OFF");
8434 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8441 get_32bit_dynamic_section (FILE * file)
8443 Elf32_External_Dyn * edyn;
8444 Elf32_External_Dyn * ext;
8445 Elf_Internal_Dyn * entry;
8447 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8448 dynamic_size, _("dynamic section"));
8452 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8453 might not have the luxury of section headers. Look for the DT_NULL
8454 terminator to determine the number of entries. */
8455 for (ext = edyn, dynamic_nent = 0;
8456 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8460 if (BYTE_GET (ext->d_tag) == DT_NULL)
8464 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8466 if (dynamic_section == NULL)
8468 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8469 (unsigned long) dynamic_nent);
8474 for (ext = edyn, entry = dynamic_section;
8475 entry < dynamic_section + dynamic_nent;
8478 entry->d_tag = BYTE_GET (ext->d_tag);
8479 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8488 get_64bit_dynamic_section (FILE * file)
8490 Elf64_External_Dyn * edyn;
8491 Elf64_External_Dyn * ext;
8492 Elf_Internal_Dyn * entry;
8494 /* Read in the data. */
8495 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8496 dynamic_size, _("dynamic section"));
8500 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8501 might not have the luxury of section headers. Look for the DT_NULL
8502 terminator to determine the number of entries. */
8503 for (ext = edyn, dynamic_nent = 0;
8504 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8505 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8509 if (BYTE_GET (ext->d_tag) == DT_NULL)
8513 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8515 if (dynamic_section == NULL)
8517 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8518 (unsigned long) dynamic_nent);
8523 /* Convert from external to internal formats. */
8524 for (ext = edyn, entry = dynamic_section;
8525 entry < dynamic_section + dynamic_nent;
8528 entry->d_tag = BYTE_GET (ext->d_tag);
8529 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8538 print_dynamic_flags (bfd_vma flags)
8546 flag = flags & - flags;
8556 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8557 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8558 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8559 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8560 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8561 default: fputs (_("unknown"), stdout); break;
8567 /* Parse and display the contents of the dynamic section. */
8570 process_dynamic_section (FILE * file)
8572 Elf_Internal_Dyn * entry;
8574 if (dynamic_size == 0)
8577 printf (_("\nThere is no dynamic section in this file.\n"));
8584 if (! get_32bit_dynamic_section (file))
8587 else if (! get_64bit_dynamic_section (file))
8590 /* Find the appropriate symbol table. */
8591 if (dynamic_symbols == NULL)
8593 for (entry = dynamic_section;
8594 entry < dynamic_section + dynamic_nent;
8597 Elf_Internal_Shdr section;
8599 if (entry->d_tag != DT_SYMTAB)
8602 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8604 /* Since we do not know how big the symbol table is,
8605 we default to reading in the entire file (!) and
8606 processing that. This is overkill, I know, but it
8608 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8610 if (archive_file_offset != 0)
8611 section.sh_size = archive_file_size - section.sh_offset;
8614 if (fseek (file, 0, SEEK_END))
8615 error (_("Unable to seek to end of file!\n"));
8617 section.sh_size = ftell (file) - section.sh_offset;
8621 section.sh_entsize = sizeof (Elf32_External_Sym);
8623 section.sh_entsize = sizeof (Elf64_External_Sym);
8624 section.sh_name = string_table_length;
8626 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8627 if (num_dynamic_syms < 1)
8629 error (_("Unable to determine the number of symbols to load\n"));
8635 /* Similarly find a string table. */
8636 if (dynamic_strings == NULL)
8638 for (entry = dynamic_section;
8639 entry < dynamic_section + dynamic_nent;
8642 unsigned long offset;
8645 if (entry->d_tag != DT_STRTAB)
8648 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8650 /* Since we do not know how big the string table is,
8651 we default to reading in the entire file (!) and
8652 processing that. This is overkill, I know, but it
8655 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8657 if (archive_file_offset != 0)
8658 str_tab_len = archive_file_size - offset;
8661 if (fseek (file, 0, SEEK_END))
8662 error (_("Unable to seek to end of file\n"));
8663 str_tab_len = ftell (file) - offset;
8666 if (str_tab_len < 1)
8669 (_("Unable to determine the length of the dynamic string table\n"));
8673 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8675 _("dynamic string table"));
8676 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8681 /* And find the syminfo section if available. */
8682 if (dynamic_syminfo == NULL)
8684 unsigned long syminsz = 0;
8686 for (entry = dynamic_section;
8687 entry < dynamic_section + dynamic_nent;
8690 if (entry->d_tag == DT_SYMINENT)
8692 /* Note: these braces are necessary to avoid a syntax
8693 error from the SunOS4 C compiler. */
8694 /* PR binutils/17531: A corrupt file can trigger this test.
8695 So do not use an assert, instead generate an error message. */
8696 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8697 error (_("Bad value (%d) for SYMINENT entry\n"),
8698 (int) entry->d_un.d_val);
8700 else if (entry->d_tag == DT_SYMINSZ)
8701 syminsz = entry->d_un.d_val;
8702 else if (entry->d_tag == DT_SYMINFO)
8703 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8707 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8709 Elf_External_Syminfo * extsyminfo;
8710 Elf_External_Syminfo * extsym;
8711 Elf_Internal_Syminfo * syminfo;
8713 /* There is a syminfo section. Read the data. */
8714 extsyminfo = (Elf_External_Syminfo *)
8715 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8716 _("symbol information"));
8720 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8721 if (dynamic_syminfo == NULL)
8723 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8724 (unsigned long) syminsz);
8728 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8729 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8730 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8731 ++syminfo, ++extsym)
8733 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8734 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8741 if (do_dynamic && dynamic_addr)
8742 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8743 dynamic_addr, (unsigned long) dynamic_nent);
8745 printf (_(" Tag Type Name/Value\n"));
8747 for (entry = dynamic_section;
8748 entry < dynamic_section + dynamic_nent;
8756 print_vma (entry->d_tag, FULL_HEX);
8757 dtype = get_dynamic_type (entry->d_tag);
8758 printf (" (%s)%*s", dtype,
8759 ((is_32bit_elf ? 27 : 19)
8760 - (int) strlen (dtype)),
8764 switch (entry->d_tag)
8768 print_dynamic_flags (entry->d_un.d_val);
8778 switch (entry->d_tag)
8781 printf (_("Auxiliary library"));
8785 printf (_("Filter library"));
8789 printf (_("Configuration file"));
8793 printf (_("Dependency audit library"));
8797 printf (_("Audit library"));
8801 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8802 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8806 print_vma (entry->d_un.d_val, PREFIX_HEX);
8815 printf (_("Flags:"));
8817 if (entry->d_un.d_val == 0)
8818 printf (_(" None\n"));
8821 unsigned long int val = entry->d_un.d_val;
8823 if (val & DTF_1_PARINIT)
8825 printf (" PARINIT");
8826 val ^= DTF_1_PARINIT;
8828 if (val & DTF_1_CONFEXP)
8830 printf (" CONFEXP");
8831 val ^= DTF_1_CONFEXP;
8834 printf (" %lx", val);
8843 printf (_("Flags:"));
8845 if (entry->d_un.d_val == 0)
8846 printf (_(" None\n"));
8849 unsigned long int val = entry->d_un.d_val;
8851 if (val & DF_P1_LAZYLOAD)
8853 printf (" LAZYLOAD");
8854 val ^= DF_P1_LAZYLOAD;
8856 if (val & DF_P1_GROUPPERM)
8858 printf (" GROUPPERM");
8859 val ^= DF_P1_GROUPPERM;
8862 printf (" %lx", val);
8871 printf (_("Flags:"));
8872 if (entry->d_un.d_val == 0)
8873 printf (_(" None\n"));
8876 unsigned long int val = entry->d_un.d_val;
8883 if (val & DF_1_GLOBAL)
8888 if (val & DF_1_GROUP)
8893 if (val & DF_1_NODELETE)
8895 printf (" NODELETE");
8896 val ^= DF_1_NODELETE;
8898 if (val & DF_1_LOADFLTR)
8900 printf (" LOADFLTR");
8901 val ^= DF_1_LOADFLTR;
8903 if (val & DF_1_INITFIRST)
8905 printf (" INITFIRST");
8906 val ^= DF_1_INITFIRST;
8908 if (val & DF_1_NOOPEN)
8913 if (val & DF_1_ORIGIN)
8918 if (val & DF_1_DIRECT)
8923 if (val & DF_1_TRANS)
8928 if (val & DF_1_INTERPOSE)
8930 printf (" INTERPOSE");
8931 val ^= DF_1_INTERPOSE;
8933 if (val & DF_1_NODEFLIB)
8935 printf (" NODEFLIB");
8936 val ^= DF_1_NODEFLIB;
8938 if (val & DF_1_NODUMP)
8943 if (val & DF_1_CONFALT)
8945 printf (" CONFALT");
8946 val ^= DF_1_CONFALT;
8948 if (val & DF_1_ENDFILTEE)
8950 printf (" ENDFILTEE");
8951 val ^= DF_1_ENDFILTEE;
8953 if (val & DF_1_DISPRELDNE)
8955 printf (" DISPRELDNE");
8956 val ^= DF_1_DISPRELDNE;
8958 if (val & DF_1_DISPRELPND)
8960 printf (" DISPRELPND");
8961 val ^= DF_1_DISPRELPND;
8963 if (val & DF_1_NODIRECT)
8965 printf (" NODIRECT");
8966 val ^= DF_1_NODIRECT;
8968 if (val & DF_1_IGNMULDEF)
8970 printf (" IGNMULDEF");
8971 val ^= DF_1_IGNMULDEF;
8973 if (val & DF_1_NOKSYMS)
8975 printf (" NOKSYMS");
8976 val ^= DF_1_NOKSYMS;
8978 if (val & DF_1_NOHDR)
8983 if (val & DF_1_EDITED)
8988 if (val & DF_1_NORELOC)
8990 printf (" NORELOC");
8991 val ^= DF_1_NORELOC;
8993 if (val & DF_1_SYMINTPOSE)
8995 printf (" SYMINTPOSE");
8996 val ^= DF_1_SYMINTPOSE;
8998 if (val & DF_1_GLOBAUDIT)
9000 printf (" GLOBAUDIT");
9001 val ^= DF_1_GLOBAUDIT;
9003 if (val & DF_1_SINGLETON)
9005 printf (" SINGLETON");
9006 val ^= DF_1_SINGLETON;
9009 printf (" %lx", val);
9016 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9018 puts (get_dynamic_type (entry->d_un.d_val));
9038 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9044 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9045 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9051 switch (entry->d_tag)
9054 printf (_("Shared library: [%s]"), name);
9056 if (streq (name, program_interpreter))
9057 printf (_(" program interpreter"));
9061 printf (_("Library soname: [%s]"), name);
9065 printf (_("Library rpath: [%s]"), name);
9069 printf (_("Library runpath: [%s]"), name);
9073 print_vma (entry->d_un.d_val, PREFIX_HEX);
9078 print_vma (entry->d_un.d_val, PREFIX_HEX);
9091 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9095 case DT_INIT_ARRAYSZ:
9096 case DT_FINI_ARRAYSZ:
9097 case DT_GNU_CONFLICTSZ:
9098 case DT_GNU_LIBLISTSZ:
9101 print_vma (entry->d_un.d_val, UNSIGNED);
9102 printf (_(" (bytes)\n"));
9112 print_vma (entry->d_un.d_val, UNSIGNED);
9125 if (entry->d_tag == DT_USED
9126 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9128 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9132 printf (_("Not needed object: [%s]\n"), name);
9137 print_vma (entry->d_un.d_val, PREFIX_HEX);
9143 /* The value of this entry is ignored. */
9148 case DT_GNU_PRELINKED:
9152 time_t atime = entry->d_un.d_val;
9154 tmp = gmtime (&atime);
9155 /* PR 17533 file: 041-1244816-0.004. */
9157 printf (_("<corrupt time val: %lx"),
9158 (unsigned long) atime);
9160 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9161 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9162 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9168 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9171 print_vma (entry->d_un.d_val, PREFIX_HEX);
9177 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9178 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9183 switch (elf_header.e_machine)
9186 case EM_MIPS_RS3_LE:
9187 dynamic_section_mips_val (entry);
9190 dynamic_section_parisc_val (entry);
9193 dynamic_section_ia64_val (entry);
9196 print_vma (entry->d_un.d_val, PREFIX_HEX);
9208 get_ver_flags (unsigned int flags)
9210 static char buff[32];
9217 if (flags & VER_FLG_BASE)
9218 strcat (buff, "BASE ");
9220 if (flags & VER_FLG_WEAK)
9222 if (flags & VER_FLG_BASE)
9223 strcat (buff, "| ");
9225 strcat (buff, "WEAK ");
9228 if (flags & VER_FLG_INFO)
9230 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9231 strcat (buff, "| ");
9233 strcat (buff, "INFO ");
9236 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9237 strcat (buff, _("| <unknown>"));
9242 /* Display the contents of the version sections. */
9245 process_version_sections (FILE * file)
9247 Elf_Internal_Shdr * section;
9254 for (i = 0, section = section_headers;
9255 i < elf_header.e_shnum;
9258 switch (section->sh_type)
9260 case SHT_GNU_verdef:
9262 Elf_External_Verdef * edefs;
9269 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9270 printable_section_name (section),
9273 printf (_(" Addr: 0x"));
9274 printf_vma (section->sh_addr);
9275 printf (_(" Offset: %#08lx Link: %u (%s)"),
9276 (unsigned long) section->sh_offset, section->sh_link,
9277 printable_section_name_from_index (section->sh_link));
9279 edefs = (Elf_External_Verdef *)
9280 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9281 _("version definition section"));
9284 endbuf = (char *) edefs + section->sh_size;
9286 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9289 Elf_External_Verdef * edef;
9290 Elf_Internal_Verdef ent;
9291 Elf_External_Verdaux * eaux;
9292 Elf_Internal_Verdaux aux;
9296 /* Check for very large indicies. */
9297 if (idx > (size_t) (endbuf - (char *) edefs))
9300 vstart = ((char *) edefs) + idx;
9301 if (vstart + sizeof (*edef) > endbuf)
9304 edef = (Elf_External_Verdef *) vstart;
9306 ent.vd_version = BYTE_GET (edef->vd_version);
9307 ent.vd_flags = BYTE_GET (edef->vd_flags);
9308 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9309 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9310 ent.vd_hash = BYTE_GET (edef->vd_hash);
9311 ent.vd_aux = BYTE_GET (edef->vd_aux);
9312 ent.vd_next = BYTE_GET (edef->vd_next);
9314 printf (_(" %#06x: Rev: %d Flags: %s"),
9315 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9317 printf (_(" Index: %d Cnt: %d "),
9318 ent.vd_ndx, ent.vd_cnt);
9320 /* Check for overflow. */
9321 if (ent.vd_aux > (size_t) (endbuf - vstart))
9324 vstart += ent.vd_aux;
9326 eaux = (Elf_External_Verdaux *) vstart;
9328 aux.vda_name = BYTE_GET (eaux->vda_name);
9329 aux.vda_next = BYTE_GET (eaux->vda_next);
9331 if (VALID_DYNAMIC_NAME (aux.vda_name))
9332 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9334 printf (_("Name index: %ld\n"), aux.vda_name);
9336 isum = idx + ent.vd_aux;
9338 for (j = 1; j < ent.vd_cnt; j++)
9340 /* Check for overflow. */
9341 if (aux.vda_next > (size_t) (endbuf - vstart))
9344 isum += aux.vda_next;
9345 vstart += aux.vda_next;
9347 eaux = (Elf_External_Verdaux *) vstart;
9348 if (vstart + sizeof (*eaux) > endbuf)
9351 aux.vda_name = BYTE_GET (eaux->vda_name);
9352 aux.vda_next = BYTE_GET (eaux->vda_next);
9354 if (VALID_DYNAMIC_NAME (aux.vda_name))
9355 printf (_(" %#06x: Parent %d: %s\n"),
9356 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9358 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9359 isum, j, aux.vda_name);
9363 printf (_(" Version def aux past end of section\n"));
9365 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9366 if (idx + ent.vd_next <= idx)
9372 if (cnt < section->sh_info)
9373 printf (_(" Version definition past end of section\n"));
9379 case SHT_GNU_verneed:
9381 Elf_External_Verneed * eneed;
9388 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9389 printable_section_name (section), section->sh_info);
9391 printf (_(" Addr: 0x"));
9392 printf_vma (section->sh_addr);
9393 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9394 (unsigned long) section->sh_offset, section->sh_link,
9395 printable_section_name_from_index (section->sh_link));
9397 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9398 section->sh_offset, 1,
9400 _("Version Needs section"));
9403 endbuf = (char *) eneed + section->sh_size;
9405 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9407 Elf_External_Verneed * entry;
9408 Elf_Internal_Verneed ent;
9413 if (idx > (size_t) (endbuf - (char *) eneed))
9416 vstart = ((char *) eneed) + idx;
9417 if (vstart + sizeof (*entry) > endbuf)
9420 entry = (Elf_External_Verneed *) vstart;
9422 ent.vn_version = BYTE_GET (entry->vn_version);
9423 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9424 ent.vn_file = BYTE_GET (entry->vn_file);
9425 ent.vn_aux = BYTE_GET (entry->vn_aux);
9426 ent.vn_next = BYTE_GET (entry->vn_next);
9428 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9430 if (VALID_DYNAMIC_NAME (ent.vn_file))
9431 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9433 printf (_(" File: %lx"), ent.vn_file);
9435 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9437 /* Check for overflow. */
9438 if (ent.vn_aux > (size_t) (endbuf - vstart))
9440 vstart += ent.vn_aux;
9442 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9444 Elf_External_Vernaux * eaux;
9445 Elf_Internal_Vernaux aux;
9447 if (vstart + sizeof (*eaux) > endbuf)
9449 eaux = (Elf_External_Vernaux *) vstart;
9451 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9452 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9453 aux.vna_other = BYTE_GET (eaux->vna_other);
9454 aux.vna_name = BYTE_GET (eaux->vna_name);
9455 aux.vna_next = BYTE_GET (eaux->vna_next);
9457 if (VALID_DYNAMIC_NAME (aux.vna_name))
9458 printf (_(" %#06x: Name: %s"),
9459 isum, GET_DYNAMIC_NAME (aux.vna_name));
9461 printf (_(" %#06x: Name index: %lx"),
9462 isum, aux.vna_name);
9464 printf (_(" Flags: %s Version: %d\n"),
9465 get_ver_flags (aux.vna_flags), aux.vna_other);
9467 /* Check for overflow. */
9468 if (aux.vna_next > (size_t) (endbuf - vstart)
9469 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9471 warn (_("Invalid vna_next field of %lx\n"),
9476 isum += aux.vna_next;
9477 vstart += aux.vna_next;
9481 warn (_("Missing Version Needs auxillary information\n"));
9483 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9485 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9486 cnt = section->sh_info;
9492 if (cnt < section->sh_info)
9493 warn (_("Missing Version Needs information\n"));
9499 case SHT_GNU_versym:
9501 Elf_Internal_Shdr * link_section;
9504 unsigned char * edata;
9505 unsigned short * data;
9507 Elf_Internal_Sym * symbols;
9508 Elf_Internal_Shdr * string_sec;
9509 unsigned long num_syms;
9512 if (section->sh_link >= elf_header.e_shnum)
9515 link_section = section_headers + section->sh_link;
9516 total = section->sh_size / sizeof (Elf_External_Versym);
9518 if (link_section->sh_link >= elf_header.e_shnum)
9523 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9524 if (symbols == NULL)
9527 string_sec = section_headers + link_section->sh_link;
9529 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9530 string_sec->sh_size,
9531 _("version string table"));
9538 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9539 printable_section_name (section), (unsigned long) total);
9541 printf (_(" Addr: "));
9542 printf_vma (section->sh_addr);
9543 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9544 (unsigned long) section->sh_offset, section->sh_link,
9545 printable_section_name (link_section));
9547 off = offset_from_vma (file,
9548 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9549 total * sizeof (short));
9550 edata = (unsigned char *) get_data (NULL, file, off, total,
9552 _("version symbol data"));
9560 data = (short unsigned int *) cmalloc (total, sizeof (short));
9562 for (cnt = total; cnt --;)
9563 data[cnt] = byte_get (edata + cnt * sizeof (short),
9568 for (cnt = 0; cnt < total; cnt += 4)
9571 int check_def, check_need;
9574 printf (" %03x:", cnt);
9576 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9577 switch (data[cnt + j])
9580 fputs (_(" 0 (*local*) "), stdout);
9584 fputs (_(" 1 (*global*) "), stdout);
9588 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9589 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9591 /* If this index value is greater than the size of the symbols
9592 array, break to avoid an out-of-bounds read. */
9593 if ((unsigned long)(cnt + j) >= num_syms)
9595 warn (_("invalid index into symbol array\n"));
9601 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9602 || section_headers[symbols[cnt + j].st_shndx].sh_type
9605 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9612 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9614 Elf_Internal_Verneed ivn;
9615 unsigned long offset;
9617 offset = offset_from_vma
9618 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9619 sizeof (Elf_External_Verneed));
9623 Elf_Internal_Vernaux ivna;
9624 Elf_External_Verneed evn;
9625 Elf_External_Vernaux evna;
9626 unsigned long a_off;
9628 if (get_data (&evn, file, offset, sizeof (evn), 1,
9629 _("version need")) == NULL)
9632 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9633 ivn.vn_next = BYTE_GET (evn.vn_next);
9635 a_off = offset + ivn.vn_aux;
9639 if (get_data (&evna, file, a_off, sizeof (evna),
9640 1, _("version need aux (2)")) == NULL)
9647 ivna.vna_next = BYTE_GET (evna.vna_next);
9648 ivna.vna_other = BYTE_GET (evna.vna_other);
9651 a_off += ivna.vna_next;
9653 while (ivna.vna_other != data[cnt + j]
9654 && ivna.vna_next != 0);
9656 if (ivna.vna_other == data[cnt + j])
9658 ivna.vna_name = BYTE_GET (evna.vna_name);
9660 if (ivna.vna_name >= string_sec->sh_size)
9661 name = _("*invalid*");
9663 name = strtab + ivna.vna_name;
9664 nn += printf ("(%s%-*s",
9666 12 - (int) strlen (name),
9672 offset += ivn.vn_next;
9674 while (ivn.vn_next);
9677 if (check_def && data[cnt + j] != 0x8001
9678 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9680 Elf_Internal_Verdef ivd;
9681 Elf_External_Verdef evd;
9682 unsigned long offset;
9684 offset = offset_from_vma
9685 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9690 if (get_data (&evd, file, offset, sizeof (evd), 1,
9691 _("version def")) == NULL)
9694 /* PR 17531: file: 046-1082287-0.004. */
9695 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9700 ivd.vd_next = BYTE_GET (evd.vd_next);
9701 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9704 offset += ivd.vd_next;
9706 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9707 && ivd.vd_next != 0);
9709 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9711 Elf_External_Verdaux evda;
9712 Elf_Internal_Verdaux ivda;
9714 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9716 if (get_data (&evda, file,
9717 offset - ivd.vd_next + ivd.vd_aux,
9719 _("version def aux")) == NULL)
9722 ivda.vda_name = BYTE_GET (evda.vda_name);
9724 if (ivda.vda_name >= string_sec->sh_size)
9725 name = _("*invalid*");
9727 name = strtab + ivda.vda_name;
9728 nn += printf ("(%s%-*s",
9730 12 - (int) strlen (name),
9736 printf ("%*c", 18 - nn, ' ');
9754 printf (_("\nNo version information found in this file.\n"));
9760 get_symbol_binding (unsigned int binding)
9762 static char buff[32];
9766 case STB_LOCAL: return "LOCAL";
9767 case STB_GLOBAL: return "GLOBAL";
9768 case STB_WEAK: return "WEAK";
9770 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9771 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9773 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9775 if (binding == STB_GNU_UNIQUE
9776 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9777 /* GNU is still using the default value 0. */
9778 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9780 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9783 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9789 get_symbol_type (unsigned int type)
9791 static char buff[32];
9795 case STT_NOTYPE: return "NOTYPE";
9796 case STT_OBJECT: return "OBJECT";
9797 case STT_FUNC: return "FUNC";
9798 case STT_SECTION: return "SECTION";
9799 case STT_FILE: return "FILE";
9800 case STT_COMMON: return "COMMON";
9801 case STT_TLS: return "TLS";
9802 case STT_RELC: return "RELC";
9803 case STT_SRELC: return "SRELC";
9805 if (type >= STT_LOPROC && type <= STT_HIPROC)
9807 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9808 return "THUMB_FUNC";
9810 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9813 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9814 return "PARISC_MILLI";
9816 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9818 else if (type >= STT_LOOS && type <= STT_HIOS)
9820 if (elf_header.e_machine == EM_PARISC)
9822 if (type == STT_HP_OPAQUE)
9824 if (type == STT_HP_STUB)
9828 if (type == STT_GNU_IFUNC
9829 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9830 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9831 /* GNU is still using the default value 0. */
9832 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9835 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9838 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9844 get_symbol_visibility (unsigned int visibility)
9848 case STV_DEFAULT: return "DEFAULT";
9849 case STV_INTERNAL: return "INTERNAL";
9850 case STV_HIDDEN: return "HIDDEN";
9851 case STV_PROTECTED: return "PROTECTED";
9853 error (_("Unrecognized visibility value: %u"), visibility);
9854 return _("<unknown>");
9859 get_mips_symbol_other (unsigned int other)
9871 case STO_MICROMIPS | STO_MIPS_PIC:
9872 return "MICROMIPS, MIPS PIC";
9881 get_ia64_symbol_other (unsigned int other)
9885 static char res[32];
9889 /* Function types is for images and .STB files only. */
9890 switch (elf_header.e_type)
9894 switch (VMS_ST_FUNC_TYPE (other))
9896 case VMS_SFT_CODE_ADDR:
9897 strcat (res, " CA");
9899 case VMS_SFT_SYMV_IDX:
9900 strcat (res, " VEC");
9903 strcat (res, " FD");
9905 case VMS_SFT_RESERVE:
9906 strcat (res, " RSV");
9909 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9910 VMS_ST_FUNC_TYPE (other));
9911 strcat (res, " <unknown>");
9918 switch (VMS_ST_LINKAGE (other))
9920 case VMS_STL_IGNORE:
9921 strcat (res, " IGN");
9923 case VMS_STL_RESERVE:
9924 strcat (res, " RSV");
9927 strcat (res, " STD");
9930 strcat (res, " LNK");
9933 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9934 VMS_ST_LINKAGE (other));
9935 strcat (res, " <unknown>");
9948 get_ppc64_symbol_other (unsigned int other)
9950 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9952 static char buf[32];
9953 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9954 PPC64_LOCAL_ENTRY_OFFSET (other));
9961 get_symbol_other (unsigned int other)
9963 const char * result = NULL;
9964 static char buff [32];
9969 switch (elf_header.e_machine)
9972 result = get_mips_symbol_other (other);
9975 result = get_ia64_symbol_other (other);
9978 result = get_ppc64_symbol_other (other);
9987 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9992 get_symbol_index_type (unsigned int type)
9994 static char buff[32];
9998 case SHN_UNDEF: return "UND";
9999 case SHN_ABS: return "ABS";
10000 case SHN_COMMON: return "COM";
10002 if (type == SHN_IA_64_ANSI_COMMON
10003 && elf_header.e_machine == EM_IA_64
10004 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10006 else if ((elf_header.e_machine == EM_X86_64
10007 || elf_header.e_machine == EM_L1OM
10008 || elf_header.e_machine == EM_K1OM)
10009 && type == SHN_X86_64_LCOMMON)
10010 return "LARGE_COM";
10011 else if ((type == SHN_MIPS_SCOMMON
10012 && elf_header.e_machine == EM_MIPS)
10013 || (type == SHN_TIC6X_SCOMMON
10014 && elf_header.e_machine == EM_TI_C6000))
10016 else if (type == SHN_MIPS_SUNDEFINED
10017 && elf_header.e_machine == EM_MIPS)
10019 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10020 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10021 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10022 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10023 else if (type >= SHN_LORESERVE)
10024 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10025 else if (type >= elf_header.e_shnum)
10026 sprintf (buff, _("bad section index[%3d]"), type);
10028 sprintf (buff, "%3d", type);
10036 get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
10038 unsigned char * e_data;
10041 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10042 attempting to allocate memory when the read is bound to fail. */
10043 if (ent_size * number > current_file_size)
10045 error (_("Invalid number of dynamic entries: %lu\n"),
10046 (unsigned long) number);
10050 e_data = (unsigned char *) cmalloc (number, ent_size);
10051 if (e_data == NULL)
10053 error (_("Out of memory reading %lu dynamic entries\n"),
10054 (unsigned long) number);
10058 if (fread (e_data, ent_size, number, file) != number)
10060 error (_("Unable to read in %lu bytes of dynamic data\n"),
10061 (unsigned long) (number * ent_size));
10066 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
10067 if (i_data == NULL)
10069 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10070 (unsigned long) number);
10076 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10084 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10086 Elf_Internal_Sym * psym;
10089 n = print_vma (si, DEC_5);
10091 fputs (&" "[n], stdout);
10092 printf (" %3lu: ", hn);
10094 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10096 printf (_("<No info available for dynamic symbol number %lu>\n"),
10097 (unsigned long) si);
10101 psym = dynamic_symbols + si;
10102 print_vma (psym->st_value, LONG_HEX);
10104 print_vma (psym->st_size, DEC_5);
10106 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10107 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10108 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10109 /* Check to see if any other bits in the st_other field are set.
10110 Note - displaying this information disrupts the layout of the
10111 table being generated, but for the moment this case is very
10113 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10114 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10115 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10116 if (VALID_DYNAMIC_NAME (psym->st_name))
10117 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10119 printf (_(" <corrupt: %14ld>"), psym->st_name);
10123 static const char *
10124 get_symbol_version_string (FILE *file, int is_dynsym,
10125 const char *strtab,
10126 unsigned long int strtab_size,
10127 unsigned int si, Elf_Internal_Sym *psym,
10128 enum versioned_symbol_info *sym_info,
10129 unsigned short *vna_other)
10131 const char *version_string = NULL;
10134 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10136 unsigned char data[2];
10137 unsigned short vers_data;
10138 unsigned long offset;
10142 offset = offset_from_vma
10143 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10144 sizeof data + si * sizeof (vers_data));
10146 if (get_data (&data, file, offset + si * sizeof (vers_data),
10147 sizeof (data), 1, _("version data")) == NULL)
10150 vers_data = byte_get (data, 2);
10152 is_nobits = (section_headers != NULL
10153 && psym->st_shndx < elf_header.e_shnum
10154 && section_headers[psym->st_shndx].sh_type
10157 check_def = (psym->st_shndx != SHN_UNDEF);
10159 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10161 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10162 && (is_nobits || ! check_def))
10164 Elf_External_Verneed evn;
10165 Elf_Internal_Verneed ivn;
10166 Elf_Internal_Vernaux ivna;
10168 /* We must test both. */
10169 offset = offset_from_vma
10170 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10175 unsigned long vna_off;
10177 if (get_data (&evn, file, offset, sizeof (evn), 1,
10178 _("version need")) == NULL)
10181 ivna.vna_other = 0;
10186 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10187 ivn.vn_next = BYTE_GET (evn.vn_next);
10189 vna_off = offset + ivn.vn_aux;
10193 Elf_External_Vernaux evna;
10195 if (get_data (&evna, file, vna_off,
10197 _("version need aux (3)")) == NULL)
10200 ivna.vna_other = 0;
10205 ivna.vna_other = BYTE_GET (evna.vna_other);
10206 ivna.vna_next = BYTE_GET (evna.vna_next);
10207 ivna.vna_name = BYTE_GET (evna.vna_name);
10210 vna_off += ivna.vna_next;
10212 while (ivna.vna_other != vers_data
10213 && ivna.vna_next != 0);
10215 if (ivna.vna_other == vers_data)
10218 offset += ivn.vn_next;
10220 while (ivn.vn_next != 0);
10222 if (ivna.vna_other == vers_data)
10224 *sym_info = symbol_undefined;
10225 *vna_other = ivna.vna_other;
10226 version_string = (ivna.vna_name < strtab_size
10227 ? strtab + ivna.vna_name
10231 else if (! is_nobits)
10232 error (_("bad dynamic symbol\n"));
10239 if (vers_data != 0x8001
10240 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10242 Elf_Internal_Verdef ivd;
10243 Elf_Internal_Verdaux ivda;
10244 Elf_External_Verdaux evda;
10247 off = offset_from_vma
10249 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10250 sizeof (Elf_External_Verdef));
10254 Elf_External_Verdef evd;
10256 if (get_data (&evd, file, off, sizeof (evd),
10257 1, _("version def")) == NULL)
10265 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10266 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10267 ivd.vd_next = BYTE_GET (evd.vd_next);
10270 off += ivd.vd_next;
10272 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10273 && ivd.vd_next != 0);
10275 off -= ivd.vd_next;
10278 if (get_data (&evda, file, off, sizeof (evda),
10279 1, _("version def aux")) == NULL)
10280 return version_string;
10282 ivda.vda_name = BYTE_GET (evda.vda_name);
10284 if (psym->st_name != ivda.vda_name)
10286 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10287 ? symbol_hidden : symbol_public);
10288 version_string = (ivda.vda_name < strtab_size
10289 ? strtab + ivda.vda_name
10296 return version_string;
10299 /* Dump the symbol table. */
10301 process_symbol_table (FILE * file)
10303 Elf_Internal_Shdr * section;
10304 bfd_size_type nbuckets = 0;
10305 bfd_size_type nchains = 0;
10306 bfd_vma * buckets = NULL;
10307 bfd_vma * chains = NULL;
10308 bfd_vma ngnubuckets = 0;
10309 bfd_vma * gnubuckets = NULL;
10310 bfd_vma * gnuchains = NULL;
10311 bfd_vma gnusymidx = 0;
10312 bfd_size_type ngnuchains = 0;
10314 if (!do_syms && !do_dyn_syms && !do_histogram)
10317 if (dynamic_info[DT_HASH]
10319 || (do_using_dynamic
10321 && dynamic_strings != NULL)))
10323 unsigned char nb[8];
10324 unsigned char nc[8];
10325 unsigned int hash_ent_size = 4;
10327 if ((elf_header.e_machine == EM_ALPHA
10328 || elf_header.e_machine == EM_S390
10329 || elf_header.e_machine == EM_S390_OLD)
10330 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10334 (archive_file_offset
10335 + offset_from_vma (file, dynamic_info[DT_HASH],
10336 sizeof nb + sizeof nc)),
10339 error (_("Unable to seek to start of dynamic information\n"));
10343 if (fread (nb, hash_ent_size, 1, file) != 1)
10345 error (_("Failed to read in number of buckets\n"));
10349 if (fread (nc, hash_ent_size, 1, file) != 1)
10351 error (_("Failed to read in number of chains\n"));
10355 nbuckets = byte_get (nb, hash_ent_size);
10356 nchains = byte_get (nc, hash_ent_size);
10358 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10359 chains = get_dynamic_data (file, nchains, hash_ent_size);
10362 if (buckets == NULL || chains == NULL)
10364 if (do_using_dynamic)
10375 if (dynamic_info_DT_GNU_HASH
10377 || (do_using_dynamic
10379 && dynamic_strings != NULL)))
10381 unsigned char nb[16];
10382 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10383 bfd_vma buckets_vma;
10386 (archive_file_offset
10387 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10391 error (_("Unable to seek to start of dynamic information\n"));
10395 if (fread (nb, 16, 1, file) != 1)
10397 error (_("Failed to read in number of buckets\n"));
10401 ngnubuckets = byte_get (nb, 4);
10402 gnusymidx = byte_get (nb + 4, 4);
10403 bitmaskwords = byte_get (nb + 8, 4);
10404 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10406 buckets_vma += bitmaskwords * 4;
10408 buckets_vma += bitmaskwords * 8;
10411 (archive_file_offset
10412 + offset_from_vma (file, buckets_vma, 4)),
10415 error (_("Unable to seek to start of dynamic information\n"));
10419 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10421 if (gnubuckets == NULL)
10424 for (i = 0; i < ngnubuckets; i++)
10425 if (gnubuckets[i] != 0)
10427 if (gnubuckets[i] < gnusymidx)
10430 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10431 maxchain = gnubuckets[i];
10434 if (maxchain == 0xffffffff)
10437 maxchain -= gnusymidx;
10440 (archive_file_offset
10441 + offset_from_vma (file, buckets_vma
10442 + 4 * (ngnubuckets + maxchain), 4)),
10445 error (_("Unable to seek to start of dynamic information\n"));
10451 if (fread (nb, 4, 1, file) != 1)
10453 error (_("Failed to determine last chain length\n"));
10457 if (maxchain + 1 == 0)
10462 while ((byte_get (nb, 4) & 1) == 0);
10465 (archive_file_offset
10466 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10469 error (_("Unable to seek to start of dynamic information\n"));
10473 gnuchains = get_dynamic_data (file, maxchain, 4);
10474 ngnuchains = maxchain;
10477 if (gnuchains == NULL)
10482 if (do_using_dynamic)
10487 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10489 && do_using_dynamic
10490 && dynamic_strings != NULL
10491 && dynamic_symbols != NULL)
10495 if (dynamic_info[DT_HASH])
10499 printf (_("\nSymbol table for image:\n"));
10501 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10503 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10505 for (hn = 0; hn < nbuckets; hn++)
10510 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10511 print_dynamic_symbol (si, hn);
10515 if (dynamic_info_DT_GNU_HASH)
10517 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10519 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10521 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10523 for (hn = 0; hn < ngnubuckets; ++hn)
10524 if (gnubuckets[hn] != 0)
10526 bfd_vma si = gnubuckets[hn];
10527 bfd_vma off = si - gnusymidx;
10531 print_dynamic_symbol (si, hn);
10534 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10538 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10539 && section_headers != NULL)
10543 for (i = 0, section = section_headers;
10544 i < elf_header.e_shnum;
10548 char * strtab = NULL;
10549 unsigned long int strtab_size = 0;
10550 Elf_Internal_Sym * symtab;
10551 Elf_Internal_Sym * psym;
10552 unsigned long num_syms;
10554 if ((section->sh_type != SHT_SYMTAB
10555 && section->sh_type != SHT_DYNSYM)
10557 && section->sh_type == SHT_SYMTAB))
10560 if (section->sh_entsize == 0)
10562 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10563 printable_section_name (section));
10567 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10568 printable_section_name (section),
10569 (unsigned long) (section->sh_size / section->sh_entsize));
10572 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10574 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10576 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10577 if (symtab == NULL)
10580 if (section->sh_link == elf_header.e_shstrndx)
10582 strtab = string_table;
10583 strtab_size = string_table_length;
10585 else if (section->sh_link < elf_header.e_shnum)
10587 Elf_Internal_Shdr * string_sec;
10589 string_sec = section_headers + section->sh_link;
10591 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10592 1, string_sec->sh_size,
10593 _("string table"));
10594 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10597 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10599 const char *version_string;
10600 enum versioned_symbol_info sym_info;
10601 unsigned short vna_other;
10603 printf ("%6d: ", si);
10604 print_vma (psym->st_value, LONG_HEX);
10606 print_vma (psym->st_size, DEC_5);
10607 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10608 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10609 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10610 /* Check to see if any other bits in the st_other field are set.
10611 Note - displaying this information disrupts the layout of the
10612 table being generated, but for the moment this case is very rare. */
10613 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10614 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10615 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10616 print_symbol (25, psym->st_name < strtab_size
10617 ? strtab + psym->st_name : _("<corrupt>"));
10620 = get_symbol_version_string (file,
10621 section->sh_type == SHT_DYNSYM,
10622 strtab, strtab_size, si,
10623 psym, &sym_info, &vna_other);
10624 if (version_string)
10626 if (sym_info == symbol_undefined)
10627 printf ("@%s (%d)", version_string, vna_other);
10629 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10637 if (strtab != string_table)
10643 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10645 if (do_histogram && buckets != NULL)
10647 unsigned long * lengths;
10648 unsigned long * counts;
10651 unsigned long maxlength = 0;
10652 unsigned long nzero_counts = 0;
10653 unsigned long nsyms = 0;
10655 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10656 (unsigned long) nbuckets);
10658 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10659 if (lengths == NULL)
10661 error (_("Out of memory allocating space for histogram buckets\n"));
10665 printf (_(" Length Number %% of total Coverage\n"));
10666 for (hn = 0; hn < nbuckets; ++hn)
10668 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10671 if (maxlength < ++lengths[hn])
10674 /* PR binutils/17531: A corrupt binary could contain broken
10675 histogram data. Do not go into an infinite loop trying
10677 if (chains[si] == si)
10679 error (_("histogram chain links to itself\n"));
10685 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10686 if (counts == NULL)
10689 error (_("Out of memory allocating space for histogram counts\n"));
10693 for (hn = 0; hn < nbuckets; ++hn)
10694 ++counts[lengths[hn]];
10699 printf (" 0 %-10lu (%5.1f%%)\n",
10700 counts[0], (counts[0] * 100.0) / nbuckets);
10701 for (i = 1; i <= maxlength; ++i)
10703 nzero_counts += counts[i] * i;
10704 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10705 i, counts[i], (counts[i] * 100.0) / nbuckets,
10706 (nzero_counts * 100.0) / nsyms);
10714 if (buckets != NULL)
10720 if (do_histogram && gnubuckets != NULL)
10722 unsigned long * lengths;
10723 unsigned long * counts;
10725 unsigned long maxlength = 0;
10726 unsigned long nzero_counts = 0;
10727 unsigned long nsyms = 0;
10729 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10730 (unsigned long) ngnubuckets);
10732 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10733 if (lengths == NULL)
10735 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10739 printf (_(" Length Number %% of total Coverage\n"));
10741 for (hn = 0; hn < ngnubuckets; ++hn)
10742 if (gnubuckets[hn] != 0)
10744 bfd_vma off, length = 1;
10746 for (off = gnubuckets[hn] - gnusymidx;
10747 /* PR 17531 file: 010-77222-0.004. */
10748 off < ngnuchains && (gnuchains[off] & 1) == 0;
10751 lengths[hn] = length;
10752 if (length > maxlength)
10753 maxlength = length;
10757 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10758 if (counts == NULL)
10761 error (_("Out of memory allocating space for gnu histogram counts\n"));
10765 for (hn = 0; hn < ngnubuckets; ++hn)
10766 ++counts[lengths[hn]];
10768 if (ngnubuckets > 0)
10771 printf (" 0 %-10lu (%5.1f%%)\n",
10772 counts[0], (counts[0] * 100.0) / ngnubuckets);
10773 for (j = 1; j <= maxlength; ++j)
10775 nzero_counts += counts[j] * j;
10776 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10777 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10778 (nzero_counts * 100.0) / nsyms);
10792 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10796 if (dynamic_syminfo == NULL
10798 /* No syminfo, this is ok. */
10801 /* There better should be a dynamic symbol section. */
10802 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10806 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10807 dynamic_syminfo_offset, dynamic_syminfo_nent);
10809 printf (_(" Num: Name BoundTo Flags\n"));
10810 for (i = 0; i < dynamic_syminfo_nent; ++i)
10812 unsigned short int flags = dynamic_syminfo[i].si_flags;
10814 printf ("%4d: ", i);
10815 if (i >= num_dynamic_syms)
10816 printf (_("<corrupt index>"));
10817 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10818 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10820 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10823 switch (dynamic_syminfo[i].si_boundto)
10825 case SYMINFO_BT_SELF:
10826 fputs ("SELF ", stdout);
10828 case SYMINFO_BT_PARENT:
10829 fputs ("PARENT ", stdout);
10832 if (dynamic_syminfo[i].si_boundto > 0
10833 && dynamic_syminfo[i].si_boundto < dynamic_nent
10834 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10836 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10840 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10844 if (flags & SYMINFO_FLG_DIRECT)
10845 printf (" DIRECT");
10846 if (flags & SYMINFO_FLG_PASSTHRU)
10847 printf (" PASSTHRU");
10848 if (flags & SYMINFO_FLG_COPY)
10850 if (flags & SYMINFO_FLG_LAZYLOAD)
10851 printf (" LAZYLOAD");
10859 /* Check to see if the given reloc needs to be handled in a target specific
10860 manner. If so then process the reloc and return TRUE otherwise return
10864 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10865 unsigned char * start,
10866 Elf_Internal_Sym * symtab)
10868 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10870 switch (elf_header.e_machine)
10873 case EM_MSP430_OLD:
10875 static Elf_Internal_Sym * saved_sym = NULL;
10877 switch (reloc_type)
10879 case 10: /* R_MSP430_SYM_DIFF */
10880 if (uses_msp430x_relocs ())
10882 case 21: /* R_MSP430X_SYM_DIFF */
10883 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10886 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10887 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10888 goto handle_sym_diff;
10890 case 5: /* R_MSP430_16_BYTE */
10891 case 9: /* R_MSP430_8 */
10892 if (uses_msp430x_relocs ())
10894 goto handle_sym_diff;
10896 case 2: /* R_MSP430_ABS16 */
10897 case 15: /* R_MSP430X_ABS16 */
10898 if (! uses_msp430x_relocs ())
10900 goto handle_sym_diff;
10903 if (saved_sym != NULL)
10907 value = reloc->r_addend
10908 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10909 - saved_sym->st_value);
10911 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10919 if (saved_sym != NULL)
10920 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10927 case EM_CYGNUS_MN10300:
10929 static Elf_Internal_Sym * saved_sym = NULL;
10931 switch (reloc_type)
10933 case 34: /* R_MN10300_ALIGN */
10935 case 33: /* R_MN10300_SYM_DIFF */
10936 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10938 case 1: /* R_MN10300_32 */
10939 case 2: /* R_MN10300_16 */
10940 if (saved_sym != NULL)
10944 value = reloc->r_addend
10945 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10946 - saved_sym->st_value);
10948 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10955 if (saved_sym != NULL)
10956 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10966 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10967 DWARF debug sections. This is a target specific test. Note - we do not
10968 go through the whole including-target-headers-multiple-times route, (as
10969 we have already done with <elf/h8.h>) because this would become very
10970 messy and even then this function would have to contain target specific
10971 information (the names of the relocs instead of their numeric values).
10972 FIXME: This is not the correct way to solve this problem. The proper way
10973 is to have target specific reloc sizing and typing functions created by
10974 the reloc-macros.h header, in the same way that it already creates the
10975 reloc naming functions. */
10978 is_32bit_abs_reloc (unsigned int reloc_type)
10980 switch (elf_header.e_machine)
10984 return reloc_type == 1; /* R_386_32. */
10986 return reloc_type == 1; /* R_68K_32. */
10988 return reloc_type == 1; /* R_860_32. */
10990 return reloc_type == 2; /* R_960_32. */
10992 return reloc_type == 258; /* R_AARCH64_ABS32 */
10994 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10996 return reloc_type == 1; /* R_ARC_32. */
10998 return reloc_type == 2; /* R_ARM_ABS32 */
11001 return reloc_type == 1;
11002 case EM_ADAPTEVA_EPIPHANY:
11003 return reloc_type == 3;
11005 return reloc_type == 0x12; /* R_byte4_data. */
11007 return reloc_type == 3; /* R_CRIS_32. */
11009 return reloc_type == 3; /* R_CR16_NUM32. */
11011 return reloc_type == 15; /* R_CRX_NUM32. */
11012 case EM_CYGNUS_FRV:
11013 return reloc_type == 1;
11014 case EM_CYGNUS_D10V:
11016 return reloc_type == 6; /* R_D10V_32. */
11017 case EM_CYGNUS_D30V:
11019 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11021 return reloc_type == 3; /* R_DLX_RELOC_32. */
11022 case EM_CYGNUS_FR30:
11024 return reloc_type == 3; /* R_FR30_32. */
11028 return reloc_type == 1; /* R_H8_DIR32. */
11030 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
11033 return reloc_type == 2; /* R_IP2K_32. */
11035 return reloc_type == 2; /* R_IQ2000_32. */
11036 case EM_LATTICEMICO32:
11037 return reloc_type == 3; /* R_LM32_32. */
11040 return reloc_type == 3; /* R_M32C_32. */
11042 return reloc_type == 34; /* R_M32R_32_RELA. */
11044 return reloc_type == 1; /* R_MCORE_ADDR32. */
11045 case EM_CYGNUS_MEP:
11046 return reloc_type == 4; /* R_MEP_32. */
11048 return reloc_type == 2; /* R_METAG_ADDR32. */
11049 case EM_MICROBLAZE:
11050 return reloc_type == 1; /* R_MICROBLAZE_32. */
11052 return reloc_type == 2; /* R_MIPS_32. */
11054 return reloc_type == 4; /* R_MMIX_32. */
11055 case EM_CYGNUS_MN10200:
11057 return reloc_type == 1; /* R_MN10200_32. */
11058 case EM_CYGNUS_MN10300:
11060 return reloc_type == 1; /* R_MN10300_32. */
11062 return reloc_type == 1; /* R_MOXIE_32. */
11063 case EM_MSP430_OLD:
11065 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11067 return reloc_type == 2; /* R_MT_32. */
11069 return reloc_type == 20; /* R_NDS32_RELA. */
11070 case EM_ALTERA_NIOS2:
11071 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
11073 return reloc_type == 1; /* R_NIOS_32. */
11075 return reloc_type == 1; /* R_OR1K_32. */
11077 return (reloc_type == 1 /* R_PARISC_DIR32. */
11078 || reloc_type == 41); /* R_PARISC_SECREL32. */
11081 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11083 return reloc_type == 1; /* R_PPC64_ADDR32. */
11085 return reloc_type == 1; /* R_PPC_ADDR32. */
11087 return reloc_type == 1; /* R_RL78_DIR32. */
11089 return reloc_type == 1; /* R_RX_DIR32. */
11091 return reloc_type == 1; /* R_I370_ADDR31. */
11094 return reloc_type == 4; /* R_S390_32. */
11096 return reloc_type == 8; /* R_SCORE_ABS32. */
11098 return reloc_type == 1; /* R_SH_DIR32. */
11099 case EM_SPARC32PLUS:
11102 return reloc_type == 3 /* R_SPARC_32. */
11103 || reloc_type == 23; /* R_SPARC_UA32. */
11105 return reloc_type == 6; /* R_SPU_ADDR32 */
11107 return reloc_type == 1; /* R_C6000_ABS32. */
11109 return reloc_type == 2; /* R_TILEGX_32. */
11111 return reloc_type == 1; /* R_TILEPRO_32. */
11112 case EM_CYGNUS_V850:
11114 return reloc_type == 6; /* R_V850_ABS32. */
11116 return reloc_type == 0x33; /* R_V810_WORD. */
11118 return reloc_type == 1; /* R_VAX_32. */
11120 return reloc_type == 3; /* R_VISIUM_32. */
11124 return reloc_type == 10; /* R_X86_64_32. */
11127 return reloc_type == 3; /* R_XC16C_ABS_32. */
11129 return reloc_type == 4; /* R_XGATE_32. */
11131 return reloc_type == 1; /* R_XSTROMY16_32. */
11132 case EM_XTENSA_OLD:
11134 return reloc_type == 1; /* R_XTENSA_32. */
11137 static unsigned int prev_warn = 0;
11139 /* Avoid repeating the same warning multiple times. */
11140 if (prev_warn != elf_header.e_machine)
11141 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11142 elf_header.e_machine);
11143 prev_warn = elf_header.e_machine;
11149 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11150 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11153 is_32bit_pcrel_reloc (unsigned int reloc_type)
11155 switch (elf_header.e_machine)
11159 return reloc_type == 2; /* R_386_PC32. */
11161 return reloc_type == 4; /* R_68K_PC32. */
11163 return reloc_type == 261; /* R_AARCH64_PREL32 */
11164 case EM_ADAPTEVA_EPIPHANY:
11165 return reloc_type == 6;
11167 return reloc_type == 10; /* R_ALPHA_SREL32. */
11169 return reloc_type == 3; /* R_ARM_REL32 */
11170 case EM_MICROBLAZE:
11171 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11173 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11175 return reloc_type == 9; /* R_PARISC_PCREL32. */
11177 return reloc_type == 26; /* R_PPC_REL32. */
11179 return reloc_type == 26; /* R_PPC64_REL32. */
11182 return reloc_type == 5; /* R_390_PC32. */
11184 return reloc_type == 2; /* R_SH_REL32. */
11185 case EM_SPARC32PLUS:
11188 return reloc_type == 6; /* R_SPARC_DISP32. */
11190 return reloc_type == 13; /* R_SPU_REL32. */
11192 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11194 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11196 return reloc_type == 6; /* R_VISIUM_32_PCREL */
11200 return reloc_type == 2; /* R_X86_64_PC32. */
11201 case EM_XTENSA_OLD:
11203 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11205 /* Do not abort or issue an error message here. Not all targets use
11206 pc-relative 32-bit relocs in their DWARF debug information and we
11207 have already tested for target coverage in is_32bit_abs_reloc. A
11208 more helpful warning message will be generated by apply_relocations
11209 anyway, so just return. */
11214 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11215 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11218 is_64bit_abs_reloc (unsigned int reloc_type)
11220 switch (elf_header.e_machine)
11223 return reloc_type == 257; /* R_AARCH64_ABS64. */
11225 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11227 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11229 return reloc_type == 80; /* R_PARISC_DIR64. */
11231 return reloc_type == 38; /* R_PPC64_ADDR64. */
11232 case EM_SPARC32PLUS:
11235 return reloc_type == 54; /* R_SPARC_UA64. */
11239 return reloc_type == 1; /* R_X86_64_64. */
11242 return reloc_type == 22; /* R_S390_64. */
11244 return reloc_type == 1; /* R_TILEGX_64. */
11246 return reloc_type == 18; /* R_MIPS_64. */
11252 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11253 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11256 is_64bit_pcrel_reloc (unsigned int reloc_type)
11258 switch (elf_header.e_machine)
11261 return reloc_type == 260; /* R_AARCH64_PREL64. */
11263 return reloc_type == 11; /* R_ALPHA_SREL64. */
11265 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11267 return reloc_type == 72; /* R_PARISC_PCREL64. */
11269 return reloc_type == 44; /* R_PPC64_REL64. */
11270 case EM_SPARC32PLUS:
11273 return reloc_type == 46; /* R_SPARC_DISP64. */
11277 return reloc_type == 24; /* R_X86_64_PC64. */
11280 return reloc_type == 23; /* R_S390_PC64. */
11282 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11288 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11289 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11292 is_24bit_abs_reloc (unsigned int reloc_type)
11294 switch (elf_header.e_machine)
11296 case EM_CYGNUS_MN10200:
11298 return reloc_type == 4; /* R_MN10200_24. */
11304 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11305 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11308 is_16bit_abs_reloc (unsigned int reloc_type)
11310 switch (elf_header.e_machine)
11314 return reloc_type == 4; /* R_AVR_16. */
11315 case EM_ADAPTEVA_EPIPHANY:
11316 return reloc_type == 5;
11317 case EM_CYGNUS_D10V:
11319 return reloc_type == 3; /* R_D10V_16. */
11323 return reloc_type == R_H8_DIR16;
11326 return reloc_type == 1; /* R_IP2K_16. */
11329 return reloc_type == 1; /* R_M32C_16 */
11331 if (uses_msp430x_relocs ())
11332 return reloc_type == 2; /* R_MSP430_ABS16. */
11333 case EM_MSP430_OLD:
11334 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11336 return reloc_type == 19; /* R_NDS32_RELA. */
11337 case EM_ALTERA_NIOS2:
11338 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11340 return reloc_type == 9; /* R_NIOS_16. */
11342 return reloc_type == 2; /* R_OR1K_16. */
11344 return reloc_type == 2; /* R_C6000_ABS16. */
11347 return reloc_type == 2; /* R_XC16C_ABS_16. */
11348 case EM_CYGNUS_MN10200:
11350 return reloc_type == 2; /* R_MN10200_16. */
11351 case EM_CYGNUS_MN10300:
11353 return reloc_type == 2; /* R_MN10300_16. */
11355 return reloc_type == 2; /* R_VISIUM_16. */
11357 return reloc_type == 3; /* R_XGATE_16. */
11363 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11364 relocation entries (possibly formerly used for SHT_GROUP sections). */
11367 is_none_reloc (unsigned int reloc_type)
11369 switch (elf_header.e_machine)
11371 case EM_68K: /* R_68K_NONE. */
11372 case EM_386: /* R_386_NONE. */
11373 case EM_SPARC32PLUS:
11375 case EM_SPARC: /* R_SPARC_NONE. */
11376 case EM_MIPS: /* R_MIPS_NONE. */
11377 case EM_PARISC: /* R_PARISC_NONE. */
11378 case EM_ALPHA: /* R_ALPHA_NONE. */
11379 case EM_ADAPTEVA_EPIPHANY:
11380 case EM_PPC: /* R_PPC_NONE. */
11381 case EM_PPC64: /* R_PPC64_NONE. */
11382 case EM_ARM: /* R_ARM_NONE. */
11383 case EM_IA_64: /* R_IA64_NONE. */
11384 case EM_SH: /* R_SH_NONE. */
11386 case EM_S390: /* R_390_NONE. */
11387 case EM_CRIS: /* R_CRIS_NONE. */
11388 case EM_X86_64: /* R_X86_64_NONE. */
11389 case EM_L1OM: /* R_X86_64_NONE. */
11390 case EM_K1OM: /* R_X86_64_NONE. */
11391 case EM_MN10300: /* R_MN10300_NONE. */
11392 case EM_MOXIE: /* R_MOXIE_NONE. */
11393 case EM_M32R: /* R_M32R_NONE. */
11394 case EM_TI_C6000:/* R_C6000_NONE. */
11395 case EM_TILEGX: /* R_TILEGX_NONE. */
11396 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11398 case EM_C166: /* R_XC16X_NONE. */
11399 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11400 case EM_NIOS32: /* R_NIOS_NONE. */
11401 case EM_OR1K: /* R_OR1K_NONE. */
11402 return reloc_type == 0;
11404 return reloc_type == 0 || reloc_type == 256;
11406 return (reloc_type == 0 /* R_XTENSA_NONE. */
11407 || reloc_type == 204 /* R_NDS32_DIFF8. */
11408 || reloc_type == 205 /* R_NDS32_DIFF16. */
11409 || reloc_type == 206 /* R_NDS32_DIFF32. */
11410 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11411 case EM_XTENSA_OLD:
11413 return (reloc_type == 0 /* R_XTENSA_NONE. */
11414 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11415 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11416 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11418 return reloc_type == 3; /* R_METAG_NONE. */
11423 /* Apply relocations to a section.
11424 Note: So far support has been added only for those relocations
11425 which can be found in debug sections.
11426 FIXME: Add support for more relocations ? */
11429 apply_relocations (void * file,
11430 Elf_Internal_Shdr * section,
11431 unsigned char * start)
11433 Elf_Internal_Shdr * relsec;
11434 unsigned char * end = start + section->sh_size;
11436 if (elf_header.e_type != ET_REL)
11439 /* Find the reloc section associated with the section. */
11440 for (relsec = section_headers;
11441 relsec < section_headers + elf_header.e_shnum;
11444 bfd_boolean is_rela;
11445 unsigned long num_relocs;
11446 Elf_Internal_Rela * relocs;
11447 Elf_Internal_Rela * rp;
11448 Elf_Internal_Shdr * symsec;
11449 Elf_Internal_Sym * symtab;
11450 unsigned long num_syms;
11451 Elf_Internal_Sym * sym;
11453 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11454 || relsec->sh_info >= elf_header.e_shnum
11455 || section_headers + relsec->sh_info != section
11456 || relsec->sh_size == 0
11457 || relsec->sh_link >= elf_header.e_shnum)
11460 is_rela = relsec->sh_type == SHT_RELA;
11464 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11465 relsec->sh_size, & relocs, & num_relocs))
11470 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11471 relsec->sh_size, & relocs, & num_relocs))
11475 /* SH uses RELA but uses in place value instead of the addend field. */
11476 if (elf_header.e_machine == EM_SH)
11479 symsec = section_headers + relsec->sh_link;
11480 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11482 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11485 unsigned int reloc_type;
11486 unsigned int reloc_size;
11487 unsigned char * rloc;
11488 unsigned long sym_index;
11490 reloc_type = get_reloc_type (rp->r_info);
11492 if (target_specific_reloc_handling (rp, start, symtab))
11494 else if (is_none_reloc (reloc_type))
11496 else if (is_32bit_abs_reloc (reloc_type)
11497 || is_32bit_pcrel_reloc (reloc_type))
11499 else if (is_64bit_abs_reloc (reloc_type)
11500 || is_64bit_pcrel_reloc (reloc_type))
11502 else if (is_24bit_abs_reloc (reloc_type))
11504 else if (is_16bit_abs_reloc (reloc_type))
11508 static unsigned int prev_reloc = 0;
11509 if (reloc_type != prev_reloc)
11510 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11511 reloc_type, printable_section_name (section));
11512 prev_reloc = reloc_type;
11516 rloc = start + rp->r_offset;
11517 if ((rloc + reloc_size) > end || (rloc < start))
11519 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11520 (unsigned long) rp->r_offset,
11521 printable_section_name (section));
11525 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11526 if (sym_index >= num_syms)
11528 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11529 sym_index, printable_section_name (section));
11532 sym = symtab + sym_index;
11534 /* If the reloc has a symbol associated with it,
11535 make sure that it is of an appropriate type.
11537 Relocations against symbols without type can happen.
11538 Gcc -feliminate-dwarf2-dups may generate symbols
11539 without type for debug info.
11541 Icc generates relocations against function symbols
11542 instead of local labels.
11544 Relocations against object symbols can happen, eg when
11545 referencing a global array. For an example of this see
11546 the _clz.o binary in libgcc.a. */
11548 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11550 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11551 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11552 (long int)(rp - relocs),
11553 printable_section_name (relsec));
11559 addend += rp->r_addend;
11560 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11561 partial_inplace. */
11563 || (elf_header.e_machine == EM_XTENSA
11564 && reloc_type == 1)
11565 || ((elf_header.e_machine == EM_PJ
11566 || elf_header.e_machine == EM_PJ_OLD)
11567 && reloc_type == 1)
11568 || ((elf_header.e_machine == EM_D30V
11569 || elf_header.e_machine == EM_CYGNUS_D30V)
11570 && reloc_type == 12))
11571 addend += byte_get (rloc, reloc_size);
11573 if (is_32bit_pcrel_reloc (reloc_type)
11574 || is_64bit_pcrel_reloc (reloc_type))
11576 /* On HPPA, all pc-relative relocations are biased by 8. */
11577 if (elf_header.e_machine == EM_PARISC)
11579 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11583 byte_put (rloc, addend + sym->st_value, reloc_size);
11592 #ifdef SUPPORT_DISASSEMBLY
11594 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11596 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11598 /* FIXME: XXX -- to be done --- XXX */
11604 /* Reads in the contents of SECTION from FILE, returning a pointer
11605 to a malloc'ed buffer or NULL if something went wrong. */
11608 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11610 bfd_size_type num_bytes;
11612 num_bytes = section->sh_size;
11614 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11616 printf (_("\nSection '%s' has no data to dump.\n"),
11617 printable_section_name (section));
11621 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11622 _("section contents"));
11627 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11629 Elf_Internal_Shdr * relsec;
11630 bfd_size_type num_bytes;
11634 bfd_boolean some_strings_shown;
11636 start = get_section_contents (section, file);
11640 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11642 /* If the section being dumped has relocations against it the user might
11643 be expecting these relocations to have been applied. Check for this
11644 case and issue a warning message in order to avoid confusion.
11645 FIXME: Maybe we ought to have an option that dumps a section with
11646 relocs applied ? */
11647 for (relsec = section_headers;
11648 relsec < section_headers + elf_header.e_shnum;
11651 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11652 || relsec->sh_info >= elf_header.e_shnum
11653 || section_headers + relsec->sh_info != section
11654 || relsec->sh_size == 0
11655 || relsec->sh_link >= elf_header.e_shnum)
11658 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11662 num_bytes = section->sh_size;
11664 end = start + num_bytes;
11665 some_strings_shown = FALSE;
11669 while (!ISPRINT (* data))
11670 if (++ data >= end)
11675 size_t maxlen = end - data;
11678 /* PR 11128: Use two separate invocations in order to work
11679 around bugs in the Solaris 8 implementation of printf. */
11680 printf (" [%6tx] ", data - start);
11682 printf (" [%6Ix] ", (size_t) (data - start));
11686 print_symbol ((int) maxlen, data);
11688 data += strnlen (data, maxlen);
11692 printf (_("<corrupt>\n"));
11695 some_strings_shown = TRUE;
11699 if (! some_strings_shown)
11700 printf (_(" No strings found in this section."));
11708 dump_section_as_bytes (Elf_Internal_Shdr * section,
11710 bfd_boolean relocate)
11712 Elf_Internal_Shdr * relsec;
11713 bfd_size_type bytes;
11715 unsigned char * data;
11716 unsigned char * start;
11718 start = (unsigned char *) get_section_contents (section, file);
11722 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11726 apply_relocations (file, section, start);
11730 /* If the section being dumped has relocations against it the user might
11731 be expecting these relocations to have been applied. Check for this
11732 case and issue a warning message in order to avoid confusion.
11733 FIXME: Maybe we ought to have an option that dumps a section with
11734 relocs applied ? */
11735 for (relsec = section_headers;
11736 relsec < section_headers + elf_header.e_shnum;
11739 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11740 || relsec->sh_info >= elf_header.e_shnum
11741 || section_headers + relsec->sh_info != section
11742 || relsec->sh_size == 0
11743 || relsec->sh_link >= elf_header.e_shnum)
11746 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11751 addr = section->sh_addr;
11752 bytes = section->sh_size;
11761 lbytes = (bytes > 16 ? 16 : bytes);
11763 printf (" 0x%8.8lx ", (unsigned long) addr);
11765 for (j = 0; j < 16; j++)
11768 printf ("%2.2x", data[j]);
11776 for (j = 0; j < lbytes; j++)
11779 if (k >= ' ' && k < 0x7f)
11797 /* Uncompresses a section that was compressed using zlib, in place. */
11800 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11801 dwarf_size_type *size ATTRIBUTE_UNUSED)
11803 #ifndef HAVE_ZLIB_H
11806 dwarf_size_type compressed_size = *size;
11807 unsigned char * compressed_buffer = *buffer;
11808 dwarf_size_type uncompressed_size;
11809 unsigned char * uncompressed_buffer;
11812 dwarf_size_type header_size = 12;
11814 /* Read the zlib header. In this case, it should be "ZLIB" followed
11815 by the uncompressed section size, 8 bytes in big-endian order. */
11816 if (compressed_size < header_size
11817 || ! streq ((char *) compressed_buffer, "ZLIB"))
11820 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11821 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11822 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11823 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11824 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11825 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11826 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11827 uncompressed_size += compressed_buffer[11];
11829 /* It is possible the section consists of several compressed
11830 buffers concatenated together, so we uncompress in a loop. */
11831 strm.zalloc = NULL;
11833 strm.opaque = NULL;
11834 strm.avail_in = compressed_size - header_size;
11835 strm.next_in = (Bytef *) compressed_buffer + header_size;
11836 strm.avail_out = uncompressed_size;
11837 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11839 rc = inflateInit (& strm);
11840 while (strm.avail_in > 0)
11844 strm.next_out = ((Bytef *) uncompressed_buffer
11845 + (uncompressed_size - strm.avail_out));
11846 rc = inflate (&strm, Z_FINISH);
11847 if (rc != Z_STREAM_END)
11849 rc = inflateReset (& strm);
11851 rc = inflateEnd (& strm);
11853 || strm.avail_out != 0)
11856 free (compressed_buffer);
11857 *buffer = uncompressed_buffer;
11858 *size = uncompressed_size;
11862 free (uncompressed_buffer);
11863 /* Indicate decompression failure. */
11866 #endif /* HAVE_ZLIB_H */
11870 load_specific_debug_section (enum dwarf_section_display_enum debug,
11871 Elf_Internal_Shdr * sec, void * file)
11873 struct dwarf_section * section = &debug_displays [debug].section;
11876 /* If it is already loaded, do nothing. */
11877 if (section->start != NULL)
11880 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11881 section->address = sec->sh_addr;
11882 section->user_data = NULL;
11883 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11885 sec->sh_size, buf);
11886 if (section->start == NULL)
11890 section->size = sec->sh_size;
11891 if (uncompress_section_contents (§ion->start, §ion->size))
11892 sec->sh_size = section->size;
11895 if (section->start == NULL)
11898 if (debug_displays [debug].relocate)
11899 apply_relocations ((FILE *) file, sec, section->start);
11904 /* If this is not NULL, load_debug_section will only look for sections
11905 within the list of sections given here. */
11906 unsigned int *section_subset = NULL;
11909 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11911 struct dwarf_section * section = &debug_displays [debug].section;
11912 Elf_Internal_Shdr * sec;
11914 /* Locate the debug section. */
11915 sec = find_section_in_set (section->uncompressed_name, section_subset);
11917 section->name = section->uncompressed_name;
11920 sec = find_section_in_set (section->compressed_name, section_subset);
11922 section->name = section->compressed_name;
11927 /* If we're loading from a subset of sections, and we've loaded
11928 a section matching this name before, it's likely that it's a
11930 if (section_subset != NULL)
11931 free_debug_section (debug);
11933 return load_specific_debug_section (debug, sec, (FILE *) file);
11937 free_debug_section (enum dwarf_section_display_enum debug)
11939 struct dwarf_section * section = &debug_displays [debug].section;
11941 if (section->start == NULL)
11944 free ((char *) section->start);
11945 section->start = NULL;
11946 section->address = 0;
11951 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11953 char * name = SECTION_NAME (section);
11954 const char * print_name = printable_section_name (section);
11955 bfd_size_type length;
11959 length = section->sh_size;
11962 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
11965 if (section->sh_type == SHT_NOBITS)
11967 /* There is no point in dumping the contents of a debugging section
11968 which has the NOBITS type - the bits in the file will be random.
11969 This can happen when a file containing a .eh_frame section is
11970 stripped with the --only-keep-debug command line option. */
11971 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11976 if (const_strneq (name, ".gnu.linkonce.wi."))
11977 name = ".debug_info";
11979 /* See if we know how to display the contents of this section. */
11980 for (i = 0; i < max; i++)
11981 if (streq (debug_displays[i].section.uncompressed_name, name)
11982 || (i == line && const_strneq (name, ".debug_line."))
11983 || streq (debug_displays[i].section.compressed_name, name))
11985 struct dwarf_section * sec = &debug_displays [i].section;
11986 int secondary = (section != find_section (name));
11989 free_debug_section ((enum dwarf_section_display_enum) i);
11991 if (i == line && const_strneq (name, ".debug_line."))
11993 else if (streq (sec->uncompressed_name, name))
11994 sec->name = sec->uncompressed_name;
11996 sec->name = sec->compressed_name;
11997 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12000 /* If this debug section is part of a CU/TU set in a .dwp file,
12001 restrict load_debug_section to the sections in that set. */
12002 section_subset = find_cu_tu_set (file, shndx);
12004 result &= debug_displays[i].display (sec, file);
12006 section_subset = NULL;
12008 if (secondary || (i != info && i != abbrev))
12009 free_debug_section ((enum dwarf_section_display_enum) i);
12017 printf (_("Unrecognized debug section: %s\n"), print_name);
12024 /* Set DUMP_SECTS for all sections where dumps were requested
12025 based on section name. */
12028 initialise_dumps_byname (void)
12030 struct dump_list_entry * cur;
12032 for (cur = dump_sects_byname; cur; cur = cur->next)
12037 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12038 if (streq (SECTION_NAME (section_headers + i), cur->name))
12040 request_dump_bynumber (i, cur->type);
12045 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12051 process_section_contents (FILE * file)
12053 Elf_Internal_Shdr * section;
12059 initialise_dumps_byname ();
12061 for (i = 0, section = section_headers;
12062 i < elf_header.e_shnum && i < num_dump_sects;
12065 #ifdef SUPPORT_DISASSEMBLY
12066 if (dump_sects[i] & DISASS_DUMP)
12067 disassemble_section (section, file);
12069 if (dump_sects[i] & HEX_DUMP)
12070 dump_section_as_bytes (section, file, FALSE);
12072 if (dump_sects[i] & RELOC_DUMP)
12073 dump_section_as_bytes (section, file, TRUE);
12075 if (dump_sects[i] & STRING_DUMP)
12076 dump_section_as_strings (section, file);
12078 if (dump_sects[i] & DEBUG_DUMP)
12079 display_debug_section (i, section, file);
12082 /* Check to see if the user requested a
12083 dump of a section that does not exist. */
12084 while (i++ < num_dump_sects)
12086 warn (_("Section %d was not dumped because it does not exist!\n"), i);
12090 process_mips_fpe_exception (int mask)
12095 if (mask & OEX_FPU_INEX)
12096 fputs ("INEX", stdout), first = 0;
12097 if (mask & OEX_FPU_UFLO)
12098 printf ("%sUFLO", first ? "" : "|"), first = 0;
12099 if (mask & OEX_FPU_OFLO)
12100 printf ("%sOFLO", first ? "" : "|"), first = 0;
12101 if (mask & OEX_FPU_DIV0)
12102 printf ("%sDIV0", first ? "" : "|"), first = 0;
12103 if (mask & OEX_FPU_INVAL)
12104 printf ("%sINVAL", first ? "" : "|");
12107 fputs ("0", stdout);
12110 /* Display's the value of TAG at location P. If TAG is
12111 greater than 0 it is assumed to be an unknown tag, and
12112 a message is printed to this effect. Otherwise it is
12113 assumed that a message has already been printed.
12115 If the bottom bit of TAG is set it assumed to have a
12116 string value, otherwise it is assumed to have an integer
12119 Returns an updated P pointing to the first unread byte
12120 beyond the end of TAG's value.
12122 Reads at or beyond END will not be made. */
12124 static unsigned char *
12125 display_tag_value (int tag,
12127 const unsigned char * const end)
12132 printf (" Tag_unknown_%d: ", tag);
12136 warn (_("<corrupt tag>\n"));
12140 /* PR 17531 file: 027-19978-0.004. */
12141 size_t maxlen = (end - p) - 1;
12146 print_symbol ((int) maxlen, (const char *) p);
12147 p += strnlen ((char *) p, maxlen) + 1;
12151 printf (_("<corrupt string tag>"));
12152 p = (unsigned char *) end;
12160 val = read_uleb128 (p, &len, end);
12162 printf ("%ld (0x%lx)\n", val, val);
12169 /* ARM EABI attributes section. */
12174 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12176 const char ** table;
12177 } arm_attr_public_tag;
12179 static const char * arm_attr_tag_CPU_arch[] =
12180 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12181 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12182 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12183 static const char * arm_attr_tag_THUMB_ISA_use[] =
12184 {"No", "Thumb-1", "Thumb-2"};
12185 static const char * arm_attr_tag_FP_arch[] =
12186 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12187 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12188 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12189 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12190 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12191 static const char * arm_attr_tag_PCS_config[] =
12192 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12193 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12194 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12195 {"V6", "SB", "TLS", "Unused"};
12196 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12197 {"Absolute", "PC-relative", "SB-relative", "None"};
12198 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12199 {"Absolute", "PC-relative", "None"};
12200 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12201 {"None", "direct", "GOT-indirect"};
12202 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12203 {"None", "??? 1", "2", "??? 3", "4"};
12204 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12205 static const char * arm_attr_tag_ABI_FP_denormal[] =
12206 {"Unused", "Needed", "Sign only"};
12207 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12208 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12209 static const char * arm_attr_tag_ABI_FP_number_model[] =
12210 {"Unused", "Finite", "RTABI", "IEEE 754"};
12211 static const char * arm_attr_tag_ABI_enum_size[] =
12212 {"Unused", "small", "int", "forced to int"};
12213 static const char * arm_attr_tag_ABI_HardFP_use[] =
12214 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12215 static const char * arm_attr_tag_ABI_VFP_args[] =
12216 {"AAPCS", "VFP registers", "custom", "compatible"};
12217 static const char * arm_attr_tag_ABI_WMMX_args[] =
12218 {"AAPCS", "WMMX registers", "custom"};
12219 static const char * arm_attr_tag_ABI_optimization_goals[] =
12220 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12221 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12222 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12223 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12224 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12225 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12226 static const char * arm_attr_tag_FP_HP_extension[] =
12227 {"Not Allowed", "Allowed"};
12228 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12229 {"None", "IEEE 754", "Alternative Format"};
12230 static const char * arm_attr_tag_MPextension_use[] =
12231 {"Not Allowed", "Allowed"};
12232 static const char * arm_attr_tag_DIV_use[] =
12233 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12234 "Allowed in v7-A with integer division extension"};
12235 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12236 static const char * arm_attr_tag_Virtualization_use[] =
12237 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12238 "TrustZone and Virtualization Extensions"};
12239 static const char * arm_attr_tag_MPextension_use_legacy[] =
12240 {"Not Allowed", "Allowed"};
12242 #define LOOKUP(id, name) \
12243 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12244 static arm_attr_public_tag arm_attr_public_tags[] =
12246 {4, "CPU_raw_name", 1, NULL},
12247 {5, "CPU_name", 1, NULL},
12248 LOOKUP(6, CPU_arch),
12249 {7, "CPU_arch_profile", 0, NULL},
12250 LOOKUP(8, ARM_ISA_use),
12251 LOOKUP(9, THUMB_ISA_use),
12252 LOOKUP(10, FP_arch),
12253 LOOKUP(11, WMMX_arch),
12254 LOOKUP(12, Advanced_SIMD_arch),
12255 LOOKUP(13, PCS_config),
12256 LOOKUP(14, ABI_PCS_R9_use),
12257 LOOKUP(15, ABI_PCS_RW_data),
12258 LOOKUP(16, ABI_PCS_RO_data),
12259 LOOKUP(17, ABI_PCS_GOT_use),
12260 LOOKUP(18, ABI_PCS_wchar_t),
12261 LOOKUP(19, ABI_FP_rounding),
12262 LOOKUP(20, ABI_FP_denormal),
12263 LOOKUP(21, ABI_FP_exceptions),
12264 LOOKUP(22, ABI_FP_user_exceptions),
12265 LOOKUP(23, ABI_FP_number_model),
12266 {24, "ABI_align_needed", 0, NULL},
12267 {25, "ABI_align_preserved", 0, NULL},
12268 LOOKUP(26, ABI_enum_size),
12269 LOOKUP(27, ABI_HardFP_use),
12270 LOOKUP(28, ABI_VFP_args),
12271 LOOKUP(29, ABI_WMMX_args),
12272 LOOKUP(30, ABI_optimization_goals),
12273 LOOKUP(31, ABI_FP_optimization_goals),
12274 {32, "compatibility", 0, NULL},
12275 LOOKUP(34, CPU_unaligned_access),
12276 LOOKUP(36, FP_HP_extension),
12277 LOOKUP(38, ABI_FP_16bit_format),
12278 LOOKUP(42, MPextension_use),
12279 LOOKUP(44, DIV_use),
12280 {64, "nodefaults", 0, NULL},
12281 {65, "also_compatible_with", 0, NULL},
12282 LOOKUP(66, T2EE_use),
12283 {67, "conformance", 1, NULL},
12284 LOOKUP(68, Virtualization_use),
12285 LOOKUP(70, MPextension_use_legacy)
12289 static unsigned char *
12290 display_arm_attribute (unsigned char * p,
12291 const unsigned char * const end)
12296 arm_attr_public_tag * attr;
12300 tag = read_uleb128 (p, &len, end);
12303 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12305 if (arm_attr_public_tags[i].tag == tag)
12307 attr = &arm_attr_public_tags[i];
12314 printf (" Tag_%s: ", attr->name);
12315 switch (attr->type)
12320 case 7: /* Tag_CPU_arch_profile. */
12321 val = read_uleb128 (p, &len, end);
12325 case 0: printf (_("None\n")); break;
12326 case 'A': printf (_("Application\n")); break;
12327 case 'R': printf (_("Realtime\n")); break;
12328 case 'M': printf (_("Microcontroller\n")); break;
12329 case 'S': printf (_("Application or Realtime\n")); break;
12330 default: printf ("??? (%d)\n", val); break;
12334 case 24: /* Tag_align_needed. */
12335 val = read_uleb128 (p, &len, end);
12339 case 0: printf (_("None\n")); break;
12340 case 1: printf (_("8-byte\n")); break;
12341 case 2: printf (_("4-byte\n")); break;
12342 case 3: printf ("??? 3\n"); break;
12345 printf (_("8-byte and up to %d-byte extended\n"),
12348 printf ("??? (%d)\n", val);
12353 case 25: /* Tag_align_preserved. */
12354 val = read_uleb128 (p, &len, end);
12358 case 0: printf (_("None\n")); break;
12359 case 1: printf (_("8-byte, except leaf SP\n")); break;
12360 case 2: printf (_("8-byte\n")); break;
12361 case 3: printf ("??? 3\n"); break;
12364 printf (_("8-byte and up to %d-byte extended\n"),
12367 printf ("??? (%d)\n", val);
12372 case 32: /* Tag_compatibility. */
12374 val = read_uleb128 (p, &len, end);
12376 printf (_("flag = %d, vendor = "), val);
12379 size_t maxlen = (end - p) - 1;
12381 print_symbol ((int) maxlen, (const char *) p);
12382 p += strnlen ((char *) p, maxlen) + 1;
12386 printf (_("<corrupt>"));
12387 p = (unsigned char *) end;
12393 case 64: /* Tag_nodefaults. */
12394 /* PR 17531: file: 001-505008-0.01. */
12397 printf (_("True\n"));
12400 case 65: /* Tag_also_compatible_with. */
12401 val = read_uleb128 (p, &len, end);
12403 if (val == 6 /* Tag_CPU_arch. */)
12405 val = read_uleb128 (p, &len, end);
12407 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12408 printf ("??? (%d)\n", val);
12410 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12414 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12419 printf (_("<unknown: %d>\n"), tag);
12425 return display_tag_value (-1, p, end);
12427 return display_tag_value (0, p, end);
12430 assert (attr->type & 0x80);
12431 val = read_uleb128 (p, &len, end);
12433 type = attr->type & 0x7f;
12435 printf ("??? (%d)\n", val);
12437 printf ("%s\n", attr->table[val]);
12442 return display_tag_value (tag, p, end);
12445 static unsigned char *
12446 display_gnu_attribute (unsigned char * p,
12447 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12448 const unsigned char * const end)
12454 tag = read_uleb128 (p, &len, end);
12457 /* Tag_compatibility is the only generic GNU attribute defined at
12461 val = read_uleb128 (p, &len, end);
12464 printf (_("flag = %d, vendor = "), val);
12467 printf (_("<corrupt>\n"));
12468 warn (_("corrupt vendor attribute\n"));
12474 size_t maxlen = (end - p) - 1;
12476 print_symbol ((int) maxlen, (const char *) p);
12477 p += strnlen ((char *) p, maxlen) + 1;
12481 printf (_("<corrupt>"));
12482 p = (unsigned char *) end;
12489 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12490 return display_proc_gnu_attribute (p, tag, end);
12492 return display_tag_value (tag, p, end);
12495 static unsigned char *
12496 display_power_gnu_attribute (unsigned char * p,
12498 const unsigned char * const end)
12503 if (tag == Tag_GNU_Power_ABI_FP)
12505 val = read_uleb128 (p, &len, end);
12507 printf (" Tag_GNU_Power_ABI_FP: ");
12512 printf (_("Hard or soft float\n"));
12515 printf (_("Hard float\n"));
12518 printf (_("Soft float\n"));
12521 printf (_("Single-precision hard float\n"));
12524 printf ("??? (%d)\n", val);
12530 if (tag == Tag_GNU_Power_ABI_Vector)
12532 val = read_uleb128 (p, &len, end);
12534 printf (" Tag_GNU_Power_ABI_Vector: ");
12538 printf (_("Any\n"));
12541 printf (_("Generic\n"));
12544 printf ("AltiVec\n");
12550 printf ("??? (%d)\n", val);
12556 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12560 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12564 val = read_uleb128 (p, &len, end);
12566 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12570 printf (_("Any\n"));
12573 printf ("r3/r4\n");
12576 printf (_("Memory\n"));
12579 printf ("??? (%d)\n", val);
12585 return display_tag_value (tag & 1, p, end);
12589 display_sparc_hwcaps (int mask)
12595 if (mask & ELF_SPARC_HWCAP_MUL32)
12596 fputs ("mul32", stdout), first = 0;
12597 if (mask & ELF_SPARC_HWCAP_DIV32)
12598 printf ("%sdiv32", first ? "" : "|"), first = 0;
12599 if (mask & ELF_SPARC_HWCAP_FSMULD)
12600 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12601 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12602 printf ("%sv8plus", first ? "" : "|"), first = 0;
12603 if (mask & ELF_SPARC_HWCAP_POPC)
12604 printf ("%spopc", first ? "" : "|"), first = 0;
12605 if (mask & ELF_SPARC_HWCAP_VIS)
12606 printf ("%svis", first ? "" : "|"), first = 0;
12607 if (mask & ELF_SPARC_HWCAP_VIS2)
12608 printf ("%svis2", first ? "" : "|"), first = 0;
12609 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12610 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12611 if (mask & ELF_SPARC_HWCAP_FMAF)
12612 printf ("%sfmaf", first ? "" : "|"), first = 0;
12613 if (mask & ELF_SPARC_HWCAP_VIS3)
12614 printf ("%svis3", first ? "" : "|"), first = 0;
12615 if (mask & ELF_SPARC_HWCAP_HPC)
12616 printf ("%shpc", first ? "" : "|"), first = 0;
12617 if (mask & ELF_SPARC_HWCAP_RANDOM)
12618 printf ("%srandom", first ? "" : "|"), first = 0;
12619 if (mask & ELF_SPARC_HWCAP_TRANS)
12620 printf ("%strans", first ? "" : "|"), first = 0;
12621 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12622 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12623 if (mask & ELF_SPARC_HWCAP_IMA)
12624 printf ("%sima", first ? "" : "|"), first = 0;
12625 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12626 printf ("%scspare", first ? "" : "|"), first = 0;
12629 fputc ('0', stdout);
12630 fputc ('\n', stdout);
12634 display_sparc_hwcaps2 (int mask)
12640 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12641 fputs ("fjathplus", stdout), first = 0;
12642 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12643 printf ("%svis3b", first ? "" : "|"), first = 0;
12644 if (mask & ELF_SPARC_HWCAP2_ADP)
12645 printf ("%sadp", first ? "" : "|"), first = 0;
12646 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12647 printf ("%ssparc5", first ? "" : "|"), first = 0;
12648 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12649 printf ("%smwait", first ? "" : "|"), first = 0;
12650 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12651 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12652 if (mask & ELF_SPARC_HWCAP2_XMONT)
12653 printf ("%sxmont2", first ? "" : "|"), first = 0;
12654 if (mask & ELF_SPARC_HWCAP2_NSEC)
12655 printf ("%snsec", first ? "" : "|"), first = 0;
12656 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12657 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12658 if (mask & ELF_SPARC_HWCAP2_FJDES)
12659 printf ("%sfjdes", first ? "" : "|"), first = 0;
12660 if (mask & ELF_SPARC_HWCAP2_FJAES)
12661 printf ("%sfjaes", first ? "" : "|"), first = 0;
12664 fputc ('0', stdout);
12665 fputc ('\n', stdout);
12668 static unsigned char *
12669 display_sparc_gnu_attribute (unsigned char * p,
12671 const unsigned char * const end)
12676 if (tag == Tag_GNU_Sparc_HWCAPS)
12678 val = read_uleb128 (p, &len, end);
12680 printf (" Tag_GNU_Sparc_HWCAPS: ");
12681 display_sparc_hwcaps (val);
12684 if (tag == Tag_GNU_Sparc_HWCAPS2)
12686 val = read_uleb128 (p, &len, end);
12688 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12689 display_sparc_hwcaps2 (val);
12693 return display_tag_value (tag, p, end);
12697 print_mips_fp_abi_value (int val)
12701 case Val_GNU_MIPS_ABI_FP_ANY:
12702 printf (_("Hard or soft float\n"));
12704 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12705 printf (_("Hard float (double precision)\n"));
12707 case Val_GNU_MIPS_ABI_FP_SINGLE:
12708 printf (_("Hard float (single precision)\n"));
12710 case Val_GNU_MIPS_ABI_FP_SOFT:
12711 printf (_("Soft float\n"));
12713 case Val_GNU_MIPS_ABI_FP_OLD_64:
12714 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12716 case Val_GNU_MIPS_ABI_FP_XX:
12717 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12719 case Val_GNU_MIPS_ABI_FP_64:
12720 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12722 case Val_GNU_MIPS_ABI_FP_64A:
12723 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12726 printf ("??? (%d)\n", val);
12731 static unsigned char *
12732 display_mips_gnu_attribute (unsigned char * p,
12734 const unsigned char * const end)
12736 if (tag == Tag_GNU_MIPS_ABI_FP)
12741 val = read_uleb128 (p, &len, end);
12743 printf (" Tag_GNU_MIPS_ABI_FP: ");
12745 print_mips_fp_abi_value (val);
12750 if (tag == Tag_GNU_MIPS_ABI_MSA)
12755 val = read_uleb128 (p, &len, end);
12757 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12761 case Val_GNU_MIPS_ABI_MSA_ANY:
12762 printf (_("Any MSA or not\n"));
12764 case Val_GNU_MIPS_ABI_MSA_128:
12765 printf (_("128-bit MSA\n"));
12768 printf ("??? (%d)\n", val);
12774 return display_tag_value (tag & 1, p, end);
12777 static unsigned char *
12778 display_tic6x_attribute (unsigned char * p,
12779 const unsigned char * const end)
12785 tag = read_uleb128 (p, &len, end);
12791 val = read_uleb128 (p, &len, end);
12793 printf (" Tag_ISA: ");
12797 case C6XABI_Tag_ISA_none:
12798 printf (_("None\n"));
12800 case C6XABI_Tag_ISA_C62X:
12803 case C6XABI_Tag_ISA_C67X:
12806 case C6XABI_Tag_ISA_C67XP:
12807 printf ("C67x+\n");
12809 case C6XABI_Tag_ISA_C64X:
12812 case C6XABI_Tag_ISA_C64XP:
12813 printf ("C64x+\n");
12815 case C6XABI_Tag_ISA_C674X:
12816 printf ("C674x\n");
12819 printf ("??? (%d)\n", val);
12824 case Tag_ABI_wchar_t:
12825 val = read_uleb128 (p, &len, end);
12827 printf (" Tag_ABI_wchar_t: ");
12831 printf (_("Not used\n"));
12834 printf (_("2 bytes\n"));
12837 printf (_("4 bytes\n"));
12840 printf ("??? (%d)\n", val);
12845 case Tag_ABI_stack_align_needed:
12846 val = read_uleb128 (p, &len, end);
12848 printf (" Tag_ABI_stack_align_needed: ");
12852 printf (_("8-byte\n"));
12855 printf (_("16-byte\n"));
12858 printf ("??? (%d)\n", val);
12863 case Tag_ABI_stack_align_preserved:
12864 val = read_uleb128 (p, &len, end);
12866 printf (" Tag_ABI_stack_align_preserved: ");
12870 printf (_("8-byte\n"));
12873 printf (_("16-byte\n"));
12876 printf ("??? (%d)\n", val);
12882 val = read_uleb128 (p, &len, end);
12884 printf (" Tag_ABI_DSBT: ");
12888 printf (_("DSBT addressing not used\n"));
12891 printf (_("DSBT addressing used\n"));
12894 printf ("??? (%d)\n", val);
12900 val = read_uleb128 (p, &len, end);
12902 printf (" Tag_ABI_PID: ");
12906 printf (_("Data addressing position-dependent\n"));
12909 printf (_("Data addressing position-independent, GOT near DP\n"));
12912 printf (_("Data addressing position-independent, GOT far from DP\n"));
12915 printf ("??? (%d)\n", val);
12921 val = read_uleb128 (p, &len, end);
12923 printf (" Tag_ABI_PIC: ");
12927 printf (_("Code addressing position-dependent\n"));
12930 printf (_("Code addressing position-independent\n"));
12933 printf ("??? (%d)\n", val);
12938 case Tag_ABI_array_object_alignment:
12939 val = read_uleb128 (p, &len, end);
12941 printf (" Tag_ABI_array_object_alignment: ");
12945 printf (_("8-byte\n"));
12948 printf (_("4-byte\n"));
12951 printf (_("16-byte\n"));
12954 printf ("??? (%d)\n", val);
12959 case Tag_ABI_array_object_align_expected:
12960 val = read_uleb128 (p, &len, end);
12962 printf (" Tag_ABI_array_object_align_expected: ");
12966 printf (_("8-byte\n"));
12969 printf (_("4-byte\n"));
12972 printf (_("16-byte\n"));
12975 printf ("??? (%d)\n", val);
12980 case Tag_ABI_compatibility:
12982 val = read_uleb128 (p, &len, end);
12984 printf (" Tag_ABI_compatibility: ");
12985 printf (_("flag = %d, vendor = "), val);
12988 size_t maxlen = (end - p) - 1;
12990 print_symbol ((int) maxlen, (const char *) p);
12991 p += strnlen ((char *) p, maxlen) + 1;
12995 printf (_("<corrupt>"));
12996 p = (unsigned char *) end;
13002 case Tag_ABI_conformance:
13004 printf (" Tag_ABI_conformance: \"");
13007 size_t maxlen = (end - p) - 1;
13009 print_symbol ((int) maxlen, (const char *) p);
13010 p += strnlen ((char *) p, maxlen) + 1;
13014 printf (_("<corrupt>"));
13015 p = (unsigned char *) end;
13022 return display_tag_value (tag, p, end);
13026 display_raw_attribute (unsigned char * p, unsigned char * end)
13028 unsigned long addr = 0;
13029 size_t bytes = end - p;
13036 int lbytes = (bytes > 16 ? 16 : bytes);
13038 printf (" 0x%8.8lx ", addr);
13040 for (j = 0; j < 16; j++)
13043 printf ("%2.2x", p[j]);
13051 for (j = 0; j < lbytes; j++)
13054 if (k >= ' ' && k < 0x7f)
13070 static unsigned char *
13071 display_msp430x_attribute (unsigned char * p,
13072 const unsigned char * const end)
13078 tag = read_uleb128 (p, & len, end);
13083 case OFBA_MSPABI_Tag_ISA:
13084 val = read_uleb128 (p, &len, end);
13086 printf (" Tag_ISA: ");
13089 case 0: printf (_("None\n")); break;
13090 case 1: printf (_("MSP430\n")); break;
13091 case 2: printf (_("MSP430X\n")); break;
13092 default: printf ("??? (%d)\n", val); break;
13096 case OFBA_MSPABI_Tag_Code_Model:
13097 val = read_uleb128 (p, &len, end);
13099 printf (" Tag_Code_Model: ");
13102 case 0: printf (_("None\n")); break;
13103 case 1: printf (_("Small\n")); break;
13104 case 2: printf (_("Large\n")); break;
13105 default: printf ("??? (%d)\n", val); break;
13109 case OFBA_MSPABI_Tag_Data_Model:
13110 val = read_uleb128 (p, &len, end);
13112 printf (" Tag_Data_Model: ");
13115 case 0: printf (_("None\n")); break;
13116 case 1: printf (_("Small\n")); break;
13117 case 2: printf (_("Large\n")); break;
13118 case 3: printf (_("Restricted Large\n")); break;
13119 default: printf ("??? (%d)\n", val); break;
13124 printf (_(" <unknown tag %d>: "), tag);
13131 size_t maxlen = (end - p) - 1;
13133 print_symbol ((int) maxlen, (const char *) p);
13134 p += strnlen ((char *) p, maxlen) + 1;
13138 printf (_("<corrupt>"));
13139 p = (unsigned char *) end;
13145 val = read_uleb128 (p, &len, end);
13147 printf ("%d (0x%x)\n", val, val);
13157 process_attributes (FILE * file,
13158 const char * public_name,
13159 unsigned int proc_type,
13160 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13161 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13163 Elf_Internal_Shdr * sect;
13166 /* Find the section header so that we get the size. */
13167 for (i = 0, sect = section_headers;
13168 i < elf_header.e_shnum;
13171 unsigned char * contents;
13174 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13177 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13178 sect->sh_size, _("attributes"));
13179 if (contents == NULL)
13185 bfd_vma section_len;
13187 section_len = sect->sh_size - 1;
13190 while (section_len > 0)
13193 unsigned int namelen;
13194 bfd_boolean public_section;
13195 bfd_boolean gnu_section;
13197 if (section_len <= 4)
13199 error (_("Tag section ends prematurely\n"));
13202 attr_len = byte_get (p, 4);
13205 if (attr_len > section_len)
13207 error (_("Bad attribute length (%u > %u)\n"),
13208 (unsigned) attr_len, (unsigned) section_len);
13209 attr_len = section_len;
13211 /* PR 17531: file: 001-101425-0.004 */
13212 else if (attr_len < 5)
13214 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13218 section_len -= attr_len;
13221 namelen = strnlen ((char *) p, attr_len) + 1;
13222 if (namelen == 0 || namelen >= attr_len)
13224 error (_("Corrupt attribute section name\n"));
13228 printf (_("Attribute Section: "));
13229 print_symbol (INT_MAX, (const char *) p);
13232 if (public_name && streq ((char *) p, public_name))
13233 public_section = TRUE;
13235 public_section = FALSE;
13237 if (streq ((char *) p, "gnu"))
13238 gnu_section = TRUE;
13240 gnu_section = FALSE;
13243 attr_len -= namelen;
13245 while (attr_len > 0 && p < contents + sect->sh_size)
13250 unsigned char * end;
13252 /* PR binutils/17531: Safe handling of corrupt files. */
13255 error (_("Unused bytes at end of section\n"));
13261 size = byte_get (p, 4);
13262 if (size > attr_len)
13264 error (_("Bad subsection length (%u > %u)\n"),
13265 (unsigned) size, (unsigned) attr_len);
13268 /* PR binutils/17531: Safe handling of corrupt files. */
13271 error (_("Bad subsection length (%u < 6)\n"),
13278 end = p + size - 1;
13279 assert (end <= contents + sect->sh_size);
13285 printf (_("File Attributes\n"));
13288 printf (_("Section Attributes:"));
13291 printf (_("Symbol Attributes:"));
13297 val = read_uleb128 (p, &j, end);
13301 printf (" %d", val);
13306 printf (_("Unknown tag: %d\n"), tag);
13307 public_section = FALSE;
13311 if (public_section && display_pub_attribute != NULL)
13314 p = display_pub_attribute (p, end);
13317 else if (gnu_section && display_proc_gnu_attribute != NULL)
13320 p = display_gnu_attribute (p,
13321 display_proc_gnu_attribute,
13327 printf (_(" Unknown attribute:\n"));
13328 display_raw_attribute (p, end);
13337 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13345 process_arm_specific (FILE * file)
13347 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13348 display_arm_attribute, NULL);
13352 process_power_specific (FILE * file)
13354 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13355 display_power_gnu_attribute);
13359 process_sparc_specific (FILE * file)
13361 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13362 display_sparc_gnu_attribute);
13366 process_tic6x_specific (FILE * file)
13368 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13369 display_tic6x_attribute, NULL);
13373 process_msp430x_specific (FILE * file)
13375 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13376 display_msp430x_attribute, NULL);
13379 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13380 Print the Address, Access and Initial fields of an entry at VMA ADDR
13381 and return the VMA of the next entry. */
13384 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13387 print_vma (addr, LONG_HEX);
13389 if (addr < pltgot + 0xfff0)
13390 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13392 printf ("%10s", "");
13395 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13400 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13401 print_vma (entry, LONG_HEX);
13403 return addr + (is_32bit_elf ? 4 : 8);
13406 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13407 PLTGOT. Print the Address and Initial fields of an entry at VMA
13408 ADDR and return the VMA of the next entry. */
13411 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13414 print_vma (addr, LONG_HEX);
13417 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13422 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13423 print_vma (entry, LONG_HEX);
13425 return addr + (is_32bit_elf ? 4 : 8);
13429 print_mips_ases (unsigned int mask)
13431 if (mask & AFL_ASE_DSP)
13432 fputs ("\n\tDSP ASE", stdout);
13433 if (mask & AFL_ASE_DSPR2)
13434 fputs ("\n\tDSP R2 ASE", stdout);
13435 if (mask & AFL_ASE_EVA)
13436 fputs ("\n\tEnhanced VA Scheme", stdout);
13437 if (mask & AFL_ASE_MCU)
13438 fputs ("\n\tMCU (MicroController) ASE", stdout);
13439 if (mask & AFL_ASE_MDMX)
13440 fputs ("\n\tMDMX ASE", stdout);
13441 if (mask & AFL_ASE_MIPS3D)
13442 fputs ("\n\tMIPS-3D ASE", stdout);
13443 if (mask & AFL_ASE_MT)
13444 fputs ("\n\tMT ASE", stdout);
13445 if (mask & AFL_ASE_SMARTMIPS)
13446 fputs ("\n\tSmartMIPS ASE", stdout);
13447 if (mask & AFL_ASE_VIRT)
13448 fputs ("\n\tVZ ASE", stdout);
13449 if (mask & AFL_ASE_MSA)
13450 fputs ("\n\tMSA ASE", stdout);
13451 if (mask & AFL_ASE_MIPS16)
13452 fputs ("\n\tMIPS16 ASE", stdout);
13453 if (mask & AFL_ASE_MICROMIPS)
13454 fputs ("\n\tMICROMIPS ASE", stdout);
13455 if (mask & AFL_ASE_XPA)
13456 fputs ("\n\tXPA ASE", stdout);
13458 fprintf (stdout, "\n\t%s", _("None"));
13459 else if ((mask & ~AFL_ASE_MASK) != 0)
13460 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13464 print_mips_isa_ext (unsigned int isa_ext)
13469 fputs (_("None"), stdout);
13472 fputs ("RMI XLR", stdout);
13474 case AFL_EXT_OCTEON3:
13475 fputs ("Cavium Networks Octeon3", stdout);
13477 case AFL_EXT_OCTEON2:
13478 fputs ("Cavium Networks Octeon2", stdout);
13480 case AFL_EXT_OCTEONP:
13481 fputs ("Cavium Networks OcteonP", stdout);
13483 case AFL_EXT_LOONGSON_3A:
13484 fputs ("Loongson 3A", stdout);
13486 case AFL_EXT_OCTEON:
13487 fputs ("Cavium Networks Octeon", stdout);
13490 fputs ("Toshiba R5900", stdout);
13493 fputs ("MIPS R4650", stdout);
13496 fputs ("LSI R4010", stdout);
13499 fputs ("NEC VR4100", stdout);
13502 fputs ("Toshiba R3900", stdout);
13504 case AFL_EXT_10000:
13505 fputs ("MIPS R10000", stdout);
13508 fputs ("Broadcom SB-1", stdout);
13511 fputs ("NEC VR4111/VR4181", stdout);
13514 fputs ("NEC VR4120", stdout);
13517 fputs ("NEC VR5400", stdout);
13520 fputs ("NEC VR5500", stdout);
13522 case AFL_EXT_LOONGSON_2E:
13523 fputs ("ST Microelectronics Loongson 2E", stdout);
13525 case AFL_EXT_LOONGSON_2F:
13526 fputs ("ST Microelectronics Loongson 2F", stdout);
13529 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13534 get_mips_reg_size (int reg_size)
13536 return (reg_size == AFL_REG_NONE) ? 0
13537 : (reg_size == AFL_REG_32) ? 32
13538 : (reg_size == AFL_REG_64) ? 64
13539 : (reg_size == AFL_REG_128) ? 128
13544 process_mips_specific (FILE * file)
13546 Elf_Internal_Dyn * entry;
13547 Elf_Internal_Shdr *sect = NULL;
13548 size_t liblist_offset = 0;
13549 size_t liblistno = 0;
13550 size_t conflictsno = 0;
13551 size_t options_offset = 0;
13552 size_t conflicts_offset = 0;
13553 size_t pltrelsz = 0;
13555 bfd_vma pltgot = 0;
13556 bfd_vma mips_pltgot = 0;
13557 bfd_vma jmprel = 0;
13558 bfd_vma local_gotno = 0;
13559 bfd_vma gotsym = 0;
13560 bfd_vma symtabno = 0;
13562 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13563 display_mips_gnu_attribute);
13565 sect = find_section (".MIPS.abiflags");
13569 Elf_External_ABIFlags_v0 *abiflags_ext;
13570 Elf_Internal_ABIFlags_v0 abiflags_in;
13572 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13573 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13576 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13577 sect->sh_size, _("MIPS ABI Flags section"));
13580 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13581 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13582 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13583 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13584 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13585 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13586 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13587 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13588 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13589 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13590 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13592 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13593 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13594 if (abiflags_in.isa_rev > 1)
13595 printf ("r%d", abiflags_in.isa_rev);
13596 printf ("\nGPR size: %d",
13597 get_mips_reg_size (abiflags_in.gpr_size));
13598 printf ("\nCPR1 size: %d",
13599 get_mips_reg_size (abiflags_in.cpr1_size));
13600 printf ("\nCPR2 size: %d",
13601 get_mips_reg_size (abiflags_in.cpr2_size));
13602 fputs ("\nFP ABI: ", stdout);
13603 print_mips_fp_abi_value (abiflags_in.fp_abi);
13604 fputs ("ISA Extension: ", stdout);
13605 print_mips_isa_ext (abiflags_in.isa_ext);
13606 fputs ("\nASEs:", stdout);
13607 print_mips_ases (abiflags_in.ases);
13608 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13609 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13610 fputc ('\n', stdout);
13611 free (abiflags_ext);
13616 /* We have a lot of special sections. Thanks SGI! */
13617 if (dynamic_section == NULL)
13618 /* No information available. */
13621 for (entry = dynamic_section;
13622 /* PR 17531 file: 012-50589-0.004. */
13623 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13625 switch (entry->d_tag)
13627 case DT_MIPS_LIBLIST:
13629 = offset_from_vma (file, entry->d_un.d_val,
13630 liblistno * sizeof (Elf32_External_Lib));
13632 case DT_MIPS_LIBLISTNO:
13633 liblistno = entry->d_un.d_val;
13635 case DT_MIPS_OPTIONS:
13636 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13638 case DT_MIPS_CONFLICT:
13640 = offset_from_vma (file, entry->d_un.d_val,
13641 conflictsno * sizeof (Elf32_External_Conflict));
13643 case DT_MIPS_CONFLICTNO:
13644 conflictsno = entry->d_un.d_val;
13647 pltgot = entry->d_un.d_ptr;
13649 case DT_MIPS_LOCAL_GOTNO:
13650 local_gotno = entry->d_un.d_val;
13652 case DT_MIPS_GOTSYM:
13653 gotsym = entry->d_un.d_val;
13655 case DT_MIPS_SYMTABNO:
13656 symtabno = entry->d_un.d_val;
13658 case DT_MIPS_PLTGOT:
13659 mips_pltgot = entry->d_un.d_ptr;
13662 pltrel = entry->d_un.d_val;
13665 pltrelsz = entry->d_un.d_val;
13668 jmprel = entry->d_un.d_ptr;
13674 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13676 Elf32_External_Lib * elib;
13679 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13681 sizeof (Elf32_External_Lib),
13682 _("liblist section data"));
13685 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13686 (unsigned long) liblistno);
13687 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13690 for (cnt = 0; cnt < liblistno; ++cnt)
13697 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13698 atime = BYTE_GET (elib[cnt].l_time_stamp);
13699 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13700 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13701 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13703 tmp = gmtime (&atime);
13704 snprintf (timebuf, sizeof (timebuf),
13705 "%04u-%02u-%02uT%02u:%02u:%02u",
13706 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13707 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13709 printf ("%3lu: ", (unsigned long) cnt);
13710 if (VALID_DYNAMIC_NAME (liblist.l_name))
13711 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13713 printf (_("<corrupt: %9ld>"), liblist.l_name);
13714 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13715 liblist.l_version);
13717 if (liblist.l_flags == 0)
13721 static const struct
13728 { " EXACT_MATCH", LL_EXACT_MATCH },
13729 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13730 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13731 { " EXPORTS", LL_EXPORTS },
13732 { " DELAY_LOAD", LL_DELAY_LOAD },
13733 { " DELTA", LL_DELTA }
13735 int flags = liblist.l_flags;
13738 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13739 if ((flags & l_flags_vals[fcnt].bit) != 0)
13741 fputs (l_flags_vals[fcnt].name, stdout);
13742 flags ^= l_flags_vals[fcnt].bit;
13745 printf (" %#x", (unsigned int) flags);
13755 if (options_offset != 0)
13757 Elf_External_Options * eopt;
13758 Elf_Internal_Options * iopt;
13759 Elf_Internal_Options * option;
13762 sect = section_headers;
13764 /* Find the section header so that we get the size. */
13765 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13766 /* PR 17533 file: 012-277276-0.004. */
13769 error (_("No MIPS_OPTIONS header found\n"));
13773 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13774 sect->sh_size, _("options"));
13777 iopt = (Elf_Internal_Options *)
13778 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13781 error (_("Out of memory allocatinf space for MIPS options\n"));
13788 while (offset < sect->sh_size)
13790 Elf_External_Options * eoption;
13792 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13794 option->kind = BYTE_GET (eoption->kind);
13795 option->size = BYTE_GET (eoption->size);
13796 option->section = BYTE_GET (eoption->section);
13797 option->info = BYTE_GET (eoption->info);
13799 offset += option->size;
13805 printf (_("\nSection '%s' contains %d entries:\n"),
13806 printable_section_name (sect), cnt);
13814 switch (option->kind)
13817 /* This shouldn't happen. */
13818 printf (" NULL %d %lx", option->section, option->info);
13821 printf (" REGINFO ");
13822 if (elf_header.e_machine == EM_MIPS)
13825 Elf32_External_RegInfo * ereg;
13826 Elf32_RegInfo reginfo;
13828 ereg = (Elf32_External_RegInfo *) (option + 1);
13829 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13830 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13831 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13832 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13833 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13834 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13836 printf ("GPR %08lx GP 0x%lx\n",
13837 reginfo.ri_gprmask,
13838 (unsigned long) reginfo.ri_gp_value);
13839 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13840 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13841 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13846 Elf64_External_RegInfo * ereg;
13847 Elf64_Internal_RegInfo reginfo;
13849 ereg = (Elf64_External_RegInfo *) (option + 1);
13850 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13851 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13852 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13853 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13854 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13855 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13857 printf ("GPR %08lx GP 0x",
13858 reginfo.ri_gprmask);
13859 printf_vma (reginfo.ri_gp_value);
13862 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13863 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13864 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13868 case ODK_EXCEPTIONS:
13869 fputs (" EXCEPTIONS fpe_min(", stdout);
13870 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13871 fputs (") fpe_max(", stdout);
13872 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13873 fputs (")", stdout);
13875 if (option->info & OEX_PAGE0)
13876 fputs (" PAGE0", stdout);
13877 if (option->info & OEX_SMM)
13878 fputs (" SMM", stdout);
13879 if (option->info & OEX_FPDBUG)
13880 fputs (" FPDBUG", stdout);
13881 if (option->info & OEX_DISMISS)
13882 fputs (" DISMISS", stdout);
13885 fputs (" PAD ", stdout);
13886 if (option->info & OPAD_PREFIX)
13887 fputs (" PREFIX", stdout);
13888 if (option->info & OPAD_POSTFIX)
13889 fputs (" POSTFIX", stdout);
13890 if (option->info & OPAD_SYMBOL)
13891 fputs (" SYMBOL", stdout);
13894 fputs (" HWPATCH ", stdout);
13895 if (option->info & OHW_R4KEOP)
13896 fputs (" R4KEOP", stdout);
13897 if (option->info & OHW_R8KPFETCH)
13898 fputs (" R8KPFETCH", stdout);
13899 if (option->info & OHW_R5KEOP)
13900 fputs (" R5KEOP", stdout);
13901 if (option->info & OHW_R5KCVTL)
13902 fputs (" R5KCVTL", stdout);
13905 fputs (" FILL ", stdout);
13906 /* XXX Print content of info word? */
13909 fputs (" TAGS ", stdout);
13910 /* XXX Print content of info word? */
13913 fputs (" HWAND ", stdout);
13914 if (option->info & OHWA0_R4KEOP_CHECKED)
13915 fputs (" R4KEOP_CHECKED", stdout);
13916 if (option->info & OHWA0_R4KEOP_CLEAN)
13917 fputs (" R4KEOP_CLEAN", stdout);
13920 fputs (" HWOR ", stdout);
13921 if (option->info & OHWA0_R4KEOP_CHECKED)
13922 fputs (" R4KEOP_CHECKED", stdout);
13923 if (option->info & OHWA0_R4KEOP_CLEAN)
13924 fputs (" R4KEOP_CLEAN", stdout);
13927 printf (" GP_GROUP %#06lx self-contained %#06lx",
13928 option->info & OGP_GROUP,
13929 (option->info & OGP_SELF) >> 16);
13932 printf (" IDENT %#06lx self-contained %#06lx",
13933 option->info & OGP_GROUP,
13934 (option->info & OGP_SELF) >> 16);
13937 /* This shouldn't happen. */
13938 printf (" %3d ??? %d %lx",
13939 option->kind, option->section, option->info);
13943 len = sizeof (* eopt);
13944 while (len < option->size)
13945 if (((char *) option)[len] >= ' '
13946 && ((char *) option)[len] < 0x7f)
13947 printf ("%c", ((char *) option)[len++]);
13949 printf ("\\%03o", ((char *) option)[len++]);
13951 fputs ("\n", stdout);
13959 if (conflicts_offset != 0 && conflictsno != 0)
13961 Elf32_Conflict * iconf;
13964 if (dynamic_symbols == NULL)
13966 error (_("conflict list found without a dynamic symbol table\n"));
13970 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13973 error (_("Out of memory allocating space for dynamic conflicts\n"));
13979 Elf32_External_Conflict * econf32;
13981 econf32 = (Elf32_External_Conflict *)
13982 get_data (NULL, file, conflicts_offset, conflictsno,
13983 sizeof (* econf32), _("conflict"));
13987 for (cnt = 0; cnt < conflictsno; ++cnt)
13988 iconf[cnt] = BYTE_GET (econf32[cnt]);
13994 Elf64_External_Conflict * econf64;
13996 econf64 = (Elf64_External_Conflict *)
13997 get_data (NULL, file, conflicts_offset, conflictsno,
13998 sizeof (* econf64), _("conflict"));
14002 for (cnt = 0; cnt < conflictsno; ++cnt)
14003 iconf[cnt] = BYTE_GET (econf64[cnt]);
14008 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14009 (unsigned long) conflictsno);
14010 puts (_(" Num: Index Value Name"));
14012 for (cnt = 0; cnt < conflictsno; ++cnt)
14014 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
14016 if (iconf[cnt] >= num_dynamic_syms)
14017 printf (_("<corrupt symbol index>"));
14020 Elf_Internal_Sym * psym;
14022 psym = & dynamic_symbols[iconf[cnt]];
14023 print_vma (psym->st_value, FULL_HEX);
14025 if (VALID_DYNAMIC_NAME (psym->st_name))
14026 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14028 printf (_("<corrupt: %14ld>"), psym->st_name);
14036 if (pltgot != 0 && local_gotno != 0)
14038 bfd_vma ent, local_end, global_end;
14040 unsigned char * data;
14044 addr_size = (is_32bit_elf ? 4 : 8);
14045 local_end = pltgot + local_gotno * addr_size;
14047 /* PR binutils/17533 file: 012-111227-0.004 */
14048 if (symtabno < gotsym)
14050 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14051 (long) gotsym, (long) symtabno);
14055 global_end = local_end + (symtabno - gotsym) * addr_size;
14056 assert (global_end >= local_end);
14057 offset = offset_from_vma (file, pltgot, global_end - pltgot);
14058 data = (unsigned char *) get_data (NULL, file, offset,
14059 global_end - pltgot, 1,
14060 _("Global Offset Table data"));
14064 printf (_("\nPrimary GOT:\n"));
14065 printf (_(" Canonical gp value: "));
14066 print_vma (pltgot + 0x7ff0, LONG_HEX);
14069 printf (_(" Reserved entries:\n"));
14070 printf (_(" %*s %10s %*s Purpose\n"),
14071 addr_size * 2, _("Address"), _("Access"),
14072 addr_size * 2, _("Initial"));
14073 ent = print_mips_got_entry (data, pltgot, ent);
14074 printf (_(" Lazy resolver\n"));
14076 && (byte_get (data + ent - pltgot, addr_size)
14077 >> (addr_size * 8 - 1)) != 0)
14079 ent = print_mips_got_entry (data, pltgot, ent);
14080 printf (_(" Module pointer (GNU extension)\n"));
14084 if (ent < local_end)
14086 printf (_(" Local entries:\n"));
14087 printf (" %*s %10s %*s\n",
14088 addr_size * 2, _("Address"), _("Access"),
14089 addr_size * 2, _("Initial"));
14090 while (ent < local_end)
14092 ent = print_mips_got_entry (data, pltgot, ent);
14098 if (gotsym < symtabno)
14102 printf (_(" Global entries:\n"));
14103 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14104 addr_size * 2, _("Address"),
14106 addr_size * 2, _("Initial"),
14107 addr_size * 2, _("Sym.Val."),
14109 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14110 _("Ndx"), _("Name"));
14112 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14114 for (i = gotsym; i < symtabno; i++)
14116 ent = print_mips_got_entry (data, pltgot, ent);
14119 if (dynamic_symbols == NULL)
14120 printf (_("<no dynamic symbols>"));
14121 else if (i < num_dynamic_syms)
14123 Elf_Internal_Sym * psym = dynamic_symbols + i;
14125 print_vma (psym->st_value, LONG_HEX);
14126 printf (" %-7s %3s ",
14127 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14128 get_symbol_index_type (psym->st_shndx));
14130 if (VALID_DYNAMIC_NAME (psym->st_name))
14131 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14133 printf (_("<corrupt: %14ld>"), psym->st_name);
14136 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14137 (unsigned long) i);
14148 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14151 size_t offset, rel_offset;
14152 unsigned long count, i;
14153 unsigned char * data;
14154 int addr_size, sym_width;
14155 Elf_Internal_Rela * rels;
14157 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14158 if (pltrel == DT_RELA)
14160 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14165 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14170 addr_size = (is_32bit_elf ? 4 : 8);
14171 end = mips_pltgot + (2 + count) * addr_size;
14173 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14174 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14175 1, _("Procedure Linkage Table data"));
14179 printf ("\nPLT GOT:\n\n");
14180 printf (_(" Reserved entries:\n"));
14181 printf (_(" %*s %*s Purpose\n"),
14182 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14183 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14184 printf (_(" PLT lazy resolver\n"));
14185 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14186 printf (_(" Module pointer\n"));
14189 printf (_(" Entries:\n"));
14190 printf (" %*s %*s %*s %-7s %3s %s\n",
14191 addr_size * 2, _("Address"),
14192 addr_size * 2, _("Initial"),
14193 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14194 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14195 for (i = 0; i < count; i++)
14197 unsigned long idx = get_reloc_symindex (rels[i].r_info);
14199 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14202 if (idx >= num_dynamic_syms)
14203 printf (_("<corrupt symbol index: %lu>"), idx);
14206 Elf_Internal_Sym * psym = dynamic_symbols + idx;
14208 print_vma (psym->st_value, LONG_HEX);
14209 printf (" %-7s %3s ",
14210 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14211 get_symbol_index_type (psym->st_shndx));
14212 if (VALID_DYNAMIC_NAME (psym->st_name))
14213 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14215 printf (_("<corrupt: %14ld>"), psym->st_name);
14230 process_nds32_specific (FILE * file)
14232 Elf_Internal_Shdr *sect = NULL;
14234 sect = find_section (".nds32_e_flags");
14237 unsigned int *flag;
14239 printf ("\nNDS32 elf flags section:\n");
14240 flag = get_data (NULL, file, sect->sh_offset, 1,
14241 sect->sh_size, _("NDS32 elf flags section"));
14243 switch ((*flag) & 0x3)
14246 printf ("(VEC_SIZE):\tNo entry.\n");
14249 printf ("(VEC_SIZE):\t4 bytes\n");
14252 printf ("(VEC_SIZE):\t16 bytes\n");
14255 printf ("(VEC_SIZE):\treserved\n");
14264 process_gnu_liblist (FILE * file)
14266 Elf_Internal_Shdr * section;
14267 Elf_Internal_Shdr * string_sec;
14268 Elf32_External_Lib * elib;
14270 size_t strtab_size;
14277 for (i = 0, section = section_headers;
14278 i < elf_header.e_shnum;
14281 switch (section->sh_type)
14283 case SHT_GNU_LIBLIST:
14284 if (section->sh_link >= elf_header.e_shnum)
14287 elib = (Elf32_External_Lib *)
14288 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14289 _("liblist section data"));
14293 string_sec = section_headers + section->sh_link;
14295 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14296 string_sec->sh_size,
14297 _("liblist string table"));
14299 || section->sh_entsize != sizeof (Elf32_External_Lib))
14305 strtab_size = string_sec->sh_size;
14307 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14308 printable_section_name (section),
14309 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14311 puts (_(" Library Time Stamp Checksum Version Flags"));
14313 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14321 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14322 atime = BYTE_GET (elib[cnt].l_time_stamp);
14323 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14324 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14325 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14327 tmp = gmtime (&atime);
14328 snprintf (timebuf, sizeof (timebuf),
14329 "%04u-%02u-%02uT%02u:%02u:%02u",
14330 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14331 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14333 printf ("%3lu: ", (unsigned long) cnt);
14335 printf ("%-20s", liblist.l_name < strtab_size
14336 ? strtab + liblist.l_name : _("<corrupt>"));
14338 printf ("%-20.20s", liblist.l_name < strtab_size
14339 ? strtab + liblist.l_name : _("<corrupt>"));
14340 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14341 liblist.l_version, liblist.l_flags);
14352 static const char *
14353 get_note_type (unsigned e_type)
14355 static char buff[64];
14357 if (elf_header.e_type == ET_CORE)
14361 return _("NT_AUXV (auxiliary vector)");
14363 return _("NT_PRSTATUS (prstatus structure)");
14365 return _("NT_FPREGSET (floating point registers)");
14367 return _("NT_PRPSINFO (prpsinfo structure)");
14368 case NT_TASKSTRUCT:
14369 return _("NT_TASKSTRUCT (task structure)");
14371 return _("NT_PRXFPREG (user_xfpregs structure)");
14373 return _("NT_PPC_VMX (ppc Altivec registers)");
14375 return _("NT_PPC_VSX (ppc VSX registers)");
14377 return _("NT_386_TLS (x86 TLS information)");
14378 case NT_386_IOPERM:
14379 return _("NT_386_IOPERM (x86 I/O permissions)");
14380 case NT_X86_XSTATE:
14381 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14382 case NT_S390_HIGH_GPRS:
14383 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14384 case NT_S390_TIMER:
14385 return _("NT_S390_TIMER (s390 timer register)");
14386 case NT_S390_TODCMP:
14387 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14388 case NT_S390_TODPREG:
14389 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14391 return _("NT_S390_CTRS (s390 control registers)");
14392 case NT_S390_PREFIX:
14393 return _("NT_S390_PREFIX (s390 prefix register)");
14394 case NT_S390_LAST_BREAK:
14395 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14396 case NT_S390_SYSTEM_CALL:
14397 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14399 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14401 return _("NT_ARM_VFP (arm VFP registers)");
14403 return _("NT_ARM_TLS (AArch TLS registers)");
14404 case NT_ARM_HW_BREAK:
14405 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14406 case NT_ARM_HW_WATCH:
14407 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14409 return _("NT_PSTATUS (pstatus structure)");
14411 return _("NT_FPREGS (floating point registers)");
14413 return _("NT_PSINFO (psinfo structure)");
14415 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14417 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14418 case NT_WIN32PSTATUS:
14419 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14421 return _("NT_SIGINFO (siginfo_t data)");
14423 return _("NT_FILE (mapped files)");
14431 return _("NT_VERSION (version)");
14433 return _("NT_ARCH (architecture)");
14438 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14443 print_core_note (Elf_Internal_Note *pnote)
14445 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14446 bfd_vma count, page_size;
14447 unsigned char *descdata, *filenames, *descend;
14449 if (pnote->type != NT_FILE)
14455 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14456 /* Still "successful". */
14461 if (pnote->descsz < 2 * addr_size)
14463 printf (_(" Malformed note - too short for header\n"));
14467 descdata = (unsigned char *) pnote->descdata;
14468 descend = descdata + pnote->descsz;
14470 if (descdata[pnote->descsz - 1] != '\0')
14472 printf (_(" Malformed note - does not end with \\0\n"));
14476 count = byte_get (descdata, addr_size);
14477 descdata += addr_size;
14479 page_size = byte_get (descdata, addr_size);
14480 descdata += addr_size;
14482 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14484 printf (_(" Malformed note - too short for supplied file count\n"));
14488 printf (_(" Page size: "));
14489 print_vma (page_size, DEC);
14492 printf (_(" %*s%*s%*s\n"),
14493 (int) (2 + 2 * addr_size), _("Start"),
14494 (int) (4 + 2 * addr_size), _("End"),
14495 (int) (4 + 2 * addr_size), _("Page Offset"));
14496 filenames = descdata + count * 3 * addr_size;
14497 while (--count > 0)
14499 bfd_vma start, end, file_ofs;
14501 if (filenames == descend)
14503 printf (_(" Malformed note - filenames end too early\n"));
14507 start = byte_get (descdata, addr_size);
14508 descdata += addr_size;
14509 end = byte_get (descdata, addr_size);
14510 descdata += addr_size;
14511 file_ofs = byte_get (descdata, addr_size);
14512 descdata += addr_size;
14515 print_vma (start, FULL_HEX);
14517 print_vma (end, FULL_HEX);
14519 print_vma (file_ofs, FULL_HEX);
14520 printf ("\n %s\n", filenames);
14522 filenames += 1 + strlen ((char *) filenames);
14528 static const char *
14529 get_gnu_elf_note_type (unsigned e_type)
14531 static char buff[64];
14535 case NT_GNU_ABI_TAG:
14536 return _("NT_GNU_ABI_TAG (ABI version tag)");
14538 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14539 case NT_GNU_BUILD_ID:
14540 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14541 case NT_GNU_GOLD_VERSION:
14542 return _("NT_GNU_GOLD_VERSION (gold version)");
14547 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14552 print_gnu_note (Elf_Internal_Note *pnote)
14554 switch (pnote->type)
14556 case NT_GNU_BUILD_ID:
14560 printf (_(" Build ID: "));
14561 for (i = 0; i < pnote->descsz; ++i)
14562 printf ("%02x", pnote->descdata[i] & 0xff);
14567 case NT_GNU_ABI_TAG:
14569 unsigned long os, major, minor, subminor;
14570 const char *osname;
14572 /* PR 17531: file: 030-599401-0.004. */
14573 if (pnote->descsz < 16)
14575 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14579 os = byte_get ((unsigned char *) pnote->descdata, 4);
14580 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14581 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14582 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14586 case GNU_ABI_TAG_LINUX:
14589 case GNU_ABI_TAG_HURD:
14592 case GNU_ABI_TAG_SOLARIS:
14593 osname = "Solaris";
14595 case GNU_ABI_TAG_FREEBSD:
14596 osname = "FreeBSD";
14598 case GNU_ABI_TAG_NETBSD:
14602 osname = "Unknown";
14606 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14607 major, minor, subminor);
14611 case NT_GNU_GOLD_VERSION:
14615 printf (_(" Version: "));
14616 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14617 printf ("%c", pnote->descdata[i]);
14626 static const char *
14627 get_netbsd_elfcore_note_type (unsigned e_type)
14629 static char buff[64];
14631 if (e_type == NT_NETBSDCORE_PROCINFO)
14633 /* NetBSD core "procinfo" structure. */
14634 return _("NetBSD procinfo structure");
14637 /* As of Jan 2002 there are no other machine-independent notes
14638 defined for NetBSD core files. If the note type is less
14639 than the start of the machine-dependent note types, we don't
14642 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14644 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14648 switch (elf_header.e_machine)
14650 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14651 and PT_GETFPREGS == mach+2. */
14656 case EM_SPARC32PLUS:
14660 case NT_NETBSDCORE_FIRSTMACH + 0:
14661 return _("PT_GETREGS (reg structure)");
14662 case NT_NETBSDCORE_FIRSTMACH + 2:
14663 return _("PT_GETFPREGS (fpreg structure)");
14669 /* On all other arch's, PT_GETREGS == mach+1 and
14670 PT_GETFPREGS == mach+3. */
14674 case NT_NETBSDCORE_FIRSTMACH + 1:
14675 return _("PT_GETREGS (reg structure)");
14676 case NT_NETBSDCORE_FIRSTMACH + 3:
14677 return _("PT_GETFPREGS (fpreg structure)");
14683 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14684 e_type - NT_NETBSDCORE_FIRSTMACH);
14688 static const char *
14689 get_stapsdt_note_type (unsigned e_type)
14691 static char buff[64];
14696 return _("NT_STAPSDT (SystemTap probe descriptors)");
14702 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14707 print_stapsdt_note (Elf_Internal_Note *pnote)
14709 int addr_size = is_32bit_elf ? 4 : 8;
14710 char *data = pnote->descdata;
14711 char *data_end = pnote->descdata + pnote->descsz;
14712 bfd_vma pc, base_addr, semaphore;
14713 char *provider, *probe, *arg_fmt;
14715 pc = byte_get ((unsigned char *) data, addr_size);
14717 base_addr = byte_get ((unsigned char *) data, addr_size);
14719 semaphore = byte_get ((unsigned char *) data, addr_size);
14723 data += strlen (data) + 1;
14725 data += strlen (data) + 1;
14727 data += strlen (data) + 1;
14729 printf (_(" Provider: %s\n"), provider);
14730 printf (_(" Name: %s\n"), probe);
14731 printf (_(" Location: "));
14732 print_vma (pc, FULL_HEX);
14733 printf (_(", Base: "));
14734 print_vma (base_addr, FULL_HEX);
14735 printf (_(", Semaphore: "));
14736 print_vma (semaphore, FULL_HEX);
14738 printf (_(" Arguments: %s\n"), arg_fmt);
14740 return data == data_end;
14743 static const char *
14744 get_ia64_vms_note_type (unsigned e_type)
14746 static char buff[64];
14751 return _("NT_VMS_MHD (module header)");
14753 return _("NT_VMS_LNM (language name)");
14755 return _("NT_VMS_SRC (source files)");
14757 return "NT_VMS_TITLE";
14759 return _("NT_VMS_EIDC (consistency check)");
14760 case NT_VMS_FPMODE:
14761 return _("NT_VMS_FPMODE (FP mode)");
14762 case NT_VMS_LINKTIME:
14763 return "NT_VMS_LINKTIME";
14764 case NT_VMS_IMGNAM:
14765 return _("NT_VMS_IMGNAM (image name)");
14767 return _("NT_VMS_IMGID (image id)");
14768 case NT_VMS_LINKID:
14769 return _("NT_VMS_LINKID (link id)");
14770 case NT_VMS_IMGBID:
14771 return _("NT_VMS_IMGBID (build id)");
14772 case NT_VMS_GSTNAM:
14773 return _("NT_VMS_GSTNAM (sym table name)");
14774 case NT_VMS_ORIG_DYN:
14775 return "NT_VMS_ORIG_DYN";
14776 case NT_VMS_PATCHTIME:
14777 return "NT_VMS_PATCHTIME";
14779 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14785 print_ia64_vms_note (Elf_Internal_Note * pnote)
14787 switch (pnote->type)
14790 if (pnote->descsz > 36)
14792 size_t l = strlen (pnote->descdata + 34);
14793 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14794 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14795 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14796 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14799 printf (_(" Invalid size\n"));
14802 printf (_(" Language: %s\n"), pnote->descdata);
14805 case NT_VMS_FPMODE:
14806 printf (_(" Floating Point mode: "));
14807 printf ("0x%016" BFD_VMA_FMT "x\n",
14808 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14810 case NT_VMS_LINKTIME:
14811 printf (_(" Link time: "));
14813 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14816 case NT_VMS_PATCHTIME:
14817 printf (_(" Patch time: "));
14819 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14822 case NT_VMS_ORIG_DYN:
14823 printf (_(" Major id: %u, minor id: %u\n"),
14824 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14825 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14826 printf (_(" Last modified : "));
14828 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14829 printf (_("\n Link flags : "));
14830 printf ("0x%016" BFD_VMA_FMT "x\n",
14831 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14832 printf (_(" Header flags: 0x%08x\n"),
14833 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14834 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14837 case NT_VMS_IMGNAM:
14838 printf (_(" Image name: %s\n"), pnote->descdata);
14840 case NT_VMS_GSTNAM:
14841 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14844 printf (_(" Image id: %s\n"), pnote->descdata);
14846 case NT_VMS_LINKID:
14847 printf (_(" Linker id: %s\n"), pnote->descdata);
14855 /* Note that by the ELF standard, the name field is already null byte
14856 terminated, and namesz includes the terminating null byte.
14857 I.E. the value of namesz for the name "FSF" is 4.
14859 If the value of namesz is zero, there is no name present. */
14861 process_note (Elf_Internal_Note * pnote)
14863 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14866 if (pnote->namesz == 0)
14867 /* If there is no note name, then use the default set of
14868 note type strings. */
14869 nt = get_note_type (pnote->type);
14871 else if (const_strneq (pnote->namedata, "GNU"))
14872 /* GNU-specific object file notes. */
14873 nt = get_gnu_elf_note_type (pnote->type);
14875 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14876 /* NetBSD-specific core file notes. */
14877 nt = get_netbsd_elfcore_note_type (pnote->type);
14879 else if (strneq (pnote->namedata, "SPU/", 4))
14881 /* SPU-specific core file notes. */
14882 nt = pnote->namedata + 4;
14886 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14887 /* VMS/ia64-specific file notes. */
14888 nt = get_ia64_vms_note_type (pnote->type);
14890 else if (const_strneq (pnote->namedata, "stapsdt"))
14891 nt = get_stapsdt_note_type (pnote->type);
14894 /* Don't recognize this note name; just use the default set of
14895 note type strings. */
14896 nt = get_note_type (pnote->type);
14898 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14900 if (const_strneq (pnote->namedata, "IPF/VMS"))
14901 return print_ia64_vms_note (pnote);
14902 else if (const_strneq (pnote->namedata, "GNU"))
14903 return print_gnu_note (pnote);
14904 else if (const_strneq (pnote->namedata, "stapsdt"))
14905 return print_stapsdt_note (pnote);
14906 else if (const_strneq (pnote->namedata, "CORE"))
14907 return print_core_note (pnote);
14914 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14916 Elf_External_Note * pnotes;
14917 Elf_External_Note * external;
14923 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14925 if (pnotes == NULL)
14930 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14931 (unsigned long) offset, (unsigned long) length);
14932 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14934 while ((char *) external < (char *) pnotes + length)
14936 Elf_Internal_Note inote;
14939 char * temp = NULL;
14940 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14942 if (!is_ia64_vms ())
14944 /* PR binutils/15191
14945 Make sure that there is enough data to read. */
14946 min_notesz = offsetof (Elf_External_Note, name);
14947 if (data_remaining < min_notesz)
14949 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14950 (int) data_remaining);
14953 inote.type = BYTE_GET (external->type);
14954 inote.namesz = BYTE_GET (external->namesz);
14955 inote.namedata = external->name;
14956 inote.descsz = BYTE_GET (external->descsz);
14957 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14958 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14959 next = inote.descdata + align_power (inote.descsz, 2);
14963 Elf64_External_VMS_Note *vms_external;
14965 /* PR binutils/15191
14966 Make sure that there is enough data to read. */
14967 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14968 if (data_remaining < min_notesz)
14970 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14971 (int) data_remaining);
14975 vms_external = (Elf64_External_VMS_Note *) external;
14976 inote.type = BYTE_GET (vms_external->type);
14977 inote.namesz = BYTE_GET (vms_external->namesz);
14978 inote.namedata = vms_external->name;
14979 inote.descsz = BYTE_GET (vms_external->descsz);
14980 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14981 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14982 next = inote.descdata + align_power (inote.descsz, 3);
14985 if (inote.descdata < (char *) external + min_notesz
14986 || next < (char *) external + min_notesz
14987 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14988 || inote.namedata + inote.namesz < inote.namedata
14989 || inote.descdata + inote.descsz < inote.descdata
14990 || data_remaining < (size_t)(next - (char *) external))
14992 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14993 (unsigned long) ((char *) external - (char *) pnotes));
14994 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14995 inote.type, inote.namesz, inote.descsz);
14999 external = (Elf_External_Note *) next;
15001 /* Verify that name is null terminated. It appears that at least
15002 one version of Linux (RedHat 6.0) generates corefiles that don't
15003 comply with the ELF spec by failing to include the null byte in
15005 if (inote.namedata[inote.namesz - 1] != '\0')
15007 temp = (char *) malloc (inote.namesz + 1);
15010 error (_("Out of memory allocating space for inote name\n"));
15015 strncpy (temp, inote.namedata, inote.namesz);
15016 temp[inote.namesz] = 0;
15018 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15019 inote.namedata = temp;
15022 res &= process_note (& inote);
15037 process_corefile_note_segments (FILE * file)
15039 Elf_Internal_Phdr * segment;
15043 if (! get_program_headers (file))
15046 for (i = 0, segment = program_headers;
15047 i < elf_header.e_phnum;
15050 if (segment->p_type == PT_NOTE)
15051 res &= process_corefile_note_segment (file,
15052 (bfd_vma) segment->p_offset,
15053 (bfd_vma) segment->p_filesz);
15060 process_note_sections (FILE * file)
15062 Elf_Internal_Shdr * section;
15067 for (i = 0, section = section_headers;
15068 i < elf_header.e_shnum && section != NULL;
15070 if (section->sh_type == SHT_NOTE)
15072 res &= process_corefile_note_segment (file,
15073 (bfd_vma) section->sh_offset,
15074 (bfd_vma) section->sh_size);
15079 /* Try processing NOTE segments instead. */
15080 return process_corefile_note_segments (file);
15086 process_notes (FILE * file)
15088 /* If we have not been asked to display the notes then do nothing. */
15092 if (elf_header.e_type != ET_CORE)
15093 return process_note_sections (file);
15095 /* No program headers means no NOTE segment. */
15096 if (elf_header.e_phnum > 0)
15097 return process_corefile_note_segments (file);
15099 printf (_("No note segments present in the core file.\n"));
15104 process_arch_specific (FILE * file)
15109 switch (elf_header.e_machine)
15112 return process_arm_specific (file);
15114 case EM_MIPS_RS3_LE:
15115 return process_mips_specific (file);
15118 return process_nds32_specific (file);
15121 return process_power_specific (file);
15124 case EM_SPARC32PLUS:
15126 return process_sparc_specific (file);
15129 return process_tic6x_specific (file);
15132 return process_msp430x_specific (file);
15140 get_file_header (FILE * file)
15142 /* Read in the identity array. */
15143 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15146 /* Determine how to read the rest of the header. */
15147 switch (elf_header.e_ident[EI_DATA])
15149 default: /* fall through */
15150 case ELFDATANONE: /* fall through */
15152 byte_get = byte_get_little_endian;
15153 byte_put = byte_put_little_endian;
15156 byte_get = byte_get_big_endian;
15157 byte_put = byte_put_big_endian;
15161 /* For now we only support 32 bit and 64 bit ELF files. */
15162 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15164 /* Read in the rest of the header. */
15167 Elf32_External_Ehdr ehdr32;
15169 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15172 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15173 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15174 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15175 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15176 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15177 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15178 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15179 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15180 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15181 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15182 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15183 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15184 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15188 Elf64_External_Ehdr ehdr64;
15190 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15191 we will not be able to cope with the 64bit data found in
15192 64 ELF files. Detect this now and abort before we start
15193 overwriting things. */
15194 if (sizeof (bfd_vma) < 8)
15196 error (_("This instance of readelf has been built without support for a\n\
15197 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15201 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15204 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15205 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15206 elf_header.e_version = BYTE_GET (ehdr64.e_version);
15207 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15208 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15209 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
15210 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15211 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15212 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15213 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15214 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15215 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15216 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15219 if (elf_header.e_shoff)
15221 /* There may be some extensions in the first section header. Don't
15222 bomb if we can't read it. */
15224 get_32bit_section_headers (file, TRUE);
15226 get_64bit_section_headers (file, TRUE);
15232 /* Process one ELF object file according to the command line options.
15233 This file may actually be stored in an archive. The file is
15234 positioned at the start of the ELF object. */
15237 process_object (char * file_name, FILE * file)
15241 if (! get_file_header (file))
15243 error (_("%s: Failed to read file header\n"), file_name);
15247 /* Initialise per file variables. */
15248 for (i = ARRAY_SIZE (version_info); i--;)
15249 version_info[i] = 0;
15251 for (i = ARRAY_SIZE (dynamic_info); i--;)
15252 dynamic_info[i] = 0;
15253 dynamic_info_DT_GNU_HASH = 0;
15255 /* Process the file. */
15257 printf (_("\nFile: %s\n"), file_name);
15259 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15260 Note we do this even if cmdline_dump_sects is empty because we
15261 must make sure that the dump_sets array is zeroed out before each
15262 object file is processed. */
15263 if (num_dump_sects > num_cmdline_dump_sects)
15264 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15266 if (num_cmdline_dump_sects > 0)
15268 if (num_dump_sects == 0)
15269 /* A sneaky way of allocating the dump_sects array. */
15270 request_dump_bynumber (num_cmdline_dump_sects, 0);
15272 assert (num_dump_sects >= num_cmdline_dump_sects);
15273 memcpy (dump_sects, cmdline_dump_sects,
15274 num_cmdline_dump_sects * sizeof (* dump_sects));
15277 if (! process_file_header ())
15280 if (! process_section_headers (file))
15282 /* Without loaded section headers we cannot process lots of
15284 do_unwind = do_version = do_dump = do_arch = 0;
15286 if (! do_using_dynamic)
15287 do_syms = do_dyn_syms = do_reloc = 0;
15290 if (! process_section_groups (file))
15292 /* Without loaded section groups we cannot process unwind. */
15296 if (process_program_headers (file))
15297 process_dynamic_section (file);
15299 process_relocs (file);
15301 process_unwind (file);
15303 process_symbol_table (file);
15305 process_syminfo (file);
15307 process_version_sections (file);
15309 process_section_contents (file);
15311 process_notes (file);
15313 process_gnu_liblist (file);
15315 process_arch_specific (file);
15317 if (program_headers)
15319 free (program_headers);
15320 program_headers = NULL;
15323 if (section_headers)
15325 free (section_headers);
15326 section_headers = NULL;
15331 free (string_table);
15332 string_table = NULL;
15333 string_table_length = 0;
15336 if (dynamic_strings)
15338 free (dynamic_strings);
15339 dynamic_strings = NULL;
15340 dynamic_strings_length = 0;
15343 if (dynamic_symbols)
15345 free (dynamic_symbols);
15346 dynamic_symbols = NULL;
15347 num_dynamic_syms = 0;
15350 if (dynamic_syminfo)
15352 free (dynamic_syminfo);
15353 dynamic_syminfo = NULL;
15356 if (dynamic_section)
15358 free (dynamic_section);
15359 dynamic_section = NULL;
15362 if (section_headers_groups)
15364 free (section_headers_groups);
15365 section_headers_groups = NULL;
15368 if (section_groups)
15370 struct group_list * g;
15371 struct group_list * next;
15373 for (i = 0; i < group_count; i++)
15375 for (g = section_groups [i].root; g != NULL; g = next)
15382 free (section_groups);
15383 section_groups = NULL;
15386 free_debug_memory ();
15391 /* Process an ELF archive.
15392 On entry the file is positioned just after the ARMAG string. */
15395 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15397 struct archive_info arch;
15398 struct archive_info nested_arch;
15404 /* The ARCH structure is used to hold information about this archive. */
15405 arch.file_name = NULL;
15407 arch.index_array = NULL;
15408 arch.sym_table = NULL;
15409 arch.longnames = NULL;
15411 /* The NESTED_ARCH structure is used as a single-item cache of information
15412 about a nested archive (when members of a thin archive reside within
15413 another regular archive file). */
15414 nested_arch.file_name = NULL;
15415 nested_arch.file = NULL;
15416 nested_arch.index_array = NULL;
15417 nested_arch.sym_table = NULL;
15418 nested_arch.longnames = NULL;
15420 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15426 if (do_archive_index)
15428 if (arch.sym_table == NULL)
15429 error (_("%s: unable to dump the index as none was found\n"), file_name);
15432 unsigned long i, l;
15433 unsigned long current_pos;
15435 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15436 file_name, (unsigned long) arch.index_num, arch.sym_size);
15437 current_pos = ftell (file);
15439 for (i = l = 0; i < arch.index_num; i++)
15441 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15443 char * member_name;
15445 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15447 if (member_name != NULL)
15449 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15451 if (qualified_name != NULL)
15453 printf (_("Contents of binary %s at offset "), qualified_name);
15454 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15456 free (qualified_name);
15461 if (l >= arch.sym_size)
15463 error (_("%s: end of the symbol table reached before the end of the index\n"),
15467 /* PR 17531: file: 0b6630b2. */
15468 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15469 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15472 if (arch.uses_64bit_indicies)
15477 if (l < arch.sym_size)
15478 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15479 file_name, arch.sym_size - l);
15481 if (fseek (file, current_pos, SEEK_SET) != 0)
15483 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15489 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15490 && !do_segments && !do_header && !do_dump && !do_version
15491 && !do_histogram && !do_debugging && !do_arch && !do_notes
15492 && !do_section_groups && !do_dyn_syms)
15494 ret = 0; /* Archive index only. */
15505 char * qualified_name;
15507 /* Read the next archive header. */
15508 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15510 error (_("%s: failed to seek to next archive header\n"), file_name);
15513 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15514 if (got != sizeof arch.arhdr)
15518 error (_("%s: failed to read archive header\n"), file_name);
15522 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15524 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15529 arch.next_arhdr_offset += sizeof arch.arhdr;
15531 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15532 if (archive_file_size & 01)
15533 ++archive_file_size;
15535 name = get_archive_member_name (&arch, &nested_arch);
15538 error (_("%s: bad archive file name\n"), file_name);
15542 namelen = strlen (name);
15544 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15545 if (qualified_name == NULL)
15547 error (_("%s: bad archive file name\n"), file_name);
15552 if (is_thin_archive && arch.nested_member_origin == 0)
15554 /* This is a proxy for an external member of a thin archive. */
15555 FILE * member_file;
15556 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15557 if (member_file_name == NULL)
15563 member_file = fopen (member_file_name, "rb");
15564 if (member_file == NULL)
15566 error (_("Input file '%s' is not readable.\n"), member_file_name);
15567 free (member_file_name);
15572 archive_file_offset = arch.nested_member_origin;
15574 ret |= process_object (qualified_name, member_file);
15576 fclose (member_file);
15577 free (member_file_name);
15579 else if (is_thin_archive)
15581 /* PR 15140: Allow for corrupt thin archives. */
15582 if (nested_arch.file == NULL)
15584 error (_("%s: contains corrupt thin archive: %s\n"),
15590 /* This is a proxy for a member of a nested archive. */
15591 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15593 /* The nested archive file will have been opened and setup by
15594 get_archive_member_name. */
15595 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15597 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15602 ret |= process_object (qualified_name, nested_arch.file);
15606 archive_file_offset = arch.next_arhdr_offset;
15607 arch.next_arhdr_offset += archive_file_size;
15609 ret |= process_object (qualified_name, file);
15612 if (dump_sects != NULL)
15616 num_dump_sects = 0;
15619 free (qualified_name);
15623 if (nested_arch.file != NULL)
15624 fclose (nested_arch.file);
15625 release_archive (&nested_arch);
15626 release_archive (&arch);
15632 process_file (char * file_name)
15635 struct stat statbuf;
15636 char armag[SARMAG];
15639 if (stat (file_name, &statbuf) < 0)
15641 if (errno == ENOENT)
15642 error (_("'%s': No such file\n"), file_name);
15644 error (_("Could not locate '%s'. System error message: %s\n"),
15645 file_name, strerror (errno));
15649 if (! S_ISREG (statbuf.st_mode))
15651 error (_("'%s' is not an ordinary file\n"), file_name);
15655 file = fopen (file_name, "rb");
15658 error (_("Input file '%s' is not readable.\n"), file_name);
15662 if (fread (armag, SARMAG, 1, file) != 1)
15664 error (_("%s: Failed to read file's magic number\n"), file_name);
15669 current_file_size = (bfd_size_type) statbuf.st_size;
15671 if (memcmp (armag, ARMAG, SARMAG) == 0)
15672 ret = process_archive (file_name, file, FALSE);
15673 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15674 ret = process_archive (file_name, file, TRUE);
15677 if (do_archive_index)
15678 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15682 archive_file_size = archive_file_offset = 0;
15683 ret = process_object (file_name, file);
15688 current_file_size = 0;
15692 #ifdef SUPPORT_DISASSEMBLY
15693 /* Needed by the i386 disassembler. For extra credit, someone could
15694 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15698 print_address (unsigned int addr, FILE * outfile)
15700 fprintf (outfile,"0x%8.8x", addr);
15703 /* Needed by the i386 disassembler. */
15705 db_task_printsym (unsigned int addr)
15707 print_address (addr, stderr);
15712 main (int argc, char ** argv)
15716 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15717 setlocale (LC_MESSAGES, "");
15719 #if defined (HAVE_SETLOCALE)
15720 setlocale (LC_CTYPE, "");
15722 bindtextdomain (PACKAGE, LOCALEDIR);
15723 textdomain (PACKAGE);
15725 expandargv (&argc, &argv);
15727 parse_args (argc, argv);
15729 if (num_dump_sects > 0)
15731 /* Make a copy of the dump_sects array. */
15732 cmdline_dump_sects = (dump_type *)
15733 malloc (num_dump_sects * sizeof (* dump_sects));
15734 if (cmdline_dump_sects == NULL)
15735 error (_("Out of memory allocating dump request table.\n"));
15738 memcpy (cmdline_dump_sects, dump_sects,
15739 num_dump_sects * sizeof (* dump_sects));
15740 num_cmdline_dump_sects = num_dump_sects;
15744 if (optind < (argc - 1))
15748 while (optind < argc)
15749 err |= process_file (argv[optind++]);
15751 if (dump_sects != NULL)
15753 if (cmdline_dump_sects != NULL)
15754 free (cmdline_dump_sects);