1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 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/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name = "readelf";
168 static unsigned long archive_file_offset;
169 static unsigned long archive_file_size;
170 static bfd_size_type current_file_size;
171 static unsigned long dynamic_addr;
172 static bfd_size_type dynamic_size;
173 static size_t dynamic_nent;
174 static char * dynamic_strings;
175 static unsigned long dynamic_strings_length;
176 static char * string_table;
177 static unsigned long string_table_length;
178 static unsigned long num_dynamic_syms;
179 static Elf_Internal_Sym * dynamic_symbols;
180 static Elf_Internal_Syminfo * dynamic_syminfo;
181 static unsigned long dynamic_syminfo_offset;
182 static unsigned int dynamic_syminfo_nent;
183 static char program_interpreter[PATH_MAX];
184 static bfd_vma dynamic_info[DT_ENCODING];
185 static bfd_vma dynamic_info_DT_GNU_HASH;
186 static bfd_vma version_info[16];
187 static Elf_Internal_Ehdr elf_header;
188 static Elf_Internal_Shdr * section_headers;
189 static Elf_Internal_Phdr * program_headers;
190 static Elf_Internal_Dyn * dynamic_section;
191 static Elf_Internal_Shdr * symtab_shndx_hdr;
192 static int show_name;
193 static int do_dynamic;
195 static int do_dyn_syms;
197 static int do_sections;
198 static int do_section_groups;
199 static int do_section_details;
200 static int do_segments;
201 static int do_unwind;
202 static int do_using_dynamic;
203 static int do_header;
205 static int do_version;
206 static int do_histogram;
207 static int do_debugging;
210 static int do_archive_index;
211 static int is_32bit_elf;
215 struct group_list * next;
216 unsigned int section_index;
221 struct group_list * root;
222 unsigned int group_index;
225 static size_t group_count;
226 static struct group * section_groups;
227 static struct group ** section_headers_groups;
230 /* Flag bits indicating particular types of dump. */
231 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
232 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
237 typedef unsigned char dump_type;
239 /* A linked list of the section names for which dumps were requested. */
240 struct dump_list_entry
244 struct dump_list_entry * next;
246 static struct dump_list_entry * dump_sects_byname;
248 /* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250 static dump_type * cmdline_dump_sects = NULL;
251 static unsigned int num_cmdline_dump_sects = 0;
253 /* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
258 static dump_type * dump_sects = NULL;
259 static unsigned int num_dump_sects = 0;
262 /* How to print a vma value. */
263 typedef enum print_mode
275 /* Versioned symbol info. */
276 enum versioned_symbol_info
283 static const char *get_symbol_version_string
284 (FILE *file, int is_dynsym, const char *strtab,
285 unsigned long int strtab_size, unsigned int si,
286 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
287 unsigned short *vna_other);
291 #define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
295 : string_table + (X)->sh_name))
297 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
299 #define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 #define REMOVE_ARCH_BITS(ADDR) \
311 if (elf_header.e_machine == EM_ARM) \
316 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
321 and REASON is not NULL then emit an error message using REASON as part of the
325 get_data (void * var, FILE * file, unsigned long offset, size_t size, size_t nmemb,
329 size_t amt = size * nmemb;
331 if (size == 0 || nmemb == 0)
334 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
335 attempting to allocate memory when the read is bound to fail. */
336 if (amt > current_file_size
337 || offset + archive_file_offset + amt > current_file_size)
340 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
341 (unsigned long) amt, reason);
345 if (fseek (file, archive_file_offset + offset, SEEK_SET))
348 error (_("Unable to seek to 0x%lx for %s\n"),
349 (unsigned long) archive_file_offset + offset, reason);
356 /* Check for overflow. */
357 if (nmemb < (~(size_t) 0 - 1) / size)
358 /* + 1 so that we can '\0' terminate invalid string table sections. */
359 mvar = malloc (size * nmemb + 1);
364 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
365 (unsigned long)(size * nmemb), reason);
369 ((char *) mvar)[amt] = '\0';
372 if (fread (mvar, size, nmemb, file) != nmemb)
375 error (_("Unable to read in 0x%lx bytes of %s\n"),
376 (unsigned long) amt, reason);
385 /* Print a VMA value. */
388 print_vma (bfd_vma vma, print_mode mode)
401 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
408 return printf ("%5" BFD_VMA_FMT "d", vma);
416 return nc + printf ("%" BFD_VMA_FMT "x", vma);
419 return printf ("%" BFD_VMA_FMT "d", vma);
422 return printf ("%" BFD_VMA_FMT "u", vma);
427 /* Display a symbol on stdout. Handles the display of control characters and
428 multibye characters (assuming the host environment supports them).
430 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
432 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
433 padding as necessary.
435 Returns the number of emitted characters. */
438 print_symbol (int width, const char *symbol)
440 bfd_boolean extra_padding = FALSE;
442 #ifdef HAVE_MBSTATE_T
449 /* Keep the width positive. This also helps. */
451 extra_padding = TRUE;
456 /* Set the remaining width to a very large value.
457 This simplifies the code below. */
458 width_remaining = INT_MAX;
460 width_remaining = width;
462 #ifdef HAVE_MBSTATE_T
463 /* Initialise the multibyte conversion state. */
464 memset (& state, 0, sizeof (state));
467 while (width_remaining)
470 const char c = *symbol++;
475 /* Do not print control characters directly as they can affect terminal
476 settings. Such characters usually appear in the names generated
477 by the assembler for local labels. */
480 if (width_remaining < 2)
483 printf ("^%c", c + 0x40);
484 width_remaining -= 2;
487 else if (ISPRINT (c))
495 #ifdef HAVE_MBSTATE_T
498 /* Let printf do the hard work of displaying multibyte characters. */
499 printf ("%.1s", symbol - 1);
503 #ifdef HAVE_MBSTATE_T
504 /* Try to find out how many bytes made up the character that was
505 just printed. Advance the symbol pointer past the bytes that
507 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
511 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
516 if (extra_padding && num_printed < width)
518 /* Fill in the remaining spaces. */
519 printf ("%-*s", width - num_printed, " ");
526 /* Returns a pointer to a static buffer containing a printable version of
527 the given section's name. Like print_symbol, except that it does not try
528 to print multibyte characters, it just interprets them as hex values. */
531 printable_section_name (Elf_Internal_Shdr * sec)
533 #define MAX_PRINT_SEC_NAME_LEN 128
534 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
535 const char * name = SECTION_NAME (sec);
536 char * buf = sec_name_buf;
538 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
540 while ((c = * name ++) != 0)
551 else if (ISPRINT (c))
558 static char hex[17] = "0123456789ABCDEF";
563 * buf ++ = hex[(c & 0xf0) >> 4];
564 * buf ++ = hex[c & 0x0f];
578 printable_section_name_from_index (unsigned long ndx)
580 if (ndx >= elf_header.e_shnum)
581 return _("<corrupt>");
583 return printable_section_name (section_headers + ndx);
586 /* Return a pointer to section NAME, or NULL if no such section exists. */
588 static Elf_Internal_Shdr *
589 find_section (const char * name)
593 for (i = 0; i < elf_header.e_shnum; i++)
594 if (streq (SECTION_NAME (section_headers + i), name))
595 return section_headers + i;
600 /* Return a pointer to a section containing ADDR, or NULL if no such
603 static Elf_Internal_Shdr *
604 find_section_by_address (bfd_vma addr)
608 for (i = 0; i < elf_header.e_shnum; i++)
610 Elf_Internal_Shdr *sec = section_headers + i;
611 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
618 static Elf_Internal_Shdr *
619 find_section_by_type (unsigned int type)
623 for (i = 0; i < elf_header.e_shnum; i++)
625 Elf_Internal_Shdr *sec = section_headers + i;
626 if (sec->sh_type == type)
633 /* Return a pointer to section NAME, or NULL if no such section exists,
634 restricted to the list of sections given in SET. */
636 static Elf_Internal_Shdr *
637 find_section_in_set (const char * name, unsigned int * set)
643 while ((i = *set++) > 0)
644 if (streq (SECTION_NAME (section_headers + i), name))
645 return section_headers + i;
648 return find_section (name);
651 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
654 static inline unsigned long
655 read_uleb128 (unsigned char *data,
656 unsigned int *length_return,
657 const unsigned char * const end)
659 return read_leb128 (data, length_return, FALSE, end);
662 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
663 This OS has so many departures from the ELF standard that we test it at
669 return elf_header.e_machine == EM_IA_64
670 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
673 /* Guess the relocation size commonly used by the specific machines. */
676 guess_is_rela (unsigned int e_machine)
680 /* Targets that use REL relocations. */
695 /* Targets that use RELA relocations. */
699 case EM_ADAPTEVA_EPIPHANY:
701 case EM_ALTERA_NIOS2:
720 case EM_LATTICEMICO32:
729 case EM_CYGNUS_MN10200:
731 case EM_CYGNUS_MN10300:
764 case EM_MICROBLAZE_OLD:
785 warn (_("Don't know about relocations on this machine architecture\n"));
791 slurp_rela_relocs (FILE * file,
792 unsigned long rel_offset,
793 unsigned long rel_size,
794 Elf_Internal_Rela ** relasp,
795 unsigned long * nrelasp)
797 Elf_Internal_Rela * relas;
803 Elf32_External_Rela * erelas;
805 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
806 rel_size, _("32-bit relocation data"));
810 nrelas = rel_size / sizeof (Elf32_External_Rela);
812 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
813 sizeof (Elf_Internal_Rela));
818 error (_("out of memory parsing relocs\n"));
822 for (i = 0; i < nrelas; i++)
824 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
825 relas[i].r_info = BYTE_GET (erelas[i].r_info);
826 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
833 Elf64_External_Rela * erelas;
835 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
836 rel_size, _("64-bit relocation data"));
840 nrelas = rel_size / sizeof (Elf64_External_Rela);
842 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
843 sizeof (Elf_Internal_Rela));
848 error (_("out of memory parsing relocs\n"));
852 for (i = 0; i < nrelas; i++)
854 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
855 relas[i].r_info = BYTE_GET (erelas[i].r_info);
856 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
858 /* The #ifdef BFD64 below is to prevent a compile time
859 warning. We know that if we do not have a 64 bit data
860 type that we will never execute this code anyway. */
862 if (elf_header.e_machine == EM_MIPS
863 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
865 /* In little-endian objects, r_info isn't really a
866 64-bit little-endian value: it has a 32-bit
867 little-endian symbol index followed by four
868 individual byte fields. Reorder INFO
870 bfd_vma inf = relas[i].r_info;
871 inf = (((inf & 0xffffffff) << 32)
872 | ((inf >> 56) & 0xff)
873 | ((inf >> 40) & 0xff00)
874 | ((inf >> 24) & 0xff0000)
875 | ((inf >> 8) & 0xff000000));
876 relas[i].r_info = inf;
889 slurp_rel_relocs (FILE * file,
890 unsigned long rel_offset,
891 unsigned long rel_size,
892 Elf_Internal_Rela ** relsp,
893 unsigned long * nrelsp)
895 Elf_Internal_Rela * rels;
901 Elf32_External_Rel * erels;
903 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
904 rel_size, _("32-bit relocation data"));
908 nrels = rel_size / sizeof (Elf32_External_Rel);
910 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
915 error (_("out of memory parsing relocs\n"));
919 for (i = 0; i < nrels; i++)
921 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
922 rels[i].r_info = BYTE_GET (erels[i].r_info);
923 rels[i].r_addend = 0;
930 Elf64_External_Rel * erels;
932 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
933 rel_size, _("64-bit relocation data"));
937 nrels = rel_size / sizeof (Elf64_External_Rel);
939 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
944 error (_("out of memory parsing relocs\n"));
948 for (i = 0; i < nrels; i++)
950 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
951 rels[i].r_info = BYTE_GET (erels[i].r_info);
952 rels[i].r_addend = 0;
954 /* The #ifdef BFD64 below is to prevent a compile time
955 warning. We know that if we do not have a 64 bit data
956 type that we will never execute this code anyway. */
958 if (elf_header.e_machine == EM_MIPS
959 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
961 /* In little-endian objects, r_info isn't really a
962 64-bit little-endian value: it has a 32-bit
963 little-endian symbol index followed by four
964 individual byte fields. Reorder INFO
966 bfd_vma inf = rels[i].r_info;
967 inf = (((inf & 0xffffffff) << 32)
968 | ((inf >> 56) & 0xff)
969 | ((inf >> 40) & 0xff00)
970 | ((inf >> 24) & 0xff0000)
971 | ((inf >> 8) & 0xff000000));
972 rels[i].r_info = inf;
984 /* Returns the reloc type extracted from the reloc info field. */
987 get_reloc_type (bfd_vma reloc_info)
990 return ELF32_R_TYPE (reloc_info);
992 switch (elf_header.e_machine)
995 /* Note: We assume that reloc_info has already been adjusted for us. */
996 return ELF64_MIPS_R_TYPE (reloc_info);
999 return ELF64_R_TYPE_ID (reloc_info);
1002 return ELF64_R_TYPE (reloc_info);
1006 /* Return the symbol index extracted from the reloc info field. */
1009 get_reloc_symindex (bfd_vma reloc_info)
1011 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1014 static inline bfd_boolean
1015 uses_msp430x_relocs (void)
1018 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1019 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1020 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1021 /* TI compiler uses ELFOSABI_NONE. */
1022 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1025 /* Display the contents of the relocation data found at the specified
1029 dump_relocations (FILE * file,
1030 unsigned long rel_offset,
1031 unsigned long rel_size,
1032 Elf_Internal_Sym * symtab,
1033 unsigned long nsyms,
1035 unsigned long strtablen,
1040 Elf_Internal_Rela * rels;
1042 if (is_rela == UNKNOWN)
1043 is_rela = guess_is_rela (elf_header.e_machine);
1047 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1052 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1061 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1063 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1068 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1070 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1078 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1080 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1085 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1087 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1091 for (i = 0; i < rel_size; i++)
1096 bfd_vma symtab_index;
1099 offset = rels[i].r_offset;
1100 inf = rels[i].r_info;
1102 type = get_reloc_type (inf);
1103 symtab_index = get_reloc_symindex (inf);
1107 printf ("%8.8lx %8.8lx ",
1108 (unsigned long) offset & 0xffffffff,
1109 (unsigned long) inf & 0xffffffff);
1113 #if BFD_HOST_64BIT_LONG
1115 ? "%16.16lx %16.16lx "
1116 : "%12.12lx %12.12lx ",
1118 #elif BFD_HOST_64BIT_LONG_LONG
1121 ? "%16.16llx %16.16llx "
1122 : "%12.12llx %12.12llx ",
1126 ? "%16.16I64x %16.16I64x "
1127 : "%12.12I64x %12.12I64x ",
1132 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1133 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1134 _bfd_int64_high (offset),
1135 _bfd_int64_low (offset),
1136 _bfd_int64_high (inf),
1137 _bfd_int64_low (inf));
1141 switch (elf_header.e_machine)
1148 rtype = elf_aarch64_reloc_type (type);
1152 case EM_CYGNUS_M32R:
1153 rtype = elf_m32r_reloc_type (type);
1158 rtype = elf_i386_reloc_type (type);
1163 rtype = elf_m68hc11_reloc_type (type);
1167 rtype = elf_m68k_reloc_type (type);
1171 rtype = elf_i960_reloc_type (type);
1176 rtype = elf_avr_reloc_type (type);
1179 case EM_OLD_SPARCV9:
1180 case EM_SPARC32PLUS:
1183 rtype = elf_sparc_reloc_type (type);
1187 rtype = elf_spu_reloc_type (type);
1191 rtype = v800_reloc_type (type);
1194 case EM_CYGNUS_V850:
1195 rtype = v850_reloc_type (type);
1199 case EM_CYGNUS_D10V:
1200 rtype = elf_d10v_reloc_type (type);
1204 case EM_CYGNUS_D30V:
1205 rtype = elf_d30v_reloc_type (type);
1209 rtype = elf_dlx_reloc_type (type);
1213 rtype = elf_sh_reloc_type (type);
1217 case EM_CYGNUS_MN10300:
1218 rtype = elf_mn10300_reloc_type (type);
1222 case EM_CYGNUS_MN10200:
1223 rtype = elf_mn10200_reloc_type (type);
1227 case EM_CYGNUS_FR30:
1228 rtype = elf_fr30_reloc_type (type);
1232 rtype = elf_frv_reloc_type (type);
1236 rtype = elf_mcore_reloc_type (type);
1240 rtype = elf_mmix_reloc_type (type);
1244 rtype = elf_moxie_reloc_type (type);
1248 if (uses_msp430x_relocs ())
1250 rtype = elf_msp430x_reloc_type (type);
1254 rtype = elf_msp430_reloc_type (type);
1258 rtype = elf_nds32_reloc_type (type);
1262 rtype = elf_ppc_reloc_type (type);
1266 rtype = elf_ppc64_reloc_type (type);
1270 case EM_MIPS_RS3_LE:
1271 rtype = elf_mips_reloc_type (type);
1275 rtype = elf_alpha_reloc_type (type);
1279 rtype = elf_arm_reloc_type (type);
1283 rtype = elf_arc_reloc_type (type);
1287 rtype = elf_hppa_reloc_type (type);
1293 rtype = elf_h8_reloc_type (type);
1297 rtype = elf_or1k_reloc_type (type);
1302 rtype = elf_pj_reloc_type (type);
1305 rtype = elf_ia64_reloc_type (type);
1309 rtype = elf_cris_reloc_type (type);
1313 rtype = elf_i860_reloc_type (type);
1319 rtype = elf_x86_64_reloc_type (type);
1323 rtype = i370_reloc_type (type);
1328 rtype = elf_s390_reloc_type (type);
1332 rtype = elf_score_reloc_type (type);
1336 rtype = elf_xstormy16_reloc_type (type);
1340 rtype = elf_crx_reloc_type (type);
1344 rtype = elf_vax_reloc_type (type);
1347 case EM_ADAPTEVA_EPIPHANY:
1348 rtype = elf_epiphany_reloc_type (type);
1353 rtype = elf_ip2k_reloc_type (type);
1357 rtype = elf_iq2000_reloc_type (type);
1362 rtype = elf_xtensa_reloc_type (type);
1365 case EM_LATTICEMICO32:
1366 rtype = elf_lm32_reloc_type (type);
1371 rtype = elf_m32c_reloc_type (type);
1375 rtype = elf_mt_reloc_type (type);
1379 rtype = elf_bfin_reloc_type (type);
1383 rtype = elf_mep_reloc_type (type);
1387 rtype = elf_cr16_reloc_type (type);
1391 case EM_MICROBLAZE_OLD:
1392 rtype = elf_microblaze_reloc_type (type);
1396 rtype = elf_rl78_reloc_type (type);
1400 rtype = elf_rx_reloc_type (type);
1404 rtype = elf_metag_reloc_type (type);
1409 rtype = elf_xc16x_reloc_type (type);
1413 rtype = elf_tic6x_reloc_type (type);
1417 rtype = elf_tilegx_reloc_type (type);
1421 rtype = elf_tilepro_reloc_type (type);
1425 rtype = elf_xgate_reloc_type (type);
1428 case EM_ALTERA_NIOS2:
1429 rtype = elf_nios2_reloc_type (type);
1434 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1436 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1438 if (elf_header.e_machine == EM_ALPHA
1440 && streq (rtype, "R_ALPHA_LITUSE")
1443 switch (rels[i].r_addend)
1445 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1446 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1447 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1448 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1449 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1450 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1451 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1452 default: rtype = NULL;
1455 printf (" (%s)", rtype);
1459 printf (_("<unknown addend: %lx>"),
1460 (unsigned long) rels[i].r_addend);
1463 else if (symtab_index)
1465 if (symtab == NULL || symtab_index >= nsyms)
1466 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1469 Elf_Internal_Sym * psym;
1470 const char * version_string;
1471 enum versioned_symbol_info sym_info;
1472 unsigned short vna_other;
1474 psym = symtab + symtab_index;
1477 = get_symbol_version_string (file, is_dynsym,
1486 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1490 unsigned int width = is_32bit_elf ? 8 : 14;
1492 /* Relocations against GNU_IFUNC symbols do not use the value
1493 of the symbol as the address to relocate against. Instead
1494 they invoke the function named by the symbol and use its
1495 result as the address for relocation.
1497 To indicate this to the user, do not display the value of
1498 the symbol in the "Symbols's Value" field. Instead show
1499 its name followed by () as a hint that the symbol is
1503 || psym->st_name == 0
1504 || psym->st_name >= strtablen)
1507 name = strtab + psym->st_name;
1509 len = print_symbol (width, name);
1511 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1513 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1517 print_vma (psym->st_value, LONG_HEX);
1519 printf (is_32bit_elf ? " " : " ");
1522 if (psym->st_name == 0)
1524 const char * sec_name = "<null>";
1527 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1529 if (psym->st_shndx < elf_header.e_shnum)
1530 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1531 else if (psym->st_shndx == SHN_ABS)
1533 else if (psym->st_shndx == SHN_COMMON)
1534 sec_name = "COMMON";
1535 else if ((elf_header.e_machine == EM_MIPS
1536 && psym->st_shndx == SHN_MIPS_SCOMMON)
1537 || (elf_header.e_machine == EM_TI_C6000
1538 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1539 sec_name = "SCOMMON";
1540 else if (elf_header.e_machine == EM_MIPS
1541 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1542 sec_name = "SUNDEF";
1543 else if ((elf_header.e_machine == EM_X86_64
1544 || elf_header.e_machine == EM_L1OM
1545 || elf_header.e_machine == EM_K1OM)
1546 && psym->st_shndx == SHN_X86_64_LCOMMON)
1547 sec_name = "LARGE_COMMON";
1548 else if (elf_header.e_machine == EM_IA_64
1549 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1550 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1551 sec_name = "ANSI_COM";
1552 else if (is_ia64_vms ()
1553 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1554 sec_name = "VMS_SYMVEC";
1557 sprintf (name_buf, "<section 0x%x>",
1558 (unsigned int) psym->st_shndx);
1559 sec_name = name_buf;
1562 print_symbol (22, sec_name);
1564 else if (strtab == NULL)
1565 printf (_("<string table index: %3ld>"), psym->st_name);
1566 else if (psym->st_name >= strtablen)
1567 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1570 print_symbol (22, strtab + psym->st_name);
1572 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1578 bfd_signed_vma off = rels[i].r_addend;
1581 printf (" - %" BFD_VMA_FMT "x", - off);
1583 printf (" + %" BFD_VMA_FMT "x", off);
1589 bfd_signed_vma off = rels[i].r_addend;
1591 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1593 printf ("-%" BFD_VMA_FMT "x", - off);
1595 printf ("%" BFD_VMA_FMT "x", off);
1598 if (elf_header.e_machine == EM_SPARCV9
1600 && streq (rtype, "R_SPARC_OLO10"))
1601 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1606 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1608 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1609 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1610 const char * rtype2 = elf_mips_reloc_type (type2);
1611 const char * rtype3 = elf_mips_reloc_type (type3);
1613 printf (" Type2: ");
1616 printf (_("unrecognized: %-7lx"),
1617 (unsigned long) type2 & 0xffffffff);
1619 printf ("%-17.17s", rtype2);
1621 printf ("\n Type3: ");
1624 printf (_("unrecognized: %-7lx"),
1625 (unsigned long) type3 & 0xffffffff);
1627 printf ("%-17.17s", rtype3);
1638 get_mips_dynamic_type (unsigned long type)
1642 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1643 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1644 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1645 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1646 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1647 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1648 case DT_MIPS_MSYM: return "MIPS_MSYM";
1649 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1650 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1651 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1652 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1653 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1654 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1655 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1656 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1657 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1658 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1659 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1660 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1661 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1662 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1663 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1664 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1665 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1666 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1667 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1668 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1669 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1670 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1671 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1672 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1673 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1674 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1675 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1676 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1677 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1678 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1679 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1680 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1681 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1682 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1683 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1684 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1685 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1686 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1693 get_sparc64_dynamic_type (unsigned long type)
1697 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1704 get_ppc_dynamic_type (unsigned long type)
1708 case DT_PPC_GOT: return "PPC_GOT";
1709 case DT_PPC_OPT: return "PPC_OPT";
1716 get_ppc64_dynamic_type (unsigned long type)
1720 case DT_PPC64_GLINK: return "PPC64_GLINK";
1721 case DT_PPC64_OPD: return "PPC64_OPD";
1722 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1723 case DT_PPC64_OPT: return "PPC64_OPT";
1730 get_parisc_dynamic_type (unsigned long type)
1734 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1735 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1736 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1737 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1738 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1739 case DT_HP_PREINIT: return "HP_PREINIT";
1740 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1741 case DT_HP_NEEDED: return "HP_NEEDED";
1742 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1743 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1744 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1745 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1746 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1747 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1748 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1749 case DT_HP_FILTERED: return "HP_FILTERED";
1750 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1751 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1752 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1753 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1754 case DT_PLT: return "PLT";
1755 case DT_PLT_SIZE: return "PLT_SIZE";
1756 case DT_DLT: return "DLT";
1757 case DT_DLT_SIZE: return "DLT_SIZE";
1764 get_ia64_dynamic_type (unsigned long type)
1768 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1769 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1770 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1771 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1772 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1773 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1774 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1775 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1776 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1777 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1778 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1779 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1780 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1781 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1782 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1783 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1784 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1785 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1786 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1787 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1788 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1789 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1790 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1791 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1792 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1793 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1794 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1795 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1796 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1797 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1798 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1805 get_alpha_dynamic_type (unsigned long type)
1809 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1816 get_score_dynamic_type (unsigned long type)
1820 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1821 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1822 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1823 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1824 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1825 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1832 get_tic6x_dynamic_type (unsigned long type)
1836 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1837 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1838 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1839 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1840 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1841 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1848 get_nios2_dynamic_type (unsigned long type)
1852 case DT_NIOS2_GP: return "NIOS2_GP";
1859 get_dynamic_type (unsigned long type)
1861 static char buff[64];
1865 case DT_NULL: return "NULL";
1866 case DT_NEEDED: return "NEEDED";
1867 case DT_PLTRELSZ: return "PLTRELSZ";
1868 case DT_PLTGOT: return "PLTGOT";
1869 case DT_HASH: return "HASH";
1870 case DT_STRTAB: return "STRTAB";
1871 case DT_SYMTAB: return "SYMTAB";
1872 case DT_RELA: return "RELA";
1873 case DT_RELASZ: return "RELASZ";
1874 case DT_RELAENT: return "RELAENT";
1875 case DT_STRSZ: return "STRSZ";
1876 case DT_SYMENT: return "SYMENT";
1877 case DT_INIT: return "INIT";
1878 case DT_FINI: return "FINI";
1879 case DT_SONAME: return "SONAME";
1880 case DT_RPATH: return "RPATH";
1881 case DT_SYMBOLIC: return "SYMBOLIC";
1882 case DT_REL: return "REL";
1883 case DT_RELSZ: return "RELSZ";
1884 case DT_RELENT: return "RELENT";
1885 case DT_PLTREL: return "PLTREL";
1886 case DT_DEBUG: return "DEBUG";
1887 case DT_TEXTREL: return "TEXTREL";
1888 case DT_JMPREL: return "JMPREL";
1889 case DT_BIND_NOW: return "BIND_NOW";
1890 case DT_INIT_ARRAY: return "INIT_ARRAY";
1891 case DT_FINI_ARRAY: return "FINI_ARRAY";
1892 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1893 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1894 case DT_RUNPATH: return "RUNPATH";
1895 case DT_FLAGS: return "FLAGS";
1897 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1898 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1900 case DT_CHECKSUM: return "CHECKSUM";
1901 case DT_PLTPADSZ: return "PLTPADSZ";
1902 case DT_MOVEENT: return "MOVEENT";
1903 case DT_MOVESZ: return "MOVESZ";
1904 case DT_FEATURE: return "FEATURE";
1905 case DT_POSFLAG_1: return "POSFLAG_1";
1906 case DT_SYMINSZ: return "SYMINSZ";
1907 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1909 case DT_ADDRRNGLO: return "ADDRRNGLO";
1910 case DT_CONFIG: return "CONFIG";
1911 case DT_DEPAUDIT: return "DEPAUDIT";
1912 case DT_AUDIT: return "AUDIT";
1913 case DT_PLTPAD: return "PLTPAD";
1914 case DT_MOVETAB: return "MOVETAB";
1915 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1917 case DT_VERSYM: return "VERSYM";
1919 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1920 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1921 case DT_RELACOUNT: return "RELACOUNT";
1922 case DT_RELCOUNT: return "RELCOUNT";
1923 case DT_FLAGS_1: return "FLAGS_1";
1924 case DT_VERDEF: return "VERDEF";
1925 case DT_VERDEFNUM: return "VERDEFNUM";
1926 case DT_VERNEED: return "VERNEED";
1927 case DT_VERNEEDNUM: return "VERNEEDNUM";
1929 case DT_AUXILIARY: return "AUXILIARY";
1930 case DT_USED: return "USED";
1931 case DT_FILTER: return "FILTER";
1933 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1934 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1935 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1936 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1937 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1938 case DT_GNU_HASH: return "GNU_HASH";
1941 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1943 const char * result;
1945 switch (elf_header.e_machine)
1948 case EM_MIPS_RS3_LE:
1949 result = get_mips_dynamic_type (type);
1952 result = get_sparc64_dynamic_type (type);
1955 result = get_ppc_dynamic_type (type);
1958 result = get_ppc64_dynamic_type (type);
1961 result = get_ia64_dynamic_type (type);
1964 result = get_alpha_dynamic_type (type);
1967 result = get_score_dynamic_type (type);
1970 result = get_tic6x_dynamic_type (type);
1972 case EM_ALTERA_NIOS2:
1973 result = get_nios2_dynamic_type (type);
1983 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1985 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1986 || (elf_header.e_machine == EM_PARISC
1987 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1989 const char * result;
1991 switch (elf_header.e_machine)
1994 result = get_parisc_dynamic_type (type);
1997 result = get_ia64_dynamic_type (type);
2007 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2011 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2018 get_file_type (unsigned e_type)
2020 static char buff[32];
2024 case ET_NONE: return _("NONE (None)");
2025 case ET_REL: return _("REL (Relocatable file)");
2026 case ET_EXEC: return _("EXEC (Executable file)");
2027 case ET_DYN: return _("DYN (Shared object file)");
2028 case ET_CORE: return _("CORE (Core file)");
2031 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2032 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2033 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2034 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2036 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2042 get_machine_name (unsigned e_machine)
2044 static char buff[64]; /* XXX */
2048 case EM_NONE: return _("None");
2049 case EM_AARCH64: return "AArch64";
2050 case EM_M32: return "WE32100";
2051 case EM_SPARC: return "Sparc";
2052 case EM_SPU: return "SPU";
2053 case EM_386: return "Intel 80386";
2054 case EM_68K: return "MC68000";
2055 case EM_88K: return "MC88000";
2056 case EM_486: return "Intel 80486";
2057 case EM_860: return "Intel 80860";
2058 case EM_MIPS: return "MIPS R3000";
2059 case EM_S370: return "IBM System/370";
2060 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2061 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2062 case EM_PARISC: return "HPPA";
2063 case EM_PPC_OLD: return "Power PC (old)";
2064 case EM_SPARC32PLUS: return "Sparc v8+" ;
2065 case EM_960: return "Intel 90860";
2066 case EM_PPC: return "PowerPC";
2067 case EM_PPC64: return "PowerPC64";
2068 case EM_FR20: return "Fujitsu FR20";
2069 case EM_RH32: return "TRW RH32";
2070 case EM_MCORE: return "MCORE";
2071 case EM_ARM: return "ARM";
2072 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2073 case EM_SH: return "Renesas / SuperH SH";
2074 case EM_SPARCV9: return "Sparc v9";
2075 case EM_TRICORE: return "Siemens Tricore";
2076 case EM_ARC: return "ARC";
2077 case EM_H8_300: return "Renesas H8/300";
2078 case EM_H8_300H: return "Renesas H8/300H";
2079 case EM_H8S: return "Renesas H8S";
2080 case EM_H8_500: return "Renesas H8/500";
2081 case EM_IA_64: return "Intel IA-64";
2082 case EM_MIPS_X: return "Stanford MIPS-X";
2083 case EM_COLDFIRE: return "Motorola Coldfire";
2084 case EM_ALPHA: return "Alpha";
2085 case EM_CYGNUS_D10V:
2086 case EM_D10V: return "d10v";
2087 case EM_CYGNUS_D30V:
2088 case EM_D30V: return "d30v";
2089 case EM_CYGNUS_M32R:
2090 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2091 case EM_CYGNUS_V850:
2092 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2093 case EM_V850: return "Renesas V850";
2094 case EM_CYGNUS_MN10300:
2095 case EM_MN10300: return "mn10300";
2096 case EM_CYGNUS_MN10200:
2097 case EM_MN10200: return "mn10200";
2098 case EM_MOXIE: return "Moxie";
2099 case EM_CYGNUS_FR30:
2100 case EM_FR30: return "Fujitsu FR30";
2101 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2103 case EM_PJ: return "picoJava";
2104 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2105 case EM_PCP: return "Siemens PCP";
2106 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2107 case EM_NDR1: return "Denso NDR1 microprocesspr";
2108 case EM_STARCORE: return "Motorola Star*Core processor";
2109 case EM_ME16: return "Toyota ME16 processor";
2110 case EM_ST100: return "STMicroelectronics ST100 processor";
2111 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2112 case EM_PDSP: return "Sony DSP processor";
2113 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2114 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2115 case EM_FX66: return "Siemens FX66 microcontroller";
2116 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2117 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2118 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2119 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2120 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2121 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2122 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2123 case EM_SVX: return "Silicon Graphics SVx";
2124 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2125 case EM_VAX: return "Digital VAX";
2127 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2128 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2129 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2130 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2131 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2132 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2133 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2134 case EM_PRISM: return "Vitesse Prism";
2135 case EM_X86_64: return "Advanced Micro Devices X86-64";
2136 case EM_L1OM: return "Intel L1OM";
2137 case EM_K1OM: return "Intel K1OM";
2139 case EM_S390: return "IBM S/390";
2140 case EM_SCORE: return "SUNPLUS S+Core";
2141 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2142 case EM_OR1K: return "OpenRISC 1000";
2143 case EM_ARC_A5: return "ARC International ARCompact processor";
2144 case EM_CRX: return "National Semiconductor CRX microprocessor";
2145 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2146 case EM_DLX: return "OpenDLX";
2148 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2149 case EM_IQ2000: return "Vitesse IQ2000";
2151 case EM_XTENSA: return "Tensilica Xtensa Processor";
2152 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2153 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2154 case EM_NS32K: return "National Semiconductor 32000 series";
2155 case EM_TPC: return "Tenor Network TPC processor";
2156 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2157 case EM_MAX: return "MAX Processor";
2158 case EM_CR: return "National Semiconductor CompactRISC";
2159 case EM_F2MC16: return "Fujitsu F2MC16";
2160 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2161 case EM_LATTICEMICO32: return "Lattice Mico32";
2163 case EM_M32C: return "Renesas M32c";
2164 case EM_MT: return "Morpho Techologies MT processor";
2165 case EM_BLACKFIN: return "Analog Devices Blackfin";
2166 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2167 case EM_SEP: return "Sharp embedded microprocessor";
2168 case EM_ARCA: return "Arca RISC microprocessor";
2169 case EM_UNICORE: return "Unicore";
2170 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2171 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2172 case EM_NIOS32: return "Altera Nios";
2173 case EM_ALTERA_NIOS2: return "Altera Nios II";
2175 case EM_XC16X: return "Infineon Technologies xc16x";
2176 case EM_M16C: return "Renesas M16C series microprocessors";
2177 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2178 case EM_CE: return "Freescale Communication Engine RISC core";
2179 case EM_TSK3000: return "Altium TSK3000 core";
2180 case EM_RS08: return "Freescale RS08 embedded processor";
2181 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2182 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2183 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2184 case EM_SE_C17: return "Seiko Epson C17 family";
2185 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2186 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2187 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2188 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2189 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2190 case EM_R32C: return "Renesas R32C series microprocessors";
2191 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2192 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2193 case EM_8051: return "Intel 8051 and variants";
2194 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2195 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2196 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2197 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2198 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2199 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2200 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2201 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2204 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2205 case EM_RL78: return "Renesas RL78";
2206 case EM_RX: return "Renesas RX";
2207 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2208 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2209 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2210 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2211 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2212 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2213 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2214 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2215 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2216 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2217 case EM_CUDA: return "NVIDIA CUDA architecture";
2218 case EM_XGATE: return "Motorola XGATE embedded processor";
2220 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2226 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2231 eabi = EF_ARM_EABI_VERSION (e_flags);
2232 e_flags &= ~ EF_ARM_EABIMASK;
2234 /* Handle "generic" ARM flags. */
2235 if (e_flags & EF_ARM_RELEXEC)
2237 strcat (buf, ", relocatable executable");
2238 e_flags &= ~ EF_ARM_RELEXEC;
2241 if (e_flags & EF_ARM_HASENTRY)
2243 strcat (buf, ", has entry point");
2244 e_flags &= ~ EF_ARM_HASENTRY;
2247 /* Now handle EABI specific flags. */
2251 strcat (buf, ", <unrecognized EABI>");
2256 case EF_ARM_EABI_VER1:
2257 strcat (buf, ", Version1 EABI");
2262 /* Process flags one bit at a time. */
2263 flag = e_flags & - e_flags;
2268 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2269 strcat (buf, ", sorted symbol tables");
2279 case EF_ARM_EABI_VER2:
2280 strcat (buf, ", Version2 EABI");
2285 /* Process flags one bit at a time. */
2286 flag = e_flags & - e_flags;
2291 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2292 strcat (buf, ", sorted symbol tables");
2295 case EF_ARM_DYNSYMSUSESEGIDX:
2296 strcat (buf, ", dynamic symbols use segment index");
2299 case EF_ARM_MAPSYMSFIRST:
2300 strcat (buf, ", mapping symbols precede others");
2310 case EF_ARM_EABI_VER3:
2311 strcat (buf, ", Version3 EABI");
2314 case EF_ARM_EABI_VER4:
2315 strcat (buf, ", Version4 EABI");
2320 /* Process flags one bit at a time. */
2321 flag = e_flags & - e_flags;
2327 strcat (buf, ", BE8");
2331 strcat (buf, ", LE8");
2342 case EF_ARM_EABI_VER5:
2343 strcat (buf, ", Version5 EABI");
2348 /* Process flags one bit at a time. */
2349 flag = e_flags & - e_flags;
2355 strcat (buf, ", BE8");
2359 strcat (buf, ", LE8");
2362 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2363 strcat (buf, ", soft-float ABI");
2366 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2367 strcat (buf, ", hard-float ABI");
2377 case EF_ARM_EABI_UNKNOWN:
2378 strcat (buf, ", GNU EABI");
2383 /* Process flags one bit at a time. */
2384 flag = e_flags & - e_flags;
2389 case EF_ARM_INTERWORK:
2390 strcat (buf, ", interworking enabled");
2393 case EF_ARM_APCS_26:
2394 strcat (buf, ", uses APCS/26");
2397 case EF_ARM_APCS_FLOAT:
2398 strcat (buf, ", uses APCS/float");
2402 strcat (buf, ", position independent");
2406 strcat (buf, ", 8 bit structure alignment");
2409 case EF_ARM_NEW_ABI:
2410 strcat (buf, ", uses new ABI");
2413 case EF_ARM_OLD_ABI:
2414 strcat (buf, ", uses old ABI");
2417 case EF_ARM_SOFT_FLOAT:
2418 strcat (buf, ", software FP");
2421 case EF_ARM_VFP_FLOAT:
2422 strcat (buf, ", VFP");
2425 case EF_ARM_MAVERICK_FLOAT:
2426 strcat (buf, ", Maverick FP");
2437 strcat (buf,_(", <unknown>"));
2441 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2450 static const char *ABI_STRINGS[] =
2452 "ABI v0", /* use r5 as return register; only used in N1213HC */
2453 "ABI v1", /* use r0 as return register */
2454 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2455 "ABI v2fp", /* for FPU */
2459 static const char *VER_STRINGS[] =
2461 "Andes ELF V1.3 or older",
2465 static const char *ARCH_STRINGS[] =
2474 abi = EF_NDS_ABI & e_flags;
2475 arch = EF_NDS_ARCH & e_flags;
2476 config = EF_NDS_INST & e_flags;
2477 version = EF_NDS32_ELF_VERSION & e_flags;
2479 memset (buf, 0, size);
2486 case E_NDS_ABI_V2FP:
2487 case E_NDS_ABI_AABI:
2488 case E_NDS_ABI_V2FP_PLUS:
2489 /* In case there are holes in the array. */
2490 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2494 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2500 case E_NDS32_ELF_VER_1_2:
2501 case E_NDS32_ELF_VER_1_3:
2502 case E_NDS32_ELF_VER_1_4:
2503 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2507 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2511 if (E_NDS_ABI_V0 == abi)
2513 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2514 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2515 if (arch == E_NDS_ARCH_STAR_V1_0)
2516 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2522 case E_NDS_ARCH_STAR_V1_0:
2523 case E_NDS_ARCH_STAR_V2_0:
2524 case E_NDS_ARCH_STAR_V3_0:
2525 case E_NDS_ARCH_STAR_V3_M:
2526 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2530 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2531 /* ARCH version determines how the e_flags are interpreted.
2532 If it is unknown, we cannot proceed. */
2536 /* Newer ABI; Now handle architecture specific flags. */
2537 if (arch == E_NDS_ARCH_STAR_V1_0)
2539 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2540 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2542 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2543 r += snprintf (buf + r, size -r, ", MAC");
2545 if (config & E_NDS32_HAS_DIV_INST)
2546 r += snprintf (buf + r, size -r, ", DIV");
2548 if (config & E_NDS32_HAS_16BIT_INST)
2549 r += snprintf (buf + r, size -r, ", 16b");
2553 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2555 if (version <= E_NDS32_ELF_VER_1_3)
2556 r += snprintf (buf + r, size -r, ", [B8]");
2558 r += snprintf (buf + r, size -r, ", EX9");
2561 if (config & E_NDS32_HAS_MAC_DX_INST)
2562 r += snprintf (buf + r, size -r, ", MAC_DX");
2564 if (config & E_NDS32_HAS_DIV_DX_INST)
2565 r += snprintf (buf + r, size -r, ", DIV_DX");
2567 if (config & E_NDS32_HAS_16BIT_INST)
2569 if (version <= E_NDS32_ELF_VER_1_3)
2570 r += snprintf (buf + r, size -r, ", 16b");
2572 r += snprintf (buf + r, size -r, ", IFC");
2576 if (config & E_NDS32_HAS_EXT_INST)
2577 r += snprintf (buf + r, size -r, ", PERF1");
2579 if (config & E_NDS32_HAS_EXT2_INST)
2580 r += snprintf (buf + r, size -r, ", PERF2");
2582 if (config & E_NDS32_HAS_FPU_INST)
2585 r += snprintf (buf + r, size -r, ", FPU_SP");
2588 if (config & E_NDS32_HAS_FPU_DP_INST)
2591 r += snprintf (buf + r, size -r, ", FPU_DP");
2594 if (config & E_NDS32_HAS_FPU_MAC_INST)
2597 r += snprintf (buf + r, size -r, ", FPU_MAC");
2602 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2604 case E_NDS32_FPU_REG_8SP_4DP:
2605 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2607 case E_NDS32_FPU_REG_16SP_8DP:
2608 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2610 case E_NDS32_FPU_REG_32SP_16DP:
2611 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2613 case E_NDS32_FPU_REG_32SP_32DP:
2614 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2619 if (config & E_NDS32_HAS_AUDIO_INST)
2620 r += snprintf (buf + r, size -r, ", AUDIO");
2622 if (config & E_NDS32_HAS_STRING_INST)
2623 r += snprintf (buf + r, size -r, ", STR");
2625 if (config & E_NDS32_HAS_REDUCED_REGS)
2626 r += snprintf (buf + r, size -r, ", 16REG");
2628 if (config & E_NDS32_HAS_VIDEO_INST)
2630 if (version <= E_NDS32_ELF_VER_1_3)
2631 r += snprintf (buf + r, size -r, ", VIDEO");
2633 r += snprintf (buf + r, size -r, ", SATURATION");
2636 if (config & E_NDS32_HAS_ENCRIPT_INST)
2637 r += snprintf (buf + r, size -r, ", ENCRP");
2639 if (config & E_NDS32_HAS_L2C_INST)
2640 r += snprintf (buf + r, size -r, ", L2C");
2644 get_machine_flags (unsigned e_flags, unsigned e_machine)
2646 static char buf[1024];
2658 decode_ARM_machine_flags (e_flags, buf);
2662 if (e_flags & EF_BFIN_PIC)
2663 strcat (buf, ", PIC");
2665 if (e_flags & EF_BFIN_FDPIC)
2666 strcat (buf, ", FDPIC");
2668 if (e_flags & EF_BFIN_CODE_IN_L1)
2669 strcat (buf, ", code in L1");
2671 if (e_flags & EF_BFIN_DATA_IN_L1)
2672 strcat (buf, ", data in L1");
2677 switch (e_flags & EF_FRV_CPU_MASK)
2679 case EF_FRV_CPU_GENERIC:
2683 strcat (buf, ", fr???");
2686 case EF_FRV_CPU_FR300:
2687 strcat (buf, ", fr300");
2690 case EF_FRV_CPU_FR400:
2691 strcat (buf, ", fr400");
2693 case EF_FRV_CPU_FR405:
2694 strcat (buf, ", fr405");
2697 case EF_FRV_CPU_FR450:
2698 strcat (buf, ", fr450");
2701 case EF_FRV_CPU_FR500:
2702 strcat (buf, ", fr500");
2704 case EF_FRV_CPU_FR550:
2705 strcat (buf, ", fr550");
2708 case EF_FRV_CPU_SIMPLE:
2709 strcat (buf, ", simple");
2711 case EF_FRV_CPU_TOMCAT:
2712 strcat (buf, ", tomcat");
2718 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2719 strcat (buf, ", m68000");
2720 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2721 strcat (buf, ", cpu32");
2722 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2723 strcat (buf, ", fido_a");
2726 char const * isa = _("unknown");
2727 char const * mac = _("unknown mac");
2728 char const * additional = NULL;
2730 switch (e_flags & EF_M68K_CF_ISA_MASK)
2732 case EF_M68K_CF_ISA_A_NODIV:
2734 additional = ", nodiv";
2736 case EF_M68K_CF_ISA_A:
2739 case EF_M68K_CF_ISA_A_PLUS:
2742 case EF_M68K_CF_ISA_B_NOUSP:
2744 additional = ", nousp";
2746 case EF_M68K_CF_ISA_B:
2749 case EF_M68K_CF_ISA_C:
2752 case EF_M68K_CF_ISA_C_NODIV:
2754 additional = ", nodiv";
2757 strcat (buf, ", cf, isa ");
2760 strcat (buf, additional);
2761 if (e_flags & EF_M68K_CF_FLOAT)
2762 strcat (buf, ", float");
2763 switch (e_flags & EF_M68K_CF_MAC_MASK)
2768 case EF_M68K_CF_MAC:
2771 case EF_M68K_CF_EMAC:
2774 case EF_M68K_CF_EMAC_B:
2787 if (e_flags & EF_PPC_EMB)
2788 strcat (buf, ", emb");
2790 if (e_flags & EF_PPC_RELOCATABLE)
2791 strcat (buf, _(", relocatable"));
2793 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2794 strcat (buf, _(", relocatable-lib"));
2798 if (e_flags & EF_PPC64_ABI)
2800 char abi[] = ", abiv0";
2802 abi[6] += e_flags & EF_PPC64_ABI;
2808 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2809 strcat (buf, ", RH850 ABI");
2811 if (e_flags & EF_V800_850E3)
2812 strcat (buf, ", V3 architecture");
2814 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2815 strcat (buf, ", FPU not used");
2817 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2818 strcat (buf, ", regmode: COMMON");
2820 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2821 strcat (buf, ", r4 not used");
2823 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2824 strcat (buf, ", r30 not used");
2826 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2827 strcat (buf, ", r5 not used");
2829 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2830 strcat (buf, ", r2 not used");
2832 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2834 switch (e_flags & - e_flags)
2836 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2837 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2838 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2839 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2840 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2841 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2842 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2843 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2844 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2845 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2846 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2847 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2848 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2849 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2850 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2851 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2858 case EM_CYGNUS_V850:
2859 switch (e_flags & EF_V850_ARCH)
2861 case E_V850E3V5_ARCH:
2862 strcat (buf, ", v850e3v5");
2864 case E_V850E2V3_ARCH:
2865 strcat (buf, ", v850e2v3");
2868 strcat (buf, ", v850e2");
2871 strcat (buf, ", v850e1");
2874 strcat (buf, ", v850e");
2877 strcat (buf, ", v850");
2880 strcat (buf, _(", unknown v850 architecture variant"));
2886 case EM_CYGNUS_M32R:
2887 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2888 strcat (buf, ", m32r");
2892 case EM_MIPS_RS3_LE:
2893 if (e_flags & EF_MIPS_NOREORDER)
2894 strcat (buf, ", noreorder");
2896 if (e_flags & EF_MIPS_PIC)
2897 strcat (buf, ", pic");
2899 if (e_flags & EF_MIPS_CPIC)
2900 strcat (buf, ", cpic");
2902 if (e_flags & EF_MIPS_UCODE)
2903 strcat (buf, ", ugen_reserved");
2905 if (e_flags & EF_MIPS_ABI2)
2906 strcat (buf, ", abi2");
2908 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2909 strcat (buf, ", odk first");
2911 if (e_flags & EF_MIPS_32BITMODE)
2912 strcat (buf, ", 32bitmode");
2914 if (e_flags & EF_MIPS_NAN2008)
2915 strcat (buf, ", nan2008");
2917 if (e_flags & EF_MIPS_FP64)
2918 strcat (buf, ", fp64");
2920 switch ((e_flags & EF_MIPS_MACH))
2922 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2923 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2924 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2925 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2926 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2927 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2928 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2929 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2930 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2931 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2932 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2933 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2934 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2935 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2936 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2937 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2938 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2940 /* We simply ignore the field in this case to avoid confusion:
2941 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2944 default: strcat (buf, _(", unknown CPU")); break;
2947 switch ((e_flags & EF_MIPS_ABI))
2949 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2950 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2951 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2952 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2954 /* We simply ignore the field in this case to avoid confusion:
2955 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2956 This means it is likely to be an o32 file, but not for
2959 default: strcat (buf, _(", unknown ABI")); break;
2962 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2963 strcat (buf, ", mdmx");
2965 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2966 strcat (buf, ", mips16");
2968 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2969 strcat (buf, ", micromips");
2971 switch ((e_flags & EF_MIPS_ARCH))
2973 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2974 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2975 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2976 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2977 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2978 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2979 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2980 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
2981 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2982 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2983 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2984 default: strcat (buf, _(", unknown ISA")); break;
2989 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2993 switch ((e_flags & EF_SH_MACH_MASK))
2995 case EF_SH1: strcat (buf, ", sh1"); break;
2996 case EF_SH2: strcat (buf, ", sh2"); break;
2997 case EF_SH3: strcat (buf, ", sh3"); break;
2998 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2999 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3000 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3001 case EF_SH3E: strcat (buf, ", sh3e"); break;
3002 case EF_SH4: strcat (buf, ", sh4"); break;
3003 case EF_SH5: strcat (buf, ", sh5"); break;
3004 case EF_SH2E: strcat (buf, ", sh2e"); break;
3005 case EF_SH4A: strcat (buf, ", sh4a"); break;
3006 case EF_SH2A: strcat (buf, ", sh2a"); break;
3007 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3008 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3009 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3010 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3011 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3012 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3013 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3014 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3015 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3016 default: strcat (buf, _(", unknown ISA")); break;
3019 if (e_flags & EF_SH_PIC)
3020 strcat (buf, ", pic");
3022 if (e_flags & EF_SH_FDPIC)
3023 strcat (buf, ", fdpic");
3027 if (e_flags & EF_OR1K_NODELAY)
3028 strcat (buf, ", no delay");
3032 if (e_flags & EF_SPARC_32PLUS)
3033 strcat (buf, ", v8+");
3035 if (e_flags & EF_SPARC_SUN_US1)
3036 strcat (buf, ", ultrasparcI");
3038 if (e_flags & EF_SPARC_SUN_US3)
3039 strcat (buf, ", ultrasparcIII");
3041 if (e_flags & EF_SPARC_HAL_R1)
3042 strcat (buf, ", halr1");
3044 if (e_flags & EF_SPARC_LEDATA)
3045 strcat (buf, ", ledata");
3047 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3048 strcat (buf, ", tso");
3050 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3051 strcat (buf, ", pso");
3053 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3054 strcat (buf, ", rmo");
3058 switch (e_flags & EF_PARISC_ARCH)
3060 case EFA_PARISC_1_0:
3061 strcpy (buf, ", PA-RISC 1.0");
3063 case EFA_PARISC_1_1:
3064 strcpy (buf, ", PA-RISC 1.1");
3066 case EFA_PARISC_2_0:
3067 strcpy (buf, ", PA-RISC 2.0");
3072 if (e_flags & EF_PARISC_TRAPNIL)
3073 strcat (buf, ", trapnil");
3074 if (e_flags & EF_PARISC_EXT)
3075 strcat (buf, ", ext");
3076 if (e_flags & EF_PARISC_LSB)
3077 strcat (buf, ", lsb");
3078 if (e_flags & EF_PARISC_WIDE)
3079 strcat (buf, ", wide");
3080 if (e_flags & EF_PARISC_NO_KABP)
3081 strcat (buf, ", no kabp");
3082 if (e_flags & EF_PARISC_LAZYSWAP)
3083 strcat (buf, ", lazyswap");
3088 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3089 strcat (buf, ", new calling convention");
3091 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3092 strcat (buf, ", gnu calling convention");
3096 if ((e_flags & EF_IA_64_ABI64))
3097 strcat (buf, ", 64-bit");
3099 strcat (buf, ", 32-bit");
3100 if ((e_flags & EF_IA_64_REDUCEDFP))
3101 strcat (buf, ", reduced fp model");
3102 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3103 strcat (buf, ", no function descriptors, constant gp");
3104 else if ((e_flags & EF_IA_64_CONS_GP))
3105 strcat (buf, ", constant gp");
3106 if ((e_flags & EF_IA_64_ABSOLUTE))
3107 strcat (buf, ", absolute");
3108 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3110 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3111 strcat (buf, ", vms_linkages");
3112 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3114 case EF_IA_64_VMS_COMCOD_SUCCESS:
3116 case EF_IA_64_VMS_COMCOD_WARNING:
3117 strcat (buf, ", warning");
3119 case EF_IA_64_VMS_COMCOD_ERROR:
3120 strcat (buf, ", error");
3122 case EF_IA_64_VMS_COMCOD_ABORT:
3123 strcat (buf, ", abort");
3132 if ((e_flags & EF_VAX_NONPIC))
3133 strcat (buf, ", non-PIC");
3134 if ((e_flags & EF_VAX_DFLOAT))
3135 strcat (buf, ", D-Float");
3136 if ((e_flags & EF_VAX_GFLOAT))
3137 strcat (buf, ", G-Float");
3141 if (e_flags & E_FLAG_RL78_G10)
3142 strcat (buf, ", G10");
3143 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3144 strcat (buf, ", 64-bit doubles");
3148 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3149 strcat (buf, ", 64-bit doubles");
3150 if (e_flags & E_FLAG_RX_DSP)
3151 strcat (buf, ", dsp");
3152 if (e_flags & E_FLAG_RX_PID)
3153 strcat (buf, ", pid");
3154 if (e_flags & E_FLAG_RX_ABI)
3155 strcat (buf, ", RX ABI");
3159 if (e_flags & EF_S390_HIGH_GPRS)
3160 strcat (buf, ", highgprs");
3164 if ((e_flags & EF_C6000_REL))
3165 strcat (buf, ", relocatable module");
3169 strcat (buf, _(": architecture variant: "));
3170 switch (e_flags & EF_MSP430_MACH)
3172 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3173 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3174 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3175 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3176 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3177 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3178 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3179 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3180 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3181 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3182 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3183 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3184 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3185 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3186 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3188 strcat (buf, _(": unknown")); break;
3191 if (e_flags & ~ EF_MSP430_MACH)
3192 strcat (buf, _(": unknown extra flag bits also present"));
3200 get_osabi_name (unsigned int osabi)
3202 static char buff[32];
3206 case ELFOSABI_NONE: return "UNIX - System V";
3207 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3208 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3209 case ELFOSABI_GNU: return "UNIX - GNU";
3210 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3211 case ELFOSABI_AIX: return "UNIX - AIX";
3212 case ELFOSABI_IRIX: return "UNIX - IRIX";
3213 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3214 case ELFOSABI_TRU64: return "UNIX - TRU64";
3215 case ELFOSABI_MODESTO: return "Novell - Modesto";
3216 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3217 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3218 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3219 case ELFOSABI_AROS: return "AROS";
3220 case ELFOSABI_FENIXOS: return "FenixOS";
3223 switch (elf_header.e_machine)
3228 case ELFOSABI_ARM: return "ARM";
3238 case ELFOSABI_STANDALONE: return _("Standalone App");
3247 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3248 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3257 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3263 get_aarch64_segment_type (unsigned long type)
3267 case PT_AARCH64_ARCHEXT:
3268 return "AARCH64_ARCHEXT";
3277 get_arm_segment_type (unsigned long type)
3291 get_mips_segment_type (unsigned long type)
3295 case PT_MIPS_REGINFO:
3297 case PT_MIPS_RTPROC:
3299 case PT_MIPS_OPTIONS:
3301 case PT_MIPS_ABIFLAGS:
3311 get_parisc_segment_type (unsigned long type)
3315 case PT_HP_TLS: return "HP_TLS";
3316 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3317 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3318 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3319 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3320 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3321 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3322 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3323 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3324 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3325 case PT_HP_PARALLEL: return "HP_PARALLEL";
3326 case PT_HP_FASTBIND: return "HP_FASTBIND";
3327 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3328 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3329 case PT_HP_STACK: return "HP_STACK";
3330 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3331 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3332 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3333 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3342 get_ia64_segment_type (unsigned long type)
3346 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3347 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3348 case PT_HP_TLS: return "HP_TLS";
3349 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3350 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3351 case PT_IA_64_HP_STACK: return "HP_STACK";
3360 get_tic6x_segment_type (unsigned long type)
3364 case PT_C6000_PHATTR: return "C6000_PHATTR";
3373 get_segment_type (unsigned long p_type)
3375 static char buff[32];
3379 case PT_NULL: return "NULL";
3380 case PT_LOAD: return "LOAD";
3381 case PT_DYNAMIC: return "DYNAMIC";
3382 case PT_INTERP: return "INTERP";
3383 case PT_NOTE: return "NOTE";
3384 case PT_SHLIB: return "SHLIB";
3385 case PT_PHDR: return "PHDR";
3386 case PT_TLS: return "TLS";
3388 case PT_GNU_EH_FRAME:
3389 return "GNU_EH_FRAME";
3390 case PT_GNU_STACK: return "GNU_STACK";
3391 case PT_GNU_RELRO: return "GNU_RELRO";
3394 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3396 const char * result;
3398 switch (elf_header.e_machine)
3401 result = get_aarch64_segment_type (p_type);
3404 result = get_arm_segment_type (p_type);
3407 case EM_MIPS_RS3_LE:
3408 result = get_mips_segment_type (p_type);
3411 result = get_parisc_segment_type (p_type);
3414 result = get_ia64_segment_type (p_type);
3417 result = get_tic6x_segment_type (p_type);
3427 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3429 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3431 const char * result;
3433 switch (elf_header.e_machine)
3436 result = get_parisc_segment_type (p_type);
3439 result = get_ia64_segment_type (p_type);
3449 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3452 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3459 get_mips_section_type_name (unsigned int sh_type)
3463 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3464 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3465 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3466 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3467 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3468 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3469 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3470 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3471 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3472 case SHT_MIPS_RELD: return "MIPS_RELD";
3473 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3474 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3475 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3476 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3477 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3478 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3479 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3480 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3481 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3482 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3483 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3484 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3485 case SHT_MIPS_LINE: return "MIPS_LINE";
3486 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3487 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3488 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3489 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3490 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3491 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3492 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3493 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3494 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3495 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3496 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3497 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3498 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3499 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3500 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3501 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3502 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3510 get_parisc_section_type_name (unsigned int sh_type)
3514 case SHT_PARISC_EXT: return "PARISC_EXT";
3515 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3516 case SHT_PARISC_DOC: return "PARISC_DOC";
3517 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3518 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3519 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3520 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3528 get_ia64_section_type_name (unsigned int sh_type)
3530 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3531 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3532 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3536 case SHT_IA_64_EXT: return "IA_64_EXT";
3537 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3538 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3539 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3540 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3541 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3542 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3543 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3544 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3545 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3553 get_x86_64_section_type_name (unsigned int sh_type)
3557 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3565 get_aarch64_section_type_name (unsigned int sh_type)
3569 case SHT_AARCH64_ATTRIBUTES:
3570 return "AARCH64_ATTRIBUTES";
3578 get_arm_section_type_name (unsigned int sh_type)
3582 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3583 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3584 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3585 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3586 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3594 get_tic6x_section_type_name (unsigned int sh_type)
3598 case SHT_C6000_UNWIND:
3599 return "C6000_UNWIND";
3600 case SHT_C6000_PREEMPTMAP:
3601 return "C6000_PREEMPTMAP";
3602 case SHT_C6000_ATTRIBUTES:
3603 return "C6000_ATTRIBUTES";
3608 case SHT_TI_HANDLER:
3609 return "TI_HANDLER";
3610 case SHT_TI_INITINFO:
3611 return "TI_INITINFO";
3612 case SHT_TI_PHATTRS:
3613 return "TI_PHATTRS";
3621 get_msp430x_section_type_name (unsigned int sh_type)
3625 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3626 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3627 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3628 default: return NULL;
3633 get_section_type_name (unsigned int sh_type)
3635 static char buff[32];
3639 case SHT_NULL: return "NULL";
3640 case SHT_PROGBITS: return "PROGBITS";
3641 case SHT_SYMTAB: return "SYMTAB";
3642 case SHT_STRTAB: return "STRTAB";
3643 case SHT_RELA: return "RELA";
3644 case SHT_HASH: return "HASH";
3645 case SHT_DYNAMIC: return "DYNAMIC";
3646 case SHT_NOTE: return "NOTE";
3647 case SHT_NOBITS: return "NOBITS";
3648 case SHT_REL: return "REL";
3649 case SHT_SHLIB: return "SHLIB";
3650 case SHT_DYNSYM: return "DYNSYM";
3651 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3652 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3653 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3654 case SHT_GNU_HASH: return "GNU_HASH";
3655 case SHT_GROUP: return "GROUP";
3656 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3657 case SHT_GNU_verdef: return "VERDEF";
3658 case SHT_GNU_verneed: return "VERNEED";
3659 case SHT_GNU_versym: return "VERSYM";
3660 case 0x6ffffff0: return "VERSYM";
3661 case 0x6ffffffc: return "VERDEF";
3662 case 0x7ffffffd: return "AUXILIARY";
3663 case 0x7fffffff: return "FILTER";
3664 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3667 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3669 const char * result;
3671 switch (elf_header.e_machine)
3674 case EM_MIPS_RS3_LE:
3675 result = get_mips_section_type_name (sh_type);
3678 result = get_parisc_section_type_name (sh_type);
3681 result = get_ia64_section_type_name (sh_type);
3686 result = get_x86_64_section_type_name (sh_type);
3689 result = get_aarch64_section_type_name (sh_type);
3692 result = get_arm_section_type_name (sh_type);
3695 result = get_tic6x_section_type_name (sh_type);
3698 result = get_msp430x_section_type_name (sh_type);
3708 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3710 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3712 const char * result;
3714 switch (elf_header.e_machine)
3717 result = get_ia64_section_type_name (sh_type);
3727 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3729 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3730 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3732 /* This message is probably going to be displayed in a 15
3733 character wide field, so put the hex value first. */
3734 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3740 #define OPTION_DEBUG_DUMP 512
3741 #define OPTION_DYN_SYMS 513
3742 #define OPTION_DWARF_DEPTH 514
3743 #define OPTION_DWARF_START 515
3744 #define OPTION_DWARF_CHECK 516
3746 static struct option options[] =
3748 {"all", no_argument, 0, 'a'},
3749 {"file-header", no_argument, 0, 'h'},
3750 {"program-headers", no_argument, 0, 'l'},
3751 {"headers", no_argument, 0, 'e'},
3752 {"histogram", no_argument, 0, 'I'},
3753 {"segments", no_argument, 0, 'l'},
3754 {"sections", no_argument, 0, 'S'},
3755 {"section-headers", no_argument, 0, 'S'},
3756 {"section-groups", no_argument, 0, 'g'},
3757 {"section-details", no_argument, 0, 't'},
3758 {"full-section-name",no_argument, 0, 'N'},
3759 {"symbols", no_argument, 0, 's'},
3760 {"syms", no_argument, 0, 's'},
3761 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3762 {"relocs", no_argument, 0, 'r'},
3763 {"notes", no_argument, 0, 'n'},
3764 {"dynamic", no_argument, 0, 'd'},
3765 {"arch-specific", no_argument, 0, 'A'},
3766 {"version-info", no_argument, 0, 'V'},
3767 {"use-dynamic", no_argument, 0, 'D'},
3768 {"unwind", no_argument, 0, 'u'},
3769 {"archive-index", no_argument, 0, 'c'},
3770 {"hex-dump", required_argument, 0, 'x'},
3771 {"relocated-dump", required_argument, 0, 'R'},
3772 {"string-dump", required_argument, 0, 'p'},
3773 #ifdef SUPPORT_DISASSEMBLY
3774 {"instruction-dump", required_argument, 0, 'i'},
3776 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3778 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3779 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3780 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3782 {"version", no_argument, 0, 'v'},
3783 {"wide", no_argument, 0, 'W'},
3784 {"help", no_argument, 0, 'H'},
3785 {0, no_argument, 0, 0}
3789 usage (FILE * stream)
3791 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3792 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3793 fprintf (stream, _(" Options are:\n\
3794 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3795 -h --file-header Display the ELF file header\n\
3796 -l --program-headers Display the program headers\n\
3797 --segments An alias for --program-headers\n\
3798 -S --section-headers Display the sections' header\n\
3799 --sections An alias for --section-headers\n\
3800 -g --section-groups Display the section groups\n\
3801 -t --section-details Display the section details\n\
3802 -e --headers Equivalent to: -h -l -S\n\
3803 -s --syms Display the symbol table\n\
3804 --symbols An alias for --syms\n\
3805 --dyn-syms Display the dynamic symbol table\n\
3806 -n --notes Display the core notes (if present)\n\
3807 -r --relocs Display the relocations (if present)\n\
3808 -u --unwind Display the unwind info (if present)\n\
3809 -d --dynamic Display the dynamic section (if present)\n\
3810 -V --version-info Display the version sections (if present)\n\
3811 -A --arch-specific Display architecture specific information (if any)\n\
3812 -c --archive-index Display the symbol/file index in an archive\n\
3813 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3814 -x --hex-dump=<number|name>\n\
3815 Dump the contents of section <number|name> as bytes\n\
3816 -p --string-dump=<number|name>\n\
3817 Dump the contents of section <number|name> as strings\n\
3818 -R --relocated-dump=<number|name>\n\
3819 Dump the contents of section <number|name> as relocated bytes\n\
3820 -w[lLiaprmfFsoRt] or\n\
3821 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3822 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3823 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3825 Display the contents of DWARF2 debug sections\n"));
3826 fprintf (stream, _("\
3827 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3828 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3830 #ifdef SUPPORT_DISASSEMBLY
3831 fprintf (stream, _("\
3832 -i --instruction-dump=<number|name>\n\
3833 Disassemble the contents of section <number|name>\n"));
3835 fprintf (stream, _("\
3836 -I --histogram Display histogram of bucket list lengths\n\
3837 -W --wide Allow output width to exceed 80 characters\n\
3838 @<file> Read options from <file>\n\
3839 -H --help Display this information\n\
3840 -v --version Display the version number of readelf\n"));
3842 if (REPORT_BUGS_TO[0] && stream == stdout)
3843 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3845 exit (stream == stdout ? 0 : 1);
3848 /* Record the fact that the user wants the contents of section number
3849 SECTION to be displayed using the method(s) encoded as flags bits
3850 in TYPE. Note, TYPE can be zero if we are creating the array for
3854 request_dump_bynumber (unsigned int section, dump_type type)
3856 if (section >= num_dump_sects)
3858 dump_type * new_dump_sects;
3860 new_dump_sects = (dump_type *) calloc (section + 1,
3861 sizeof (* dump_sects));
3863 if (new_dump_sects == NULL)
3864 error (_("Out of memory allocating dump request table.\n"));
3867 /* Copy current flag settings. */
3868 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3872 dump_sects = new_dump_sects;
3873 num_dump_sects = section + 1;
3878 dump_sects[section] |= type;
3883 /* Request a dump by section name. */
3886 request_dump_byname (const char * section, dump_type type)
3888 struct dump_list_entry * new_request;
3890 new_request = (struct dump_list_entry *)
3891 malloc (sizeof (struct dump_list_entry));
3893 error (_("Out of memory allocating dump request table.\n"));
3895 new_request->name = strdup (section);
3896 if (!new_request->name)
3897 error (_("Out of memory allocating dump request table.\n"));
3899 new_request->type = type;
3901 new_request->next = dump_sects_byname;
3902 dump_sects_byname = new_request;
3906 request_dump (dump_type type)
3912 section = strtoul (optarg, & cp, 0);
3914 if (! *cp && section >= 0)
3915 request_dump_bynumber (section, type);
3917 request_dump_byname (optarg, type);
3922 parse_args (int argc, char ** argv)
3929 while ((c = getopt_long
3930 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3948 do_section_groups++;
3956 do_section_groups++;
3961 do_section_details++;
4005 request_dump (HEX_DUMP);
4008 request_dump (STRING_DUMP);
4011 request_dump (RELOC_DUMP);
4018 dwarf_select_sections_all ();
4023 dwarf_select_sections_by_letters (optarg);
4026 case OPTION_DEBUG_DUMP:
4033 dwarf_select_sections_by_names (optarg);
4036 case OPTION_DWARF_DEPTH:
4040 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4043 case OPTION_DWARF_START:
4047 dwarf_start_die = strtoul (optarg, & cp, 0);
4050 case OPTION_DWARF_CHECK:
4053 case OPTION_DYN_SYMS:
4056 #ifdef SUPPORT_DISASSEMBLY
4058 request_dump (DISASS_DUMP);
4062 print_version (program_name);
4071 /* xgettext:c-format */
4072 error (_("Invalid option '-%c'\n"), c);
4079 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4080 && !do_segments && !do_header && !do_dump && !do_version
4081 && !do_histogram && !do_debugging && !do_arch && !do_notes
4082 && !do_section_groups && !do_archive_index
4087 warn (_("Nothing to do.\n"));
4093 get_elf_class (unsigned int elf_class)
4095 static char buff[32];
4099 case ELFCLASSNONE: return _("none");
4100 case ELFCLASS32: return "ELF32";
4101 case ELFCLASS64: return "ELF64";
4103 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4109 get_data_encoding (unsigned int encoding)
4111 static char buff[32];
4115 case ELFDATANONE: return _("none");
4116 case ELFDATA2LSB: return _("2's complement, little endian");
4117 case ELFDATA2MSB: return _("2's complement, big endian");
4119 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4124 /* Decode the data held in 'elf_header'. */
4127 process_file_header (void)
4129 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4130 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4131 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4132 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4135 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4139 init_dwarf_regnames (elf_header.e_machine);
4145 printf (_("ELF Header:\n"));
4146 printf (_(" Magic: "));
4147 for (i = 0; i < EI_NIDENT; i++)
4148 printf ("%2.2x ", elf_header.e_ident[i]);
4150 printf (_(" Class: %s\n"),
4151 get_elf_class (elf_header.e_ident[EI_CLASS]));
4152 printf (_(" Data: %s\n"),
4153 get_data_encoding (elf_header.e_ident[EI_DATA]));
4154 printf (_(" Version: %d %s\n"),
4155 elf_header.e_ident[EI_VERSION],
4156 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4158 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4159 ? _("<unknown: %lx>")
4161 printf (_(" OS/ABI: %s\n"),
4162 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4163 printf (_(" ABI Version: %d\n"),
4164 elf_header.e_ident[EI_ABIVERSION]);
4165 printf (_(" Type: %s\n"),
4166 get_file_type (elf_header.e_type));
4167 printf (_(" Machine: %s\n"),
4168 get_machine_name (elf_header.e_machine));
4169 printf (_(" Version: 0x%lx\n"),
4170 (unsigned long) elf_header.e_version);
4172 printf (_(" Entry point address: "));
4173 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4174 printf (_("\n Start of program headers: "));
4175 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4176 printf (_(" (bytes into file)\n Start of section headers: "));
4177 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4178 printf (_(" (bytes into file)\n"));
4180 printf (_(" Flags: 0x%lx%s\n"),
4181 (unsigned long) elf_header.e_flags,
4182 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4183 printf (_(" Size of this header: %ld (bytes)\n"),
4184 (long) elf_header.e_ehsize);
4185 printf (_(" Size of program headers: %ld (bytes)\n"),
4186 (long) elf_header.e_phentsize);
4187 printf (_(" Number of program headers: %ld"),
4188 (long) elf_header.e_phnum);
4189 if (section_headers != NULL
4190 && elf_header.e_phnum == PN_XNUM
4191 && section_headers[0].sh_info != 0)
4192 printf (" (%ld)", (long) section_headers[0].sh_info);
4193 putc ('\n', stdout);
4194 printf (_(" Size of section headers: %ld (bytes)\n"),
4195 (long) elf_header.e_shentsize);
4196 printf (_(" Number of section headers: %ld"),
4197 (long) elf_header.e_shnum);
4198 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4199 printf (" (%ld)", (long) section_headers[0].sh_size);
4200 putc ('\n', stdout);
4201 printf (_(" Section header string table index: %ld"),
4202 (long) elf_header.e_shstrndx);
4203 if (section_headers != NULL
4204 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4205 printf (" (%u)", section_headers[0].sh_link);
4206 else if (elf_header.e_shstrndx != SHN_UNDEF
4207 && elf_header.e_shstrndx >= elf_header.e_shnum)
4208 printf (_(" <corrupt: out of range>"));
4209 putc ('\n', stdout);
4212 if (section_headers != NULL)
4214 if (elf_header.e_phnum == PN_XNUM
4215 && section_headers[0].sh_info != 0)
4216 elf_header.e_phnum = section_headers[0].sh_info;
4217 if (elf_header.e_shnum == SHN_UNDEF)
4218 elf_header.e_shnum = section_headers[0].sh_size;
4219 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4220 elf_header.e_shstrndx = section_headers[0].sh_link;
4221 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4222 elf_header.e_shstrndx = SHN_UNDEF;
4223 free (section_headers);
4224 section_headers = NULL;
4231 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4233 Elf32_External_Phdr * phdrs;
4234 Elf32_External_Phdr * external;
4235 Elf_Internal_Phdr * internal;
4237 unsigned int size = elf_header.e_phentsize;
4238 unsigned int num = elf_header.e_phnum;
4240 /* PR binutils/17531: Cope with unexpected section header sizes. */
4241 if (size == 0 || num == 0)
4243 if (size < sizeof * phdrs)
4245 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4248 if (size > sizeof * phdrs)
4249 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4251 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4252 size, num, _("program headers"));
4256 for (i = 0, internal = pheaders, external = phdrs;
4257 i < elf_header.e_phnum;
4258 i++, internal++, external++)
4260 internal->p_type = BYTE_GET (external->p_type);
4261 internal->p_offset = BYTE_GET (external->p_offset);
4262 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4263 internal->p_paddr = BYTE_GET (external->p_paddr);
4264 internal->p_filesz = BYTE_GET (external->p_filesz);
4265 internal->p_memsz = BYTE_GET (external->p_memsz);
4266 internal->p_flags = BYTE_GET (external->p_flags);
4267 internal->p_align = BYTE_GET (external->p_align);
4275 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4277 Elf64_External_Phdr * phdrs;
4278 Elf64_External_Phdr * external;
4279 Elf_Internal_Phdr * internal;
4281 unsigned int size = elf_header.e_phentsize;
4282 unsigned int num = elf_header.e_phnum;
4284 /* PR binutils/17531: Cope with unexpected section header sizes. */
4285 if (size == 0 || num == 0)
4287 if (size < sizeof * phdrs)
4289 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4292 if (size > sizeof * phdrs)
4293 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4295 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4296 size, num, _("program headers"));
4300 for (i = 0, internal = pheaders, external = phdrs;
4301 i < elf_header.e_phnum;
4302 i++, internal++, external++)
4304 internal->p_type = BYTE_GET (external->p_type);
4305 internal->p_flags = BYTE_GET (external->p_flags);
4306 internal->p_offset = BYTE_GET (external->p_offset);
4307 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4308 internal->p_paddr = BYTE_GET (external->p_paddr);
4309 internal->p_filesz = BYTE_GET (external->p_filesz);
4310 internal->p_memsz = BYTE_GET (external->p_memsz);
4311 internal->p_align = BYTE_GET (external->p_align);
4318 /* Returns 1 if the program headers were read into `program_headers'. */
4321 get_program_headers (FILE * file)
4323 Elf_Internal_Phdr * phdrs;
4325 /* Check cache of prior read. */
4326 if (program_headers != NULL)
4329 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4330 sizeof (Elf_Internal_Phdr));
4334 error (_("Out of memory reading %u program headers\n"),
4335 elf_header.e_phnum);
4340 ? get_32bit_program_headers (file, phdrs)
4341 : get_64bit_program_headers (file, phdrs))
4343 program_headers = phdrs;
4351 /* Returns 1 if the program headers were loaded. */
4354 process_program_headers (FILE * file)
4356 Elf_Internal_Phdr * segment;
4359 if (elf_header.e_phnum == 0)
4361 /* PR binutils/12467. */
4362 if (elf_header.e_phoff != 0)
4363 warn (_("possibly corrupt ELF header - it has a non-zero program"
4364 " header offset, but no program headers"));
4365 else if (do_segments)
4366 printf (_("\nThere are no program headers in this file.\n"));
4370 if (do_segments && !do_header)
4372 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4373 printf (_("Entry point "));
4374 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4375 printf (_("\nThere are %d program headers, starting at offset "),
4376 elf_header.e_phnum);
4377 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4381 if (! get_program_headers (file))
4386 if (elf_header.e_phnum > 1)
4387 printf (_("\nProgram Headers:\n"));
4389 printf (_("\nProgram Headers:\n"));
4393 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4396 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4400 (_(" Type Offset VirtAddr PhysAddr\n"));
4402 (_(" FileSiz MemSiz Flags Align\n"));
4409 for (i = 0, segment = program_headers;
4410 i < elf_header.e_phnum;
4415 printf (" %-14.14s ", get_segment_type (segment->p_type));
4419 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4420 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4421 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4422 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4423 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4425 (segment->p_flags & PF_R ? 'R' : ' '),
4426 (segment->p_flags & PF_W ? 'W' : ' '),
4427 (segment->p_flags & PF_X ? 'E' : ' '));
4428 printf ("%#lx", (unsigned long) segment->p_align);
4432 if ((unsigned long) segment->p_offset == segment->p_offset)
4433 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4436 print_vma (segment->p_offset, FULL_HEX);
4440 print_vma (segment->p_vaddr, FULL_HEX);
4442 print_vma (segment->p_paddr, FULL_HEX);
4445 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4446 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4449 print_vma (segment->p_filesz, FULL_HEX);
4453 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4454 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4457 print_vma (segment->p_memsz, FULL_HEX);
4461 (segment->p_flags & PF_R ? 'R' : ' '),
4462 (segment->p_flags & PF_W ? 'W' : ' '),
4463 (segment->p_flags & PF_X ? 'E' : ' '));
4465 if ((unsigned long) segment->p_align == segment->p_align)
4466 printf ("%#lx", (unsigned long) segment->p_align);
4469 print_vma (segment->p_align, PREFIX_HEX);
4474 print_vma (segment->p_offset, FULL_HEX);
4476 print_vma (segment->p_vaddr, FULL_HEX);
4478 print_vma (segment->p_paddr, FULL_HEX);
4480 print_vma (segment->p_filesz, FULL_HEX);
4482 print_vma (segment->p_memsz, FULL_HEX);
4484 (segment->p_flags & PF_R ? 'R' : ' '),
4485 (segment->p_flags & PF_W ? 'W' : ' '),
4486 (segment->p_flags & PF_X ? 'E' : ' '));
4487 print_vma (segment->p_align, HEX);
4492 putc ('\n', stdout);
4494 switch (segment->p_type)
4498 error (_("more than one dynamic segment\n"));
4500 /* By default, assume that the .dynamic section is the first
4501 section in the DYNAMIC segment. */
4502 dynamic_addr = segment->p_offset;
4503 dynamic_size = segment->p_filesz;
4504 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4505 if (dynamic_addr + dynamic_size >= current_file_size)
4507 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4508 dynamic_addr = dynamic_size = 0;
4511 /* Try to locate the .dynamic section. If there is
4512 a section header table, we can easily locate it. */
4513 if (section_headers != NULL)
4515 Elf_Internal_Shdr * sec;
4517 sec = find_section (".dynamic");
4518 if (sec == NULL || sec->sh_size == 0)
4520 /* A corresponding .dynamic section is expected, but on
4521 IA-64/OpenVMS it is OK for it to be missing. */
4522 if (!is_ia64_vms ())
4523 error (_("no .dynamic section in the dynamic segment\n"));
4527 if (sec->sh_type == SHT_NOBITS)
4533 dynamic_addr = sec->sh_offset;
4534 dynamic_size = sec->sh_size;
4536 if (dynamic_addr < segment->p_offset
4537 || dynamic_addr > segment->p_offset + segment->p_filesz)
4538 warn (_("the .dynamic section is not contained"
4539 " within the dynamic segment\n"));
4540 else if (dynamic_addr > segment->p_offset)
4541 warn (_("the .dynamic section is not the first section"
4542 " in the dynamic segment.\n"));
4547 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4549 error (_("Unable to find program interpreter name\n"));
4553 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4555 if (ret >= (int) sizeof (fmt) || ret < 0)
4556 error (_("Internal error: failed to create format string to display program interpreter\n"));
4558 program_interpreter[0] = 0;
4559 if (fscanf (file, fmt, program_interpreter) <= 0)
4560 error (_("Unable to read program interpreter name\n"));
4563 printf (_(" [Requesting program interpreter: %s]\n"),
4564 program_interpreter);
4570 if (do_segments && section_headers != NULL && string_table != NULL)
4572 printf (_("\n Section to Segment mapping:\n"));
4573 printf (_(" Segment Sections...\n"));
4575 for (i = 0; i < elf_header.e_phnum; i++)
4578 Elf_Internal_Shdr * section;
4580 segment = program_headers + i;
4581 section = section_headers + 1;
4583 printf (" %2.2d ", i);
4585 for (j = 1; j < elf_header.e_shnum; j++, section++)
4587 if (!ELF_TBSS_SPECIAL (section, segment)
4588 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4589 printf ("%s ", printable_section_name (section));
4600 /* Find the file offset corresponding to VMA by using the program headers. */
4603 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4605 Elf_Internal_Phdr * seg;
4607 if (! get_program_headers (file))
4609 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4613 for (seg = program_headers;
4614 seg < program_headers + elf_header.e_phnum;
4617 if (seg->p_type != PT_LOAD)
4620 if (vma >= (seg->p_vaddr & -seg->p_align)
4621 && vma + size <= seg->p_vaddr + seg->p_filesz)
4622 return vma - seg->p_vaddr + seg->p_offset;
4625 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4626 (unsigned long) vma);
4631 /* Allocate memory and load the sections headers into the global pointer
4632 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4633 generate any error messages if the load fails. */
4636 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4638 Elf32_External_Shdr * shdrs;
4639 Elf_Internal_Shdr * internal;
4641 unsigned int size = elf_header.e_shentsize;
4642 unsigned int num = probe ? 1 : elf_header.e_shnum;
4644 /* PR binutils/17531: Cope with unexpected section header sizes. */
4645 if (size == 0 || num == 0)
4647 if (size < sizeof * shdrs)
4650 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4653 if (!probe && size > sizeof * shdrs)
4654 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4656 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4658 probe ? NULL : _("section headers"));
4662 if (section_headers != NULL)
4663 free (section_headers);
4664 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4665 sizeof (Elf_Internal_Shdr));
4666 if (section_headers == NULL)
4669 error (_("Out of memory reading %u section headers\n"), num);
4673 for (i = 0, internal = section_headers;
4677 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4678 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4679 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4680 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4681 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4682 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4683 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4684 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4685 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4686 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4694 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4696 Elf64_External_Shdr * shdrs;
4697 Elf_Internal_Shdr * internal;
4699 unsigned int size = elf_header.e_shentsize;
4700 unsigned int num = probe ? 1 : elf_header.e_shnum;
4702 /* PR binutils/17531: Cope with unexpected section header sizes. */
4703 if (size == 0 || num == 0)
4705 if (size < sizeof * shdrs)
4708 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4711 if (! probe && size > sizeof * shdrs)
4712 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4714 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4716 probe ? NULL : _("section headers"));
4720 if (section_headers != NULL)
4721 free (section_headers);
4722 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4723 sizeof (Elf_Internal_Shdr));
4724 if (section_headers == NULL)
4727 error (_("Out of memory reading %u section headers\n"), num);
4731 for (i = 0, internal = section_headers;
4735 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4736 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4737 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4738 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4739 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4740 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4741 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4742 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4743 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4744 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4751 static Elf_Internal_Sym *
4752 get_32bit_elf_symbols (FILE * file,
4753 Elf_Internal_Shdr * section,
4754 unsigned long * num_syms_return)
4756 unsigned long number = 0;
4757 Elf32_External_Sym * esyms = NULL;
4758 Elf_External_Sym_Shndx * shndx = NULL;
4759 Elf_Internal_Sym * isyms = NULL;
4760 Elf_Internal_Sym * psym;
4763 if (section->sh_size == 0)
4765 if (num_syms_return != NULL)
4766 * num_syms_return = 0;
4770 /* Run some sanity checks first. */
4771 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4773 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4774 printable_section_name (section), (unsigned long) section->sh_entsize);
4778 if (section->sh_size > current_file_size)
4780 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4781 printable_section_name (section), (unsigned long) section->sh_size);
4785 number = section->sh_size / section->sh_entsize;
4787 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4789 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4790 (unsigned long) section->sh_size,
4791 printable_section_name (section),
4792 (unsigned long) section->sh_entsize);
4796 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4797 section->sh_size, _("symbols"));
4802 if (symtab_shndx_hdr != NULL
4803 && (symtab_shndx_hdr->sh_link
4804 == (unsigned long) (section - section_headers)))
4806 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4807 symtab_shndx_hdr->sh_offset,
4808 1, symtab_shndx_hdr->sh_size,
4809 _("symbol table section indicies"));
4812 /* PR17531: file: heap-buffer-overflow */
4813 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4815 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4816 printable_section_name (symtab_shndx_hdr),
4817 (unsigned long) symtab_shndx_hdr->sh_size,
4818 (unsigned long) section->sh_size);
4823 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4827 error (_("Out of memory reading %lu symbols\n"),
4828 (unsigned long) number);
4832 for (j = 0, psym = isyms; j < number; j++, psym++)
4834 psym->st_name = BYTE_GET (esyms[j].st_name);
4835 psym->st_value = BYTE_GET (esyms[j].st_value);
4836 psym->st_size = BYTE_GET (esyms[j].st_size);
4837 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4838 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4840 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4841 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4842 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4843 psym->st_info = BYTE_GET (esyms[j].st_info);
4844 psym->st_other = BYTE_GET (esyms[j].st_other);
4853 if (num_syms_return != NULL)
4854 * num_syms_return = isyms == NULL ? 0 : number;
4859 static Elf_Internal_Sym *
4860 get_64bit_elf_symbols (FILE * file,
4861 Elf_Internal_Shdr * section,
4862 unsigned long * num_syms_return)
4864 unsigned long number = 0;
4865 Elf64_External_Sym * esyms = NULL;
4866 Elf_External_Sym_Shndx * shndx = NULL;
4867 Elf_Internal_Sym * isyms = NULL;
4868 Elf_Internal_Sym * psym;
4871 if (section->sh_size == 0)
4873 if (num_syms_return != NULL)
4874 * num_syms_return = 0;
4878 /* Run some sanity checks first. */
4879 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4881 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4882 printable_section_name (section),
4883 (unsigned long) section->sh_entsize);
4887 if (section->sh_size > current_file_size)
4889 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4890 printable_section_name (section),
4891 (unsigned long) section->sh_size);
4895 number = section->sh_size / section->sh_entsize;
4897 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4899 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4900 (unsigned long) section->sh_size,
4901 printable_section_name (section),
4902 (unsigned long) section->sh_entsize);
4906 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4907 section->sh_size, _("symbols"));
4911 if (symtab_shndx_hdr != NULL
4912 && (symtab_shndx_hdr->sh_link
4913 == (unsigned long) (section - section_headers)))
4915 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4916 symtab_shndx_hdr->sh_offset,
4917 1, symtab_shndx_hdr->sh_size,
4918 _("symbol table section indicies"));
4921 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4923 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4924 printable_section_name (symtab_shndx_hdr),
4925 (unsigned long) symtab_shndx_hdr->sh_size,
4926 (unsigned long) section->sh_size);
4931 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4935 error (_("Out of memory reading %lu symbols\n"),
4936 (unsigned long) number);
4940 for (j = 0, psym = isyms; j < number; j++, psym++)
4942 psym->st_name = BYTE_GET (esyms[j].st_name);
4943 psym->st_info = BYTE_GET (esyms[j].st_info);
4944 psym->st_other = BYTE_GET (esyms[j].st_other);
4945 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4947 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4949 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4950 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4951 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4953 psym->st_value = BYTE_GET (esyms[j].st_value);
4954 psym->st_size = BYTE_GET (esyms[j].st_size);
4963 if (num_syms_return != NULL)
4964 * num_syms_return = isyms == NULL ? 0 : number;
4970 get_elf_section_flags (bfd_vma sh_flags)
4972 static char buff[1024];
4974 int field_size = is_32bit_elf ? 8 : 16;
4976 int size = sizeof (buff) - (field_size + 4 + 1);
4977 bfd_vma os_flags = 0;
4978 bfd_vma proc_flags = 0;
4979 bfd_vma unknown_flags = 0;
4987 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4988 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4989 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4990 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4991 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4992 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4993 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4994 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4995 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4996 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4997 /* IA-64 specific. */
4998 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4999 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5000 /* IA-64 OpenVMS specific. */
5001 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5002 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5003 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5004 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5005 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5006 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5008 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5009 /* SPARC specific. */
5010 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5013 if (do_section_details)
5015 sprintf (buff, "[%*.*lx]: ",
5016 field_size, field_size, (unsigned long) sh_flags);
5017 p += field_size + 4;
5024 flag = sh_flags & - sh_flags;
5027 if (do_section_details)
5031 case SHF_WRITE: sindex = 0; break;
5032 case SHF_ALLOC: sindex = 1; break;
5033 case SHF_EXECINSTR: sindex = 2; break;
5034 case SHF_MERGE: sindex = 3; break;
5035 case SHF_STRINGS: sindex = 4; break;
5036 case SHF_INFO_LINK: sindex = 5; break;
5037 case SHF_LINK_ORDER: sindex = 6; break;
5038 case SHF_OS_NONCONFORMING: sindex = 7; break;
5039 case SHF_GROUP: sindex = 8; break;
5040 case SHF_TLS: sindex = 9; break;
5041 case SHF_EXCLUDE: sindex = 18; break;
5045 switch (elf_header.e_machine)
5048 if (flag == SHF_IA_64_SHORT)
5050 else if (flag == SHF_IA_64_NORECOV)
5053 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5056 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5057 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5058 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5059 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5060 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5061 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5072 case EM_OLD_SPARCV9:
5073 case EM_SPARC32PLUS:
5076 if (flag == SHF_ORDERED)
5086 if (p != buff + field_size + 4)
5088 if (size < (10 + 2))
5095 size -= flags [sindex].len;
5096 p = stpcpy (p, flags [sindex].str);
5098 else if (flag & SHF_MASKOS)
5100 else if (flag & SHF_MASKPROC)
5103 unknown_flags |= flag;
5109 case SHF_WRITE: *p = 'W'; break;
5110 case SHF_ALLOC: *p = 'A'; break;
5111 case SHF_EXECINSTR: *p = 'X'; break;
5112 case SHF_MERGE: *p = 'M'; break;
5113 case SHF_STRINGS: *p = 'S'; break;
5114 case SHF_INFO_LINK: *p = 'I'; break;
5115 case SHF_LINK_ORDER: *p = 'L'; break;
5116 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5117 case SHF_GROUP: *p = 'G'; break;
5118 case SHF_TLS: *p = 'T'; break;
5119 case SHF_EXCLUDE: *p = 'E'; break;
5122 if ((elf_header.e_machine == EM_X86_64
5123 || elf_header.e_machine == EM_L1OM
5124 || elf_header.e_machine == EM_K1OM)
5125 && flag == SHF_X86_64_LARGE)
5127 else if (flag & SHF_MASKOS)
5130 sh_flags &= ~ SHF_MASKOS;
5132 else if (flag & SHF_MASKPROC)
5135 sh_flags &= ~ SHF_MASKPROC;
5145 if (do_section_details)
5149 size -= 5 + field_size;
5150 if (p != buff + field_size + 4)
5158 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5159 (unsigned long) os_flags);
5160 p += 5 + field_size;
5164 size -= 7 + field_size;
5165 if (p != buff + field_size + 4)
5173 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5174 (unsigned long) proc_flags);
5175 p += 7 + field_size;
5179 size -= 10 + field_size;
5180 if (p != buff + field_size + 4)
5188 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5189 (unsigned long) unknown_flags);
5190 p += 10 + field_size;
5199 process_section_headers (FILE * file)
5201 Elf_Internal_Shdr * section;
5204 section_headers = NULL;
5206 if (elf_header.e_shnum == 0)
5208 /* PR binutils/12467. */
5209 if (elf_header.e_shoff != 0)
5210 warn (_("possibly corrupt ELF file header - it has a non-zero"
5211 " section header offset, but no section headers\n"));
5212 else if (do_sections)
5213 printf (_("\nThere are no sections in this file.\n"));
5218 if (do_sections && !do_header)
5219 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5220 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5224 if (! get_32bit_section_headers (file, FALSE))
5227 else if (! get_64bit_section_headers (file, FALSE))
5230 /* Read in the string table, so that we have names to display. */
5231 if (elf_header.e_shstrndx != SHN_UNDEF
5232 && elf_header.e_shstrndx < elf_header.e_shnum)
5234 section = section_headers + elf_header.e_shstrndx;
5236 if (section->sh_size != 0)
5238 string_table = (char *) get_data (NULL, file, section->sh_offset,
5239 1, section->sh_size,
5242 string_table_length = string_table != NULL ? section->sh_size : 0;
5246 /* Scan the sections for the dynamic symbol table
5247 and dynamic string table and debug sections. */
5248 dynamic_symbols = NULL;
5249 dynamic_strings = NULL;
5250 dynamic_syminfo = NULL;
5251 symtab_shndx_hdr = NULL;
5253 eh_addr_size = is_32bit_elf ? 4 : 8;
5254 switch (elf_header.e_machine)
5257 case EM_MIPS_RS3_LE:
5258 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5259 FDE addresses. However, the ABI also has a semi-official ILP32
5260 variant for which the normal FDE address size rules apply.
5262 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5263 section, where XX is the size of longs in bits. Unfortunately,
5264 earlier compilers provided no way of distinguishing ILP32 objects
5265 from LP64 objects, so if there's any doubt, we should assume that
5266 the official LP64 form is being used. */
5267 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5268 && find_section (".gcc_compiled_long32") == NULL)
5274 switch (elf_header.e_flags & EF_H8_MACH)
5276 case E_H8_MACH_H8300:
5277 case E_H8_MACH_H8300HN:
5278 case E_H8_MACH_H8300SN:
5279 case E_H8_MACH_H8300SXN:
5282 case E_H8_MACH_H8300H:
5283 case E_H8_MACH_H8300S:
5284 case E_H8_MACH_H8300SX:
5292 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5294 case EF_M32C_CPU_M16C:
5301 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5304 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5305 if (section->sh_entsize != expected_entsize) \
5308 sprintf_vma (buf, section->sh_entsize); \
5309 /* Note: coded this way so that there is a single string for \
5311 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5312 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5313 (unsigned) expected_entsize); \
5314 section->sh_entsize = expected_entsize; \
5319 #define CHECK_ENTSIZE(section, i, type) \
5320 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5321 sizeof (Elf64_External_##type))
5323 for (i = 0, section = section_headers;
5324 i < elf_header.e_shnum;
5327 char * name = SECTION_NAME (section);
5329 if (section->sh_type == SHT_DYNSYM)
5331 if (dynamic_symbols != NULL)
5333 error (_("File contains multiple dynamic symbol tables\n"));
5337 CHECK_ENTSIZE (section, i, Sym);
5338 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5340 else if (section->sh_type == SHT_STRTAB
5341 && streq (name, ".dynstr"))
5343 if (dynamic_strings != NULL)
5345 error (_("File contains multiple dynamic string tables\n"));
5349 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5350 1, section->sh_size,
5351 _("dynamic strings"));
5352 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5354 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5356 if (symtab_shndx_hdr != NULL)
5358 error (_("File contains multiple symtab shndx tables\n"));
5361 symtab_shndx_hdr = section;
5363 else if (section->sh_type == SHT_SYMTAB)
5364 CHECK_ENTSIZE (section, i, Sym);
5365 else if (section->sh_type == SHT_GROUP)
5366 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5367 else if (section->sh_type == SHT_REL)
5368 CHECK_ENTSIZE (section, i, Rel);
5369 else if (section->sh_type == SHT_RELA)
5370 CHECK_ENTSIZE (section, i, Rela);
5371 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5372 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5373 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5374 || do_debug_str || do_debug_loc || do_debug_ranges
5375 || do_debug_addr || do_debug_cu_index)
5376 && (const_strneq (name, ".debug_")
5377 || const_strneq (name, ".zdebug_")))
5380 name += sizeof (".zdebug_") - 1;
5382 name += sizeof (".debug_") - 1;
5385 || (do_debug_info && const_strneq (name, "info"))
5386 || (do_debug_info && const_strneq (name, "types"))
5387 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5388 || (do_debug_lines && strcmp (name, "line") == 0)
5389 || (do_debug_lines && const_strneq (name, "line."))
5390 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5391 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5392 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5393 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5394 || (do_debug_aranges && const_strneq (name, "aranges"))
5395 || (do_debug_ranges && const_strneq (name, "ranges"))
5396 || (do_debug_frames && const_strneq (name, "frame"))
5397 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5398 || (do_debug_macinfo && const_strneq (name, "macro"))
5399 || (do_debug_str && const_strneq (name, "str"))
5400 || (do_debug_loc && const_strneq (name, "loc"))
5401 || (do_debug_addr && const_strneq (name, "addr"))
5402 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5403 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5405 request_dump_bynumber (i, DEBUG_DUMP);
5407 /* Linkonce section to be combined with .debug_info at link time. */
5408 else if ((do_debugging || do_debug_info)
5409 && const_strneq (name, ".gnu.linkonce.wi."))
5410 request_dump_bynumber (i, DEBUG_DUMP);
5411 else if (do_debug_frames && streq (name, ".eh_frame"))
5412 request_dump_bynumber (i, DEBUG_DUMP);
5413 else if (do_gdb_index && streq (name, ".gdb_index"))
5414 request_dump_bynumber (i, DEBUG_DUMP);
5415 /* Trace sections for Itanium VMS. */
5416 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5417 || do_trace_aranges)
5418 && const_strneq (name, ".trace_"))
5420 name += sizeof (".trace_") - 1;
5423 || (do_trace_info && streq (name, "info"))
5424 || (do_trace_abbrevs && streq (name, "abbrev"))
5425 || (do_trace_aranges && streq (name, "aranges"))
5427 request_dump_bynumber (i, DEBUG_DUMP);
5434 if (elf_header.e_shnum > 1)
5435 printf (_("\nSection Headers:\n"));
5437 printf (_("\nSection Header:\n"));
5441 if (do_section_details)
5443 printf (_(" [Nr] Name\n"));
5444 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5448 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5452 if (do_section_details)
5454 printf (_(" [Nr] Name\n"));
5455 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5459 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5463 if (do_section_details)
5465 printf (_(" [Nr] Name\n"));
5466 printf (_(" Type Address Offset Link\n"));
5467 printf (_(" Size EntSize Info Align\n"));
5471 printf (_(" [Nr] Name Type Address Offset\n"));
5472 printf (_(" Size EntSize Flags Link Info Align\n"));
5476 if (do_section_details)
5477 printf (_(" Flags\n"));
5479 for (i = 0, section = section_headers;
5480 i < elf_header.e_shnum;
5483 printf (" [%2u] ", i);
5484 if (do_section_details)
5485 printf ("%s\n ", printable_section_name (section));
5487 print_symbol (-17, SECTION_NAME (section));
5489 printf (do_wide ? " %-15s " : " %-15.15s ",
5490 get_section_type_name (section->sh_type));
5494 const char * link_too_big = NULL;
5496 print_vma (section->sh_addr, LONG_HEX);
5498 printf ( " %6.6lx %6.6lx %2.2lx",
5499 (unsigned long) section->sh_offset,
5500 (unsigned long) section->sh_size,
5501 (unsigned long) section->sh_entsize);
5503 if (do_section_details)
5504 fputs (" ", stdout);
5506 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5508 if (section->sh_link >= elf_header.e_shnum)
5511 /* The sh_link value is out of range. Normally this indicates
5512 an error but it can have special values in Solaris binaries. */
5513 switch (elf_header.e_machine)
5520 case EM_OLD_SPARCV9:
5521 case EM_SPARC32PLUS:
5524 if (section->sh_link == (SHN_BEFORE & 0xffff))
5525 link_too_big = "BEFORE";
5526 else if (section->sh_link == (SHN_AFTER & 0xffff))
5527 link_too_big = "AFTER";
5534 if (do_section_details)
5536 if (link_too_big != NULL && * link_too_big)
5537 printf ("<%s> ", link_too_big);
5539 printf ("%2u ", section->sh_link);
5540 printf ("%3u %2lu\n", section->sh_info,
5541 (unsigned long) section->sh_addralign);
5544 printf ("%2u %3u %2lu\n",
5547 (unsigned long) section->sh_addralign);
5549 if (link_too_big && ! * link_too_big)
5550 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5551 i, section->sh_link);
5555 print_vma (section->sh_addr, LONG_HEX);
5557 if ((long) section->sh_offset == section->sh_offset)
5558 printf (" %6.6lx", (unsigned long) section->sh_offset);
5562 print_vma (section->sh_offset, LONG_HEX);
5565 if ((unsigned long) section->sh_size == section->sh_size)
5566 printf (" %6.6lx", (unsigned long) section->sh_size);
5570 print_vma (section->sh_size, LONG_HEX);
5573 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5574 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5578 print_vma (section->sh_entsize, LONG_HEX);
5581 if (do_section_details)
5582 fputs (" ", stdout);
5584 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5586 printf ("%2u %3u ", section->sh_link, section->sh_info);
5588 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5589 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5592 print_vma (section->sh_addralign, DEC);
5596 else if (do_section_details)
5598 printf (" %-15.15s ",
5599 get_section_type_name (section->sh_type));
5600 print_vma (section->sh_addr, LONG_HEX);
5601 if ((long) section->sh_offset == section->sh_offset)
5602 printf (" %16.16lx", (unsigned long) section->sh_offset);
5606 print_vma (section->sh_offset, LONG_HEX);
5608 printf (" %u\n ", section->sh_link);
5609 print_vma (section->sh_size, LONG_HEX);
5611 print_vma (section->sh_entsize, LONG_HEX);
5613 printf (" %-16u %lu\n",
5615 (unsigned long) section->sh_addralign);
5620 print_vma (section->sh_addr, LONG_HEX);
5621 if ((long) section->sh_offset == section->sh_offset)
5622 printf (" %8.8lx", (unsigned long) section->sh_offset);
5626 print_vma (section->sh_offset, LONG_HEX);
5629 print_vma (section->sh_size, LONG_HEX);
5631 print_vma (section->sh_entsize, LONG_HEX);
5633 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5635 printf (" %2u %3u %lu\n",
5638 (unsigned long) section->sh_addralign);
5641 if (do_section_details)
5642 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5645 if (!do_section_details)
5647 if (elf_header.e_machine == EM_X86_64
5648 || elf_header.e_machine == EM_L1OM
5649 || elf_header.e_machine == EM_K1OM)
5650 printf (_("Key to Flags:\n\
5651 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5652 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5653 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5655 printf (_("Key to Flags:\n\
5656 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5657 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5658 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5665 get_group_flags (unsigned int flags)
5667 static char buff[32];
5677 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5684 process_section_groups (FILE * file)
5686 Elf_Internal_Shdr * section;
5688 struct group * group;
5689 Elf_Internal_Shdr * symtab_sec;
5690 Elf_Internal_Shdr * strtab_sec;
5691 Elf_Internal_Sym * symtab;
5692 unsigned long num_syms;
5696 /* Don't process section groups unless needed. */
5697 if (!do_unwind && !do_section_groups)
5700 if (elf_header.e_shnum == 0)
5702 if (do_section_groups)
5703 printf (_("\nThere are no sections to group in this file.\n"));
5708 if (section_headers == NULL)
5710 error (_("Section headers are not available!\n"));
5711 /* PR 13622: This can happen with a corrupt ELF header. */
5715 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5716 sizeof (struct group *));
5718 if (section_headers_groups == NULL)
5720 error (_("Out of memory reading %u section group headers\n"),
5721 elf_header.e_shnum);
5725 /* Scan the sections for the group section. */
5727 for (i = 0, section = section_headers;
5728 i < elf_header.e_shnum;
5730 if (section->sh_type == SHT_GROUP)
5733 if (group_count == 0)
5735 if (do_section_groups)
5736 printf (_("\nThere are no section groups in this file.\n"));
5741 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5743 if (section_groups == NULL)
5745 error (_("Out of memory reading %lu groups\n"),
5746 (unsigned long) group_count);
5756 for (i = 0, section = section_headers, group = section_groups;
5757 i < elf_header.e_shnum;
5760 if (section->sh_type == SHT_GROUP)
5762 const char * name = printable_section_name (section);
5763 const char * group_name;
5764 unsigned char * start;
5765 unsigned char * indices;
5766 unsigned int entry, j, size;
5767 Elf_Internal_Shdr * sec;
5768 Elf_Internal_Sym * sym;
5770 /* Get the symbol table. */
5771 if (section->sh_link >= elf_header.e_shnum
5772 || ((sec = section_headers + section->sh_link)->sh_type
5775 error (_("Bad sh_link in group section `%s'\n"), name);
5779 if (symtab_sec != sec)
5784 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5789 error (_("Corrupt header in group section `%s'\n"), name);
5793 if (section->sh_info >= num_syms)
5795 error (_("Bad sh_info in group section `%s'\n"), name);
5799 sym = symtab + section->sh_info;
5801 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5803 if (sym->st_shndx == 0
5804 || sym->st_shndx >= elf_header.e_shnum)
5806 error (_("Bad sh_info in group section `%s'\n"), name);
5810 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5819 /* Get the string table. */
5820 if (symtab_sec->sh_link >= elf_header.e_shnum)
5829 != (sec = section_headers + symtab_sec->sh_link))
5835 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5836 1, strtab_sec->sh_size,
5838 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5840 group_name = sym->st_name < strtab_size
5841 ? strtab + sym->st_name : _("<corrupt>");
5844 /* PR 17531: file: loop. */
5845 if (section->sh_entsize > section->sh_size)
5847 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5848 printable_section_name (section),
5849 (unsigned long) section->sh_entsize,
5850 (unsigned long) section->sh_size);
5854 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5855 1, section->sh_size,
5861 size = (section->sh_size / section->sh_entsize) - 1;
5862 entry = byte_get (indices, 4);
5865 if (do_section_groups)
5867 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5868 get_group_flags (entry), i, name, group_name, size);
5870 printf (_(" [Index] Name\n"));
5873 group->group_index = i;
5875 for (j = 0; j < size; j++)
5877 struct group_list * g;
5879 entry = byte_get (indices, 4);
5882 if (entry >= elf_header.e_shnum)
5884 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5885 entry, i, elf_header.e_shnum - 1);
5889 if (section_headers_groups [entry] != NULL)
5893 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5895 section_headers_groups [entry]->group_index);
5900 /* Intel C/C++ compiler may put section 0 in a
5901 section group. We just warn it the first time
5902 and ignore it afterwards. */
5903 static int warned = 0;
5906 error (_("section 0 in group section [%5u]\n"),
5907 section_headers_groups [entry]->group_index);
5913 section_headers_groups [entry] = group;
5915 if (do_section_groups)
5917 sec = section_headers + entry;
5918 printf (" [%5u] %s\n", entry, printable_section_name (sec));
5921 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5922 g->section_index = entry;
5923 g->next = group->root;
5941 /* Data used to display dynamic fixups. */
5943 struct ia64_vms_dynfixup
5945 bfd_vma needed_ident; /* Library ident number. */
5946 bfd_vma needed; /* Index in the dstrtab of the library name. */
5947 bfd_vma fixup_needed; /* Index of the library. */
5948 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5949 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5952 /* Data used to display dynamic relocations. */
5954 struct ia64_vms_dynimgrela
5956 bfd_vma img_rela_cnt; /* Number of relocations. */
5957 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5960 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5964 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5965 const char *strtab, unsigned int strtab_sz)
5967 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5969 const char *lib_name;
5971 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5972 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5973 _("dynamic section image fixups"));
5977 if (fixup->needed < strtab_sz)
5978 lib_name = strtab + fixup->needed;
5981 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5982 (unsigned long) fixup->needed);
5985 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5986 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5988 (_("Seg Offset Type SymVec DataType\n"));
5990 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5995 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5996 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5997 type = BYTE_GET (imfs [i].type);
5998 rtype = elf_ia64_reloc_type (type);
6000 printf (" 0x%08x ", type);
6002 printf (" %-32s ", rtype);
6003 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6004 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6010 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6013 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6015 Elf64_External_VMS_IMAGE_RELA *imrs;
6018 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6019 1, imgrela->img_rela_cnt * sizeof (*imrs),
6020 _("dynamic section image relocations"));
6024 printf (_("\nImage relocs\n"));
6026 (_("Seg Offset Type Addend Seg Sym Off\n"));
6028 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6033 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6034 printf ("%08" BFD_VMA_FMT "x ",
6035 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6036 type = BYTE_GET (imrs [i].type);
6037 rtype = elf_ia64_reloc_type (type);
6039 printf ("0x%08x ", type);
6041 printf ("%-31s ", rtype);
6042 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6043 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6044 printf ("%08" BFD_VMA_FMT "x\n",
6045 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6051 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6054 process_ia64_vms_dynamic_relocs (FILE *file)
6056 struct ia64_vms_dynfixup fixup;
6057 struct ia64_vms_dynimgrela imgrela;
6058 Elf_Internal_Dyn *entry;
6060 bfd_vma strtab_off = 0;
6061 bfd_vma strtab_sz = 0;
6062 char *strtab = NULL;
6064 memset (&fixup, 0, sizeof (fixup));
6065 memset (&imgrela, 0, sizeof (imgrela));
6067 /* Note: the order of the entries is specified by the OpenVMS specs. */
6068 for (entry = dynamic_section;
6069 entry < dynamic_section + dynamic_nent;
6072 switch (entry->d_tag)
6074 case DT_IA_64_VMS_STRTAB_OFFSET:
6075 strtab_off = entry->d_un.d_val;
6078 strtab_sz = entry->d_un.d_val;
6080 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6081 1, strtab_sz, _("dynamic string section"));
6084 case DT_IA_64_VMS_NEEDED_IDENT:
6085 fixup.needed_ident = entry->d_un.d_val;
6088 fixup.needed = entry->d_un.d_val;
6090 case DT_IA_64_VMS_FIXUP_NEEDED:
6091 fixup.fixup_needed = entry->d_un.d_val;
6093 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6094 fixup.fixup_rela_cnt = entry->d_un.d_val;
6096 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6097 fixup.fixup_rela_off = entry->d_un.d_val;
6099 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6102 case DT_IA_64_VMS_IMG_RELA_CNT:
6103 imgrela.img_rela_cnt = entry->d_un.d_val;
6105 case DT_IA_64_VMS_IMG_RELA_OFF:
6106 imgrela.img_rela_off = entry->d_un.d_val;
6108 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6128 } dynamic_relocations [] =
6130 { "REL", DT_REL, DT_RELSZ, FALSE },
6131 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6132 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6135 /* Process the reloc section. */
6138 process_relocs (FILE * file)
6140 unsigned long rel_size;
6141 unsigned long rel_offset;
6147 if (do_using_dynamic)
6151 int has_dynamic_reloc;
6154 has_dynamic_reloc = 0;
6156 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6158 is_rela = dynamic_relocations [i].rela;
6159 name = dynamic_relocations [i].name;
6160 rel_size = dynamic_info [dynamic_relocations [i].size];
6161 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6163 has_dynamic_reloc |= rel_size;
6165 if (is_rela == UNKNOWN)
6167 if (dynamic_relocations [i].reloc == DT_JMPREL)
6168 switch (dynamic_info[DT_PLTREL])
6182 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6183 name, rel_offset, rel_size);
6185 dump_relocations (file,
6186 offset_from_vma (file, rel_offset, rel_size),
6188 dynamic_symbols, num_dynamic_syms,
6189 dynamic_strings, dynamic_strings_length,
6195 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6197 if (! has_dynamic_reloc)
6198 printf (_("\nThere are no dynamic relocations in this file.\n"));
6202 Elf_Internal_Shdr * section;
6206 for (i = 0, section = section_headers;
6207 i < elf_header.e_shnum;
6210 if ( section->sh_type != SHT_RELA
6211 && section->sh_type != SHT_REL)
6214 rel_offset = section->sh_offset;
6215 rel_size = section->sh_size;
6219 Elf_Internal_Shdr * strsec;
6222 printf (_("\nRelocation section "));
6224 if (string_table == NULL)
6225 printf ("%d", section->sh_name);
6227 printf ("'%s'", printable_section_name (section));
6229 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6230 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6232 is_rela = section->sh_type == SHT_RELA;
6234 if (section->sh_link != 0
6235 && section->sh_link < elf_header.e_shnum)
6237 Elf_Internal_Shdr * symsec;
6238 Elf_Internal_Sym * symtab;
6239 unsigned long nsyms;
6240 unsigned long strtablen = 0;
6241 char * strtab = NULL;
6243 symsec = section_headers + section->sh_link;
6244 if (symsec->sh_type != SHT_SYMTAB
6245 && symsec->sh_type != SHT_DYNSYM)
6248 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6253 if (symsec->sh_link != 0
6254 && symsec->sh_link < elf_header.e_shnum)
6256 strsec = section_headers + symsec->sh_link;
6258 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6261 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6264 dump_relocations (file, rel_offset, rel_size,
6265 symtab, nsyms, strtab, strtablen,
6267 symsec->sh_type == SHT_DYNSYM);
6273 dump_relocations (file, rel_offset, rel_size,
6274 NULL, 0, NULL, 0, is_rela, 0);
6281 printf (_("\nThere are no relocations in this file.\n"));
6287 /* Process the unwind section. */
6289 #include "unwind-ia64.h"
6291 /* An absolute address consists of a section and an offset. If the
6292 section is NULL, the offset itself is the address, otherwise, the
6293 address equals to LOAD_ADDRESS(section) + offset. */
6297 unsigned short section;
6301 #define ABSADDR(a) \
6303 ? section_headers [(a).section].sh_addr + (a).offset \
6306 struct ia64_unw_table_entry
6308 struct absaddr start;
6310 struct absaddr info;
6313 struct ia64_unw_aux_info
6316 struct ia64_unw_table_entry *table; /* Unwind table. */
6317 unsigned long table_len; /* Length of unwind table. */
6318 unsigned char * info; /* Unwind info. */
6319 unsigned long info_size; /* Size of unwind info. */
6320 bfd_vma info_addr; /* starting address of unwind info. */
6321 bfd_vma seg_base; /* Starting address of segment. */
6322 Elf_Internal_Sym * symtab; /* The symbol table. */
6323 unsigned long nsyms; /* Number of symbols. */
6324 char * strtab; /* The string table. */
6325 unsigned long strtab_size; /* Size of string table. */
6329 find_symbol_for_address (Elf_Internal_Sym * symtab,
6330 unsigned long nsyms,
6331 const char * strtab,
6332 unsigned long strtab_size,
6333 struct absaddr addr,
6334 const char ** symname,
6337 bfd_vma dist = 0x100000;
6338 Elf_Internal_Sym * sym;
6339 Elf_Internal_Sym * best = NULL;
6342 REMOVE_ARCH_BITS (addr.offset);
6344 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6346 bfd_vma value = sym->st_value;
6348 REMOVE_ARCH_BITS (value);
6350 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6351 && sym->st_name != 0
6352 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6353 && addr.offset >= value
6354 && addr.offset - value < dist)
6357 dist = addr.offset - value;
6365 *symname = (best->st_name >= strtab_size
6366 ? _("<corrupt>") : strtab + best->st_name);
6372 *offset = addr.offset;
6376 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6378 struct ia64_unw_table_entry * tp;
6381 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6385 const unsigned char * dp;
6386 const unsigned char * head;
6387 const char * procname;
6389 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6390 aux->strtab_size, tp->start, &procname, &offset);
6392 fputs ("\n<", stdout);
6396 fputs (procname, stdout);
6399 printf ("+%lx", (unsigned long) offset);
6402 fputs (">: [", stdout);
6403 print_vma (tp->start.offset, PREFIX_HEX);
6404 fputc ('-', stdout);
6405 print_vma (tp->end.offset, PREFIX_HEX);
6406 printf ("], info at +0x%lx\n",
6407 (unsigned long) (tp->info.offset - aux->seg_base));
6409 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6410 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6412 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6413 (unsigned) UNW_VER (stamp),
6414 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6415 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6416 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6417 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6419 if (UNW_VER (stamp) != 1)
6421 printf (_("\tUnknown version.\n"));
6426 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6427 dp = unw_decode (dp, in_body, & in_body);
6432 slurp_ia64_unwind_table (FILE * file,
6433 struct ia64_unw_aux_info * aux,
6434 Elf_Internal_Shdr * sec)
6436 unsigned long size, nrelas, i;
6437 Elf_Internal_Phdr * seg;
6438 struct ia64_unw_table_entry * tep;
6439 Elf_Internal_Shdr * relsec;
6440 Elf_Internal_Rela * rela;
6441 Elf_Internal_Rela * rp;
6442 unsigned char * table;
6444 Elf_Internal_Sym * sym;
6445 const char * relname;
6447 /* First, find the starting address of the segment that includes
6450 if (elf_header.e_phnum)
6452 if (! get_program_headers (file))
6455 for (seg = program_headers;
6456 seg < program_headers + elf_header.e_phnum;
6459 if (seg->p_type != PT_LOAD)
6462 if (sec->sh_addr >= seg->p_vaddr
6463 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6465 aux->seg_base = seg->p_vaddr;
6471 /* Second, build the unwind table from the contents of the unwind section: */
6472 size = sec->sh_size;
6473 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6478 aux->table = (struct ia64_unw_table_entry *)
6479 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6481 for (tp = table; tp < table + size; ++tep)
6483 tep->start.section = SHN_UNDEF;
6484 tep->end.section = SHN_UNDEF;
6485 tep->info.section = SHN_UNDEF;
6486 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6487 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6488 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6489 tep->start.offset += aux->seg_base;
6490 tep->end.offset += aux->seg_base;
6491 tep->info.offset += aux->seg_base;
6495 /* Third, apply any relocations to the unwind table: */
6496 for (relsec = section_headers;
6497 relsec < section_headers + elf_header.e_shnum;
6500 if (relsec->sh_type != SHT_RELA
6501 || relsec->sh_info >= elf_header.e_shnum
6502 || section_headers + relsec->sh_info != sec)
6505 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6509 for (rp = rela; rp < rela + nrelas; ++rp)
6511 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6512 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6514 if (! const_strneq (relname, "R_IA64_SEGREL"))
6516 warn (_("Skipping unexpected relocation type %s\n"), relname);
6520 i = rp->r_offset / (3 * eh_addr_size);
6522 switch (rp->r_offset/eh_addr_size % 3)
6525 aux->table[i].start.section = sym->st_shndx;
6526 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6529 aux->table[i].end.section = sym->st_shndx;
6530 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6533 aux->table[i].info.section = sym->st_shndx;
6534 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6544 aux->table_len = size / (3 * eh_addr_size);
6549 ia64_process_unwind (FILE * file)
6551 Elf_Internal_Shdr * sec;
6552 Elf_Internal_Shdr * unwsec = NULL;
6553 Elf_Internal_Shdr * strsec;
6554 unsigned long i, unwcount = 0, unwstart = 0;
6555 struct ia64_unw_aux_info aux;
6557 memset (& aux, 0, sizeof (aux));
6559 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6561 if (sec->sh_type == SHT_SYMTAB
6562 && sec->sh_link < elf_header.e_shnum)
6564 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6566 strsec = section_headers + sec->sh_link;
6567 if (aux.strtab != NULL)
6569 error (_("Multiple auxillary string tables encountered\n"));
6572 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6575 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6577 else if (sec->sh_type == SHT_IA_64_UNWIND)
6582 printf (_("\nThere are no unwind sections in this file.\n"));
6584 while (unwcount-- > 0)
6589 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6590 i < elf_header.e_shnum; ++i, ++sec)
6591 if (sec->sh_type == SHT_IA_64_UNWIND)
6596 /* We have already counted the number of SHT_IA64_UNWIND
6597 sections so the loop above should never fail. */
6598 assert (unwsec != NULL);
6601 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6603 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6605 /* We need to find which section group it is in. */
6606 struct group_list * g;
6608 if (section_headers_groups == NULL
6609 || section_headers_groups [i] == NULL)
6610 i = elf_header.e_shnum;
6613 g = section_headers_groups [i]->root;
6615 for (; g != NULL; g = g->next)
6617 sec = section_headers + g->section_index;
6619 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6624 i = elf_header.e_shnum;
6627 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6629 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6630 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6631 suffix = SECTION_NAME (unwsec) + len;
6632 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6634 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6635 && streq (SECTION_NAME (sec) + len2, suffix))
6640 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6641 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6642 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6643 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6645 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6646 suffix = SECTION_NAME (unwsec) + len;
6647 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6649 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6650 && streq (SECTION_NAME (sec) + len2, suffix))
6654 if (i == elf_header.e_shnum)
6656 printf (_("\nCould not find unwind info section for "));
6658 if (string_table == NULL)
6659 printf ("%d", unwsec->sh_name);
6661 printf ("'%s'", printable_section_name (unwsec));
6665 aux.info_addr = sec->sh_addr;
6666 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6669 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6671 printf (_("\nUnwind section "));
6673 if (string_table == NULL)
6674 printf ("%d", unwsec->sh_name);
6676 printf ("'%s'", printable_section_name (unwsec));
6678 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6679 (unsigned long) unwsec->sh_offset,
6680 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6682 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6684 if (aux.table_len > 0)
6685 dump_ia64_unwind (& aux);
6688 free ((char *) aux.table);
6690 free ((char *) aux.info);
6699 free ((char *) aux.strtab);
6702 struct hppa_unw_table_entry
6704 struct absaddr start;
6706 unsigned int Cannot_unwind:1; /* 0 */
6707 unsigned int Millicode:1; /* 1 */
6708 unsigned int Millicode_save_sr0:1; /* 2 */
6709 unsigned int Region_description:2; /* 3..4 */
6710 unsigned int reserved1:1; /* 5 */
6711 unsigned int Entry_SR:1; /* 6 */
6712 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6713 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6714 unsigned int Args_stored:1; /* 16 */
6715 unsigned int Variable_Frame:1; /* 17 */
6716 unsigned int Separate_Package_Body:1; /* 18 */
6717 unsigned int Frame_Extension_Millicode:1; /* 19 */
6718 unsigned int Stack_Overflow_Check:1; /* 20 */
6719 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6720 unsigned int Ada_Region:1; /* 22 */
6721 unsigned int cxx_info:1; /* 23 */
6722 unsigned int cxx_try_catch:1; /* 24 */
6723 unsigned int sched_entry_seq:1; /* 25 */
6724 unsigned int reserved2:1; /* 26 */
6725 unsigned int Save_SP:1; /* 27 */
6726 unsigned int Save_RP:1; /* 28 */
6727 unsigned int Save_MRP_in_frame:1; /* 29 */
6728 unsigned int extn_ptr_defined:1; /* 30 */
6729 unsigned int Cleanup_defined:1; /* 31 */
6731 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6732 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6733 unsigned int Large_frame:1; /* 2 */
6734 unsigned int Pseudo_SP_Set:1; /* 3 */
6735 unsigned int reserved4:1; /* 4 */
6736 unsigned int Total_frame_size:27; /* 5..31 */
6739 struct hppa_unw_aux_info
6741 struct hppa_unw_table_entry *table; /* Unwind table. */
6742 unsigned long table_len; /* Length of unwind table. */
6743 bfd_vma seg_base; /* Starting address of segment. */
6744 Elf_Internal_Sym * symtab; /* The symbol table. */
6745 unsigned long nsyms; /* Number of symbols. */
6746 char * strtab; /* The string table. */
6747 unsigned long strtab_size; /* Size of string table. */
6751 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6753 struct hppa_unw_table_entry * tp;
6755 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6758 const char * procname;
6760 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6761 aux->strtab_size, tp->start, &procname,
6764 fputs ("\n<", stdout);
6768 fputs (procname, stdout);
6771 printf ("+%lx", (unsigned long) offset);
6774 fputs (">: [", stdout);
6775 print_vma (tp->start.offset, PREFIX_HEX);
6776 fputc ('-', stdout);
6777 print_vma (tp->end.offset, PREFIX_HEX);
6780 #define PF(_m) if (tp->_m) printf (#_m " ");
6781 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6784 PF(Millicode_save_sr0);
6785 /* PV(Region_description); */
6791 PF(Separate_Package_Body);
6792 PF(Frame_Extension_Millicode);
6793 PF(Stack_Overflow_Check);
6794 PF(Two_Instruction_SP_Increment);
6798 PF(sched_entry_seq);
6801 PF(Save_MRP_in_frame);
6802 PF(extn_ptr_defined);
6803 PF(Cleanup_defined);
6804 PF(MPE_XL_interrupt_marker);
6805 PF(HP_UX_interrupt_marker);
6808 PV(Total_frame_size);
6817 slurp_hppa_unwind_table (FILE * file,
6818 struct hppa_unw_aux_info * aux,
6819 Elf_Internal_Shdr * sec)
6821 unsigned long size, unw_ent_size, nentries, nrelas, i;
6822 Elf_Internal_Phdr * seg;
6823 struct hppa_unw_table_entry * tep;
6824 Elf_Internal_Shdr * relsec;
6825 Elf_Internal_Rela * rela;
6826 Elf_Internal_Rela * rp;
6827 unsigned char * table;
6829 Elf_Internal_Sym * sym;
6830 const char * relname;
6832 /* First, find the starting address of the segment that includes
6835 if (elf_header.e_phnum)
6837 if (! get_program_headers (file))
6840 for (seg = program_headers;
6841 seg < program_headers + elf_header.e_phnum;
6844 if (seg->p_type != PT_LOAD)
6847 if (sec->sh_addr >= seg->p_vaddr
6848 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6850 aux->seg_base = seg->p_vaddr;
6856 /* Second, build the unwind table from the contents of the unwind
6858 size = sec->sh_size;
6859 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6865 nentries = size / unw_ent_size;
6866 size = unw_ent_size * nentries;
6868 tep = aux->table = (struct hppa_unw_table_entry *)
6869 xcmalloc (nentries, sizeof (aux->table[0]));
6871 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6873 unsigned int tmp1, tmp2;
6875 tep->start.section = SHN_UNDEF;
6876 tep->end.section = SHN_UNDEF;
6878 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6879 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6880 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6881 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6883 tep->start.offset += aux->seg_base;
6884 tep->end.offset += aux->seg_base;
6886 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6887 tep->Millicode = (tmp1 >> 30) & 0x1;
6888 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6889 tep->Region_description = (tmp1 >> 27) & 0x3;
6890 tep->reserved1 = (tmp1 >> 26) & 0x1;
6891 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6892 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6893 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6894 tep->Args_stored = (tmp1 >> 15) & 0x1;
6895 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6896 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6897 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6898 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6899 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6900 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6901 tep->cxx_info = (tmp1 >> 8) & 0x1;
6902 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6903 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6904 tep->reserved2 = (tmp1 >> 5) & 0x1;
6905 tep->Save_SP = (tmp1 >> 4) & 0x1;
6906 tep->Save_RP = (tmp1 >> 3) & 0x1;
6907 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6908 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6909 tep->Cleanup_defined = tmp1 & 0x1;
6911 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6912 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6913 tep->Large_frame = (tmp2 >> 29) & 0x1;
6914 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6915 tep->reserved4 = (tmp2 >> 27) & 0x1;
6916 tep->Total_frame_size = tmp2 & 0x7ffffff;
6920 /* Third, apply any relocations to the unwind table. */
6921 for (relsec = section_headers;
6922 relsec < section_headers + elf_header.e_shnum;
6925 if (relsec->sh_type != SHT_RELA
6926 || relsec->sh_info >= elf_header.e_shnum
6927 || section_headers + relsec->sh_info != sec)
6930 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6934 for (rp = rela; rp < rela + nrelas; ++rp)
6936 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6937 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6939 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6940 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6942 warn (_("Skipping unexpected relocation type %s\n"), relname);
6946 i = rp->r_offset / unw_ent_size;
6948 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6951 aux->table[i].start.section = sym->st_shndx;
6952 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6955 aux->table[i].end.section = sym->st_shndx;
6956 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6966 aux->table_len = nentries;
6972 hppa_process_unwind (FILE * file)
6974 struct hppa_unw_aux_info aux;
6975 Elf_Internal_Shdr * unwsec = NULL;
6976 Elf_Internal_Shdr * strsec;
6977 Elf_Internal_Shdr * sec;
6980 if (string_table == NULL)
6983 memset (& aux, 0, sizeof (aux));
6985 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6987 if (sec->sh_type == SHT_SYMTAB
6988 && sec->sh_link < elf_header.e_shnum)
6990 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6992 strsec = section_headers + sec->sh_link;
6993 if (aux.strtab != NULL)
6995 error (_("Multiple auxillary string tables encountered\n"));
6998 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7001 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7003 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7008 printf (_("\nThere are no unwind sections in this file.\n"));
7010 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7012 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7014 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7015 printable_section_name (sec),
7016 (unsigned long) sec->sh_offset,
7017 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7019 slurp_hppa_unwind_table (file, &aux, sec);
7020 if (aux.table_len > 0)
7021 dump_hppa_unwind (&aux);
7024 free ((char *) aux.table);
7032 free ((char *) aux.strtab);
7037 unsigned char * data; /* The unwind data. */
7038 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7039 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7040 unsigned long nrelas; /* The number of relocations. */
7041 unsigned int rel_type; /* REL or RELA ? */
7042 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7045 struct arm_unw_aux_info
7047 FILE * file; /* The file containing the unwind sections. */
7048 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7049 unsigned long nsyms; /* Number of symbols. */
7050 char * strtab; /* The file's string table. */
7051 unsigned long strtab_size; /* Size of string table. */
7055 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7056 bfd_vma fn, struct absaddr addr)
7058 const char *procname;
7061 if (addr.section == SHN_UNDEF)
7064 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7065 aux->strtab_size, addr, &procname,
7068 print_vma (fn, PREFIX_HEX);
7072 fputs (" <", stdout);
7073 fputs (procname, stdout);
7076 printf ("+0x%lx", (unsigned long) sym_offset);
7077 fputc ('>', stdout);
7084 arm_free_section (struct arm_section *arm_sec)
7086 if (arm_sec->data != NULL)
7087 free (arm_sec->data);
7089 if (arm_sec->rela != NULL)
7090 free (arm_sec->rela);
7093 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7094 cached section and install SEC instead.
7095 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7096 and return its valued in * WORDP, relocating if necessary.
7097 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7098 relocation's offset in ADDR.
7099 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7100 into the string table of the symbol associated with the reloc. If no
7101 reloc was applied store -1 there.
7102 5) Return TRUE upon success, FALSE otherwise. */
7105 get_unwind_section_word (struct arm_unw_aux_info * aux,
7106 struct arm_section * arm_sec,
7107 Elf_Internal_Shdr * sec,
7108 bfd_vma word_offset,
7109 unsigned int * wordp,
7110 struct absaddr * addr,
7113 Elf_Internal_Rela *rp;
7114 Elf_Internal_Sym *sym;
7115 const char * relname;
7117 bfd_boolean wrapped;
7119 if (sec == NULL || arm_sec == NULL)
7122 addr->section = SHN_UNDEF;
7125 if (sym_name != NULL)
7126 *sym_name = (bfd_vma) -1;
7128 /* If necessary, update the section cache. */
7129 if (sec != arm_sec->sec)
7131 Elf_Internal_Shdr *relsec;
7133 arm_free_section (arm_sec);
7136 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7137 sec->sh_size, _("unwind data"));
7138 arm_sec->rela = NULL;
7139 arm_sec->nrelas = 0;
7141 for (relsec = section_headers;
7142 relsec < section_headers + elf_header.e_shnum;
7145 if (relsec->sh_info >= elf_header.e_shnum
7146 || section_headers + relsec->sh_info != sec
7147 /* PR 15745: Check the section type as well. */
7148 || (relsec->sh_type != SHT_REL
7149 && relsec->sh_type != SHT_RELA))
7152 arm_sec->rel_type = relsec->sh_type;
7153 if (relsec->sh_type == SHT_REL)
7155 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7157 & arm_sec->rela, & arm_sec->nrelas))
7160 else /* relsec->sh_type == SHT_RELA */
7162 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7164 & arm_sec->rela, & arm_sec->nrelas))
7170 arm_sec->next_rela = arm_sec->rela;
7173 /* If there is no unwind data we can do nothing. */
7174 if (arm_sec->data == NULL)
7177 /* If the offset is invalid then fail. */
7178 if (word_offset > sec->sh_size - 4)
7181 /* Get the word at the required offset. */
7182 word = byte_get (arm_sec->data + word_offset, 4);
7184 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7185 if (arm_sec->rela == NULL)
7191 /* Look through the relocs to find the one that applies to the provided offset. */
7193 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7195 bfd_vma prelval, offset;
7197 if (rp->r_offset > word_offset && !wrapped)
7202 if (rp->r_offset > word_offset)
7205 if (rp->r_offset & 3)
7207 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7208 (unsigned long) rp->r_offset);
7212 if (rp->r_offset < word_offset)
7215 /* PR 17531: file: 027-161405-0.004 */
7216 if (aux->symtab == NULL)
7219 if (arm_sec->rel_type == SHT_REL)
7221 offset = word & 0x7fffffff;
7222 if (offset & 0x40000000)
7223 offset |= ~ (bfd_vma) 0x7fffffff;
7225 else if (arm_sec->rel_type == SHT_RELA)
7226 offset = rp->r_addend;
7229 error (_("Unknown section relocation type %d encountered\n"),
7234 /* PR 17531 file: 027-1241568-0.004. */
7235 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7237 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7238 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7242 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7243 offset += sym->st_value;
7244 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7246 /* Check that we are processing the expected reloc type. */
7247 if (elf_header.e_machine == EM_ARM)
7249 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7250 if (relname == NULL)
7252 warn (_("Skipping unknown ARM relocation type: %d\n"),
7253 (int) ELF32_R_TYPE (rp->r_info));
7257 if (streq (relname, "R_ARM_NONE"))
7260 if (! streq (relname, "R_ARM_PREL31"))
7262 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7266 else if (elf_header.e_machine == EM_TI_C6000)
7268 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7269 if (relname == NULL)
7271 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7272 (int) ELF32_R_TYPE (rp->r_info));
7276 if (streq (relname, "R_C6000_NONE"))
7279 if (! streq (relname, "R_C6000_PREL31"))
7281 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7289 /* This function currently only supports ARM and TI unwinders. */
7290 warn (_("Only TI and ARM unwinders are currently supported\n"));
7294 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7295 addr->section = sym->st_shndx;
7296 addr->offset = offset;
7299 * sym_name = sym->st_name;
7304 arm_sec->next_rela = rp;
7309 static const char *tic6x_unwind_regnames[16] =
7311 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7312 "A14", "A13", "A12", "A11", "A10",
7313 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7317 decode_tic6x_unwind_regmask (unsigned int mask)
7321 for (i = 12; mask; mask >>= 1, i--)
7325 fputs (tic6x_unwind_regnames[i], stdout);
7327 fputs (", ", stdout);
7333 if (remaining == 0 && more_words) \
7336 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7337 data_offset, & word, & addr, NULL)) \
7343 #define GET_OP(OP) \
7348 (OP) = word >> 24; \
7353 printf (_("[Truncated opcode]\n")); \
7356 printf ("0x%02x ", OP)
7359 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7360 unsigned int word, unsigned int remaining,
7361 unsigned int more_words,
7362 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7363 struct arm_section *data_arm_sec)
7365 struct absaddr addr;
7367 /* Decode the unwinding instructions. */
7370 unsigned int op, op2;
7379 printf (" 0x%02x ", op);
7381 if ((op & 0xc0) == 0x00)
7383 int offset = ((op & 0x3f) << 2) + 4;
7385 printf (" vsp = vsp + %d", offset);
7387 else if ((op & 0xc0) == 0x40)
7389 int offset = ((op & 0x3f) << 2) + 4;
7391 printf (" vsp = vsp - %d", offset);
7393 else if ((op & 0xf0) == 0x80)
7396 if (op == 0x80 && op2 == 0)
7397 printf (_("Refuse to unwind"));
7400 unsigned int mask = ((op & 0x0f) << 8) | op2;
7405 for (i = 0; i < 12; i++)
7406 if (mask & (1 << i))
7412 printf ("r%d", 4 + i);
7417 else if ((op & 0xf0) == 0x90)
7419 if (op == 0x9d || op == 0x9f)
7420 printf (_(" [Reserved]"));
7422 printf (" vsp = r%d", op & 0x0f);
7424 else if ((op & 0xf0) == 0xa0)
7426 int end = 4 + (op & 0x07);
7431 for (i = 4; i <= end; i++)
7447 else if (op == 0xb0)
7448 printf (_(" finish"));
7449 else if (op == 0xb1)
7452 if (op2 == 0 || (op2 & 0xf0) != 0)
7453 printf (_("[Spare]"));
7456 unsigned int mask = op2 & 0x0f;
7461 for (i = 0; i < 12; i++)
7462 if (mask & (1 << i))
7473 else if (op == 0xb2)
7475 unsigned char buf[9];
7476 unsigned int i, len;
7477 unsigned long offset;
7479 for (i = 0; i < sizeof (buf); i++)
7482 if ((buf[i] & 0x80) == 0)
7485 if (i == sizeof (buf))
7486 printf (_("corrupt change to vsp"));
7489 offset = read_uleb128 (buf, &len, buf + i + 1);
7490 assert (len == i + 1);
7491 offset = offset * 4 + 0x204;
7492 printf ("vsp = vsp + %ld", offset);
7495 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7497 unsigned int first, last;
7504 printf ("pop {D%d", first);
7506 printf ("-D%d", first + last);
7509 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7511 unsigned int count = op & 0x07;
7515 printf ("-D%d", 8 + count);
7518 else if (op >= 0xc0 && op <= 0xc5)
7520 unsigned int count = op & 0x07;
7522 printf (" pop {wR10");
7524 printf ("-wR%d", 10 + count);
7527 else if (op == 0xc6)
7529 unsigned int first, last;
7534 printf ("pop {wR%d", first);
7536 printf ("-wR%d", first + last);
7539 else if (op == 0xc7)
7542 if (op2 == 0 || (op2 & 0xf0) != 0)
7543 printf (_("[Spare]"));
7546 unsigned int mask = op2 & 0x0f;
7551 for (i = 0; i < 4; i++)
7552 if (mask & (1 << i))
7558 printf ("wCGR%d", i);
7564 printf (_(" [unsupported opcode]"));
7570 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7571 unsigned int word, unsigned int remaining,
7572 unsigned int more_words,
7573 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7574 struct arm_section *data_arm_sec)
7576 struct absaddr addr;
7578 /* Decode the unwinding instructions. */
7581 unsigned int op, op2;
7590 printf (" 0x%02x ", op);
7592 if ((op & 0xc0) == 0x00)
7594 int offset = ((op & 0x3f) << 3) + 8;
7595 printf (" sp = sp + %d", offset);
7597 else if ((op & 0xc0) == 0x80)
7600 if (op == 0x80 && op2 == 0)
7601 printf (_("Refuse to unwind"));
7604 unsigned int mask = ((op & 0x1f) << 8) | op2;
7606 printf ("pop compact {");
7610 decode_tic6x_unwind_regmask (mask);
7614 else if ((op & 0xf0) == 0xc0)
7622 unsigned int offset;
7626 /* Scan entire instruction first so that GET_OP output is not
7627 interleaved with disassembly. */
7629 for (i = 0; nregs < (op & 0xf); i++)
7635 regpos[nregs].offset = i * 2;
7636 regpos[nregs].reg = reg;
7643 regpos[nregs].offset = i * 2 + 1;
7644 regpos[nregs].reg = reg;
7649 printf (_("pop frame {"));
7651 for (i = i * 2; i > 0; i--)
7653 if (regpos[reg].offset == i - 1)
7655 name = tic6x_unwind_regnames[regpos[reg].reg];
7662 fputs (name, stdout);
7669 else if (op == 0xd0)
7670 printf (" MOV FP, SP");
7671 else if (op == 0xd1)
7672 printf (" __c6xabi_pop_rts");
7673 else if (op == 0xd2)
7675 unsigned char buf[9];
7676 unsigned int i, len;
7677 unsigned long offset;
7679 for (i = 0; i < sizeof (buf); i++)
7682 if ((buf[i] & 0x80) == 0)
7685 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7686 if (i == sizeof (buf))
7688 printf ("<corrupt sp adjust>\n");
7689 warn (_("Corrupt stack pointer adjustment detected\n"));
7693 offset = read_uleb128 (buf, &len, buf + i + 1);
7694 assert (len == i + 1);
7695 offset = offset * 8 + 0x408;
7696 printf (_("sp = sp + %ld"), offset);
7698 else if ((op & 0xf0) == 0xe0)
7700 if ((op & 0x0f) == 7)
7703 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7707 printf (_(" [unsupported opcode]"));
7714 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7718 offset = word & 0x7fffffff;
7719 if (offset & 0x40000000)
7720 offset |= ~ (bfd_vma) 0x7fffffff;
7722 if (elf_header.e_machine == EM_TI_C6000)
7725 return offset + where;
7729 decode_arm_unwind (struct arm_unw_aux_info * aux,
7731 unsigned int remaining,
7732 bfd_vma data_offset,
7733 Elf_Internal_Shdr * data_sec,
7734 struct arm_section * data_arm_sec)
7737 unsigned int more_words = 0;
7738 struct absaddr addr;
7739 bfd_vma sym_name = (bfd_vma) -1;
7743 /* Fetch the first word.
7744 Note - when decoding an object file the address extracted
7745 here will always be 0. So we also pass in the sym_name
7746 parameter so that we can find the symbol associated with
7747 the personality routine. */
7748 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7749 & word, & addr, & sym_name))
7755 if ((word & 0x80000000) == 0)
7757 /* Expand prel31 for personality routine. */
7759 const char *procname;
7761 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7762 printf (_(" Personality routine: "));
7764 && addr.section == SHN_UNDEF && addr.offset == 0
7765 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7767 procname = aux->strtab + sym_name;
7768 print_vma (fn, PREFIX_HEX);
7771 fputs (" <", stdout);
7772 fputs (procname, stdout);
7773 fputc ('>', stdout);
7777 procname = arm_print_vma_and_name (aux, fn, addr);
7778 fputc ('\n', stdout);
7780 /* The GCC personality routines use the standard compact
7781 encoding, starting with one byte giving the number of
7783 if (procname != NULL
7784 && (const_strneq (procname, "__gcc_personality_v0")
7785 || const_strneq (procname, "__gxx_personality_v0")
7786 || const_strneq (procname, "__gcj_personality_v0")
7787 || const_strneq (procname, "__gnu_objc_personality_v0")))
7794 printf (_(" [Truncated data]\n"));
7797 more_words = word >> 24;
7807 /* ARM EHABI Section 6.3:
7809 An exception-handling table entry for the compact model looks like:
7813 1 0 index Data for personalityRoutine[index] */
7815 if (elf_header.e_machine == EM_ARM
7816 && (word & 0x70000000))
7817 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7819 per_index = (word >> 24) & 0x7f;
7820 printf (_(" Compact model index: %d\n"), per_index);
7827 else if (per_index < 3)
7829 more_words = (word >> 16) & 0xff;
7835 switch (elf_header.e_machine)
7840 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7841 data_offset, data_sec, data_arm_sec);
7845 warn (_("Unknown ARM compact model index encountered\n"));
7846 printf (_(" [reserved]\n"));
7853 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7854 data_offset, data_sec, data_arm_sec);
7856 else if (per_index < 5)
7858 if (((word >> 17) & 0x7f) == 0x7f)
7859 printf (_(" Restore stack from frame pointer\n"));
7861 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7862 printf (_(" Registers restored: "));
7864 printf (" (compact) ");
7865 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7867 printf (_(" Return register: %s\n"),
7868 tic6x_unwind_regnames[word & 0xf]);
7871 printf (_(" [reserved (%d)]\n"), per_index);
7875 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7876 elf_header.e_machine);
7879 /* Decode the descriptors. Not implemented. */
7883 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7885 struct arm_section exidx_arm_sec, extab_arm_sec;
7886 unsigned int i, exidx_len;
7888 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7889 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7890 exidx_len = exidx_sec->sh_size / 8;
7892 for (i = 0; i < exidx_len; i++)
7894 unsigned int exidx_fn, exidx_entry;
7895 struct absaddr fn_addr, entry_addr;
7898 fputc ('\n', stdout);
7900 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7901 8 * i, & exidx_fn, & fn_addr, NULL)
7902 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7903 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7905 arm_free_section (& exidx_arm_sec);
7906 arm_free_section (& extab_arm_sec);
7910 /* ARM EHABI, Section 5:
7911 An index table entry consists of 2 words.
7912 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7913 if (exidx_fn & 0x80000000)
7914 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7916 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7918 arm_print_vma_and_name (aux, fn, fn_addr);
7919 fputs (": ", stdout);
7921 if (exidx_entry == 1)
7923 print_vma (exidx_entry, PREFIX_HEX);
7924 fputs (" [cantunwind]\n", stdout);
7926 else if (exidx_entry & 0x80000000)
7928 print_vma (exidx_entry, PREFIX_HEX);
7929 fputc ('\n', stdout);
7930 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7934 bfd_vma table, table_offset = 0;
7935 Elf_Internal_Shdr *table_sec;
7937 fputs ("@", stdout);
7938 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7939 print_vma (table, PREFIX_HEX);
7942 /* Locate the matching .ARM.extab. */
7943 if (entry_addr.section != SHN_UNDEF
7944 && entry_addr.section < elf_header.e_shnum)
7946 table_sec = section_headers + entry_addr.section;
7947 table_offset = entry_addr.offset;
7951 table_sec = find_section_by_address (table);
7952 if (table_sec != NULL)
7953 table_offset = table - table_sec->sh_addr;
7955 if (table_sec == NULL)
7957 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7958 (unsigned long) table);
7961 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7968 arm_free_section (&exidx_arm_sec);
7969 arm_free_section (&extab_arm_sec);
7972 /* Used for both ARM and C6X unwinding tables. */
7975 arm_process_unwind (FILE *file)
7977 struct arm_unw_aux_info aux;
7978 Elf_Internal_Shdr *unwsec = NULL;
7979 Elf_Internal_Shdr *strsec;
7980 Elf_Internal_Shdr *sec;
7982 unsigned int sec_type;
7984 switch (elf_header.e_machine)
7987 sec_type = SHT_ARM_EXIDX;
7991 sec_type = SHT_C6000_UNWIND;
7995 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
7996 elf_header.e_machine);
8000 if (string_table == NULL)
8003 memset (& aux, 0, sizeof (aux));
8006 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8008 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8010 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8012 strsec = section_headers + sec->sh_link;
8014 /* PR binutils/17531 file: 011-12666-0.004. */
8015 if (aux.strtab != NULL)
8017 error (_("Multiple string tables found in file.\n"));
8020 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8021 1, strsec->sh_size, _("string table"));
8022 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8024 else if (sec->sh_type == sec_type)
8029 printf (_("\nThere are no unwind sections in this file.\n"));
8031 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8033 if (sec->sh_type == sec_type)
8035 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8036 printable_section_name (sec),
8037 (unsigned long) sec->sh_offset,
8038 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8040 dump_arm_unwind (&aux, sec);
8047 free ((char *) aux.strtab);
8051 process_unwind (FILE * file)
8053 struct unwind_handler
8056 void (* handler)(FILE *);
8059 { EM_ARM, arm_process_unwind },
8060 { EM_IA_64, ia64_process_unwind },
8061 { EM_PARISC, hppa_process_unwind },
8062 { EM_TI_C6000, arm_process_unwind },
8070 for (i = 0; handlers[i].handler != NULL; i++)
8071 if (elf_header.e_machine == handlers[i].machtype)
8073 handlers[i].handler (file);
8077 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8078 get_machine_name (elf_header.e_machine));
8082 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8084 switch (entry->d_tag)
8087 if (entry->d_un.d_val == 0)
8091 static const char * opts[] =
8093 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8094 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8095 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8096 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8102 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8103 if (entry->d_un.d_val & (1 << cnt))
8105 printf ("%s%s", first ? "" : " ", opts[cnt]);
8111 case DT_MIPS_IVERSION:
8112 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8113 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8117 sprintf_vma (buf, entry->d_un.d_ptr);
8118 /* Note: coded this way so that there is a single string for translation. */
8119 printf (_("<corrupt: %s>"), buf);
8123 case DT_MIPS_TIME_STAMP:
8128 time_t atime = entry->d_un.d_val;
8129 tmp = gmtime (&atime);
8130 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8131 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8132 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8133 printf (_("Time Stamp: %s"), timebuf);
8137 case DT_MIPS_RLD_VERSION:
8138 case DT_MIPS_LOCAL_GOTNO:
8139 case DT_MIPS_CONFLICTNO:
8140 case DT_MIPS_LIBLISTNO:
8141 case DT_MIPS_SYMTABNO:
8142 case DT_MIPS_UNREFEXTNO:
8143 case DT_MIPS_HIPAGENO:
8144 case DT_MIPS_DELTA_CLASS_NO:
8145 case DT_MIPS_DELTA_INSTANCE_NO:
8146 case DT_MIPS_DELTA_RELOC_NO:
8147 case DT_MIPS_DELTA_SYM_NO:
8148 case DT_MIPS_DELTA_CLASSSYM_NO:
8149 case DT_MIPS_COMPACT_SIZE:
8150 print_vma (entry->d_un.d_ptr, DEC);
8154 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8160 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8162 switch (entry->d_tag)
8164 case DT_HP_DLD_FLAGS:
8173 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8174 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8175 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8176 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8177 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8178 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8179 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8180 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8181 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8182 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8183 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8184 { DT_HP_GST, "HP_GST" },
8185 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8186 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8187 { DT_HP_NODELETE, "HP_NODELETE" },
8188 { DT_HP_GROUP, "HP_GROUP" },
8189 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8193 bfd_vma val = entry->d_un.d_val;
8195 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8196 if (val & flags[cnt].bit)
8200 fputs (flags[cnt].str, stdout);
8202 val ^= flags[cnt].bit;
8205 if (val != 0 || first)
8209 print_vma (val, HEX);
8215 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8223 /* VMS vs Unix time offset and factor. */
8225 #define VMS_EPOCH_OFFSET 35067168000000000LL
8226 #define VMS_GRANULARITY_FACTOR 10000000
8228 /* Display a VMS time in a human readable format. */
8231 print_vms_time (bfd_int64_t vmstime)
8236 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8237 tm = gmtime (&unxtime);
8238 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8239 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8240 tm->tm_hour, tm->tm_min, tm->tm_sec);
8245 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8247 switch (entry->d_tag)
8249 case DT_IA_64_PLT_RESERVE:
8250 /* First 3 slots reserved. */
8251 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8253 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8256 case DT_IA_64_VMS_LINKTIME:
8258 print_vms_time (entry->d_un.d_val);
8262 case DT_IA_64_VMS_LNKFLAGS:
8263 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8264 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8265 printf (" CALL_DEBUG");
8266 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8267 printf (" NOP0BUFS");
8268 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8269 printf (" P0IMAGE");
8270 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8271 printf (" MKTHREADS");
8272 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8273 printf (" UPCALLS");
8274 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8276 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8277 printf (" INITIALIZE");
8278 if (entry->d_un.d_val & VMS_LF_MAIN)
8280 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8281 printf (" EXE_INIT");
8282 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8283 printf (" TBK_IN_IMG");
8284 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8285 printf (" DBG_IN_IMG");
8286 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8287 printf (" TBK_IN_DSF");
8288 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8289 printf (" DBG_IN_DSF");
8290 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8291 printf (" SIGNATURES");
8292 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8293 printf (" REL_SEG_OFF");
8297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8304 get_32bit_dynamic_section (FILE * file)
8306 Elf32_External_Dyn * edyn;
8307 Elf32_External_Dyn * ext;
8308 Elf_Internal_Dyn * entry;
8310 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8311 dynamic_size, _("dynamic section"));
8315 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8316 might not have the luxury of section headers. Look for the DT_NULL
8317 terminator to determine the number of entries. */
8318 for (ext = edyn, dynamic_nent = 0;
8319 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8323 if (BYTE_GET (ext->d_tag) == DT_NULL)
8327 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8329 if (dynamic_section == NULL)
8331 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8332 (unsigned long) dynamic_nent);
8337 for (ext = edyn, entry = dynamic_section;
8338 entry < dynamic_section + dynamic_nent;
8341 entry->d_tag = BYTE_GET (ext->d_tag);
8342 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8351 get_64bit_dynamic_section (FILE * file)
8353 Elf64_External_Dyn * edyn;
8354 Elf64_External_Dyn * ext;
8355 Elf_Internal_Dyn * entry;
8357 /* Read in the data. */
8358 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8359 dynamic_size, _("dynamic section"));
8363 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8364 might not have the luxury of section headers. Look for the DT_NULL
8365 terminator to determine the number of entries. */
8366 for (ext = edyn, dynamic_nent = 0;
8367 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8368 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8372 if (BYTE_GET (ext->d_tag) == DT_NULL)
8376 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8378 if (dynamic_section == NULL)
8380 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8381 (unsigned long) dynamic_nent);
8386 /* Convert from external to internal formats. */
8387 for (ext = edyn, entry = dynamic_section;
8388 entry < dynamic_section + dynamic_nent;
8391 entry->d_tag = BYTE_GET (ext->d_tag);
8392 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8401 print_dynamic_flags (bfd_vma flags)
8409 flag = flags & - flags;
8419 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8420 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8421 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8422 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8423 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8424 default: fputs (_("unknown"), stdout); break;
8430 /* Parse and display the contents of the dynamic section. */
8433 process_dynamic_section (FILE * file)
8435 Elf_Internal_Dyn * entry;
8437 if (dynamic_size == 0)
8440 printf (_("\nThere is no dynamic section in this file.\n"));
8447 if (! get_32bit_dynamic_section (file))
8450 else if (! get_64bit_dynamic_section (file))
8453 /* Find the appropriate symbol table. */
8454 if (dynamic_symbols == NULL)
8456 for (entry = dynamic_section;
8457 entry < dynamic_section + dynamic_nent;
8460 Elf_Internal_Shdr section;
8462 if (entry->d_tag != DT_SYMTAB)
8465 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8467 /* Since we do not know how big the symbol table is,
8468 we default to reading in the entire file (!) and
8469 processing that. This is overkill, I know, but it
8471 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8473 if (archive_file_offset != 0)
8474 section.sh_size = archive_file_size - section.sh_offset;
8477 if (fseek (file, 0, SEEK_END))
8478 error (_("Unable to seek to end of file!\n"));
8480 section.sh_size = ftell (file) - section.sh_offset;
8484 section.sh_entsize = sizeof (Elf32_External_Sym);
8486 section.sh_entsize = sizeof (Elf64_External_Sym);
8487 section.sh_name = string_table_length;
8489 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8490 if (num_dynamic_syms < 1)
8492 error (_("Unable to determine the number of symbols to load\n"));
8498 /* Similarly find a string table. */
8499 if (dynamic_strings == NULL)
8501 for (entry = dynamic_section;
8502 entry < dynamic_section + dynamic_nent;
8505 unsigned long offset;
8508 if (entry->d_tag != DT_STRTAB)
8511 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8513 /* Since we do not know how big the string table is,
8514 we default to reading in the entire file (!) and
8515 processing that. This is overkill, I know, but it
8518 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8520 if (archive_file_offset != 0)
8521 str_tab_len = archive_file_size - offset;
8524 if (fseek (file, 0, SEEK_END))
8525 error (_("Unable to seek to end of file\n"));
8526 str_tab_len = ftell (file) - offset;
8529 if (str_tab_len < 1)
8532 (_("Unable to determine the length of the dynamic string table\n"));
8536 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8538 _("dynamic string table"));
8539 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8544 /* And find the syminfo section if available. */
8545 if (dynamic_syminfo == NULL)
8547 unsigned long syminsz = 0;
8549 for (entry = dynamic_section;
8550 entry < dynamic_section + dynamic_nent;
8553 if (entry->d_tag == DT_SYMINENT)
8555 /* Note: these braces are necessary to avoid a syntax
8556 error from the SunOS4 C compiler. */
8557 /* PR binutils/17531: A corrupt file can trigger this test.
8558 So do not use an assert, instead generate an error message. */
8559 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8560 error (_("Bad value (%d) for SYMINENT entry\n"),
8561 (int) entry->d_un.d_val);
8563 else if (entry->d_tag == DT_SYMINSZ)
8564 syminsz = entry->d_un.d_val;
8565 else if (entry->d_tag == DT_SYMINFO)
8566 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8570 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8572 Elf_External_Syminfo * extsyminfo;
8573 Elf_External_Syminfo * extsym;
8574 Elf_Internal_Syminfo * syminfo;
8576 /* There is a syminfo section. Read the data. */
8577 extsyminfo = (Elf_External_Syminfo *)
8578 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8579 _("symbol information"));
8583 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8584 if (dynamic_syminfo == NULL)
8586 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8587 (unsigned long) syminsz);
8591 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8592 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8593 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8594 ++syminfo, ++extsym)
8596 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8597 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8604 if (do_dynamic && dynamic_addr)
8605 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8606 dynamic_addr, (unsigned long) dynamic_nent);
8608 printf (_(" Tag Type Name/Value\n"));
8610 for (entry = dynamic_section;
8611 entry < dynamic_section + dynamic_nent;
8619 print_vma (entry->d_tag, FULL_HEX);
8620 dtype = get_dynamic_type (entry->d_tag);
8621 printf (" (%s)%*s", dtype,
8622 ((is_32bit_elf ? 27 : 19)
8623 - (int) strlen (dtype)),
8627 switch (entry->d_tag)
8631 print_dynamic_flags (entry->d_un.d_val);
8641 switch (entry->d_tag)
8644 printf (_("Auxiliary library"));
8648 printf (_("Filter library"));
8652 printf (_("Configuration file"));
8656 printf (_("Dependency audit library"));
8660 printf (_("Audit library"));
8664 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8665 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8669 print_vma (entry->d_un.d_val, PREFIX_HEX);
8678 printf (_("Flags:"));
8680 if (entry->d_un.d_val == 0)
8681 printf (_(" None\n"));
8684 unsigned long int val = entry->d_un.d_val;
8686 if (val & DTF_1_PARINIT)
8688 printf (" PARINIT");
8689 val ^= DTF_1_PARINIT;
8691 if (val & DTF_1_CONFEXP)
8693 printf (" CONFEXP");
8694 val ^= DTF_1_CONFEXP;
8697 printf (" %lx", val);
8706 printf (_("Flags:"));
8708 if (entry->d_un.d_val == 0)
8709 printf (_(" None\n"));
8712 unsigned long int val = entry->d_un.d_val;
8714 if (val & DF_P1_LAZYLOAD)
8716 printf (" LAZYLOAD");
8717 val ^= DF_P1_LAZYLOAD;
8719 if (val & DF_P1_GROUPPERM)
8721 printf (" GROUPPERM");
8722 val ^= DF_P1_GROUPPERM;
8725 printf (" %lx", val);
8734 printf (_("Flags:"));
8735 if (entry->d_un.d_val == 0)
8736 printf (_(" None\n"));
8739 unsigned long int val = entry->d_un.d_val;
8746 if (val & DF_1_GLOBAL)
8751 if (val & DF_1_GROUP)
8756 if (val & DF_1_NODELETE)
8758 printf (" NODELETE");
8759 val ^= DF_1_NODELETE;
8761 if (val & DF_1_LOADFLTR)
8763 printf (" LOADFLTR");
8764 val ^= DF_1_LOADFLTR;
8766 if (val & DF_1_INITFIRST)
8768 printf (" INITFIRST");
8769 val ^= DF_1_INITFIRST;
8771 if (val & DF_1_NOOPEN)
8776 if (val & DF_1_ORIGIN)
8781 if (val & DF_1_DIRECT)
8786 if (val & DF_1_TRANS)
8791 if (val & DF_1_INTERPOSE)
8793 printf (" INTERPOSE");
8794 val ^= DF_1_INTERPOSE;
8796 if (val & DF_1_NODEFLIB)
8798 printf (" NODEFLIB");
8799 val ^= DF_1_NODEFLIB;
8801 if (val & DF_1_NODUMP)
8806 if (val & DF_1_CONFALT)
8808 printf (" CONFALT");
8809 val ^= DF_1_CONFALT;
8811 if (val & DF_1_ENDFILTEE)
8813 printf (" ENDFILTEE");
8814 val ^= DF_1_ENDFILTEE;
8816 if (val & DF_1_DISPRELDNE)
8818 printf (" DISPRELDNE");
8819 val ^= DF_1_DISPRELDNE;
8821 if (val & DF_1_DISPRELPND)
8823 printf (" DISPRELPND");
8824 val ^= DF_1_DISPRELPND;
8826 if (val & DF_1_NODIRECT)
8828 printf (" NODIRECT");
8829 val ^= DF_1_NODIRECT;
8831 if (val & DF_1_IGNMULDEF)
8833 printf (" IGNMULDEF");
8834 val ^= DF_1_IGNMULDEF;
8836 if (val & DF_1_NOKSYMS)
8838 printf (" NOKSYMS");
8839 val ^= DF_1_NOKSYMS;
8841 if (val & DF_1_NOHDR)
8846 if (val & DF_1_EDITED)
8851 if (val & DF_1_NORELOC)
8853 printf (" NORELOC");
8854 val ^= DF_1_NORELOC;
8856 if (val & DF_1_SYMINTPOSE)
8858 printf (" SYMINTPOSE");
8859 val ^= DF_1_SYMINTPOSE;
8861 if (val & DF_1_GLOBAUDIT)
8863 printf (" GLOBAUDIT");
8864 val ^= DF_1_GLOBAUDIT;
8866 if (val & DF_1_SINGLETON)
8868 printf (" SINGLETON");
8869 val ^= DF_1_SINGLETON;
8872 printf (" %lx", val);
8879 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8881 puts (get_dynamic_type (entry->d_un.d_val));
8901 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8907 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8908 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8914 switch (entry->d_tag)
8917 printf (_("Shared library: [%s]"), name);
8919 if (streq (name, program_interpreter))
8920 printf (_(" program interpreter"));
8924 printf (_("Library soname: [%s]"), name);
8928 printf (_("Library rpath: [%s]"), name);
8932 printf (_("Library runpath: [%s]"), name);
8936 print_vma (entry->d_un.d_val, PREFIX_HEX);
8941 print_vma (entry->d_un.d_val, PREFIX_HEX);
8954 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8958 case DT_INIT_ARRAYSZ:
8959 case DT_FINI_ARRAYSZ:
8960 case DT_GNU_CONFLICTSZ:
8961 case DT_GNU_LIBLISTSZ:
8964 print_vma (entry->d_un.d_val, UNSIGNED);
8965 printf (_(" (bytes)\n"));
8975 print_vma (entry->d_un.d_val, UNSIGNED);
8988 if (entry->d_tag == DT_USED
8989 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8991 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8995 printf (_("Not needed object: [%s]\n"), name);
9000 print_vma (entry->d_un.d_val, PREFIX_HEX);
9006 /* The value of this entry is ignored. */
9011 case DT_GNU_PRELINKED:
9015 time_t atime = entry->d_un.d_val;
9017 tmp = gmtime (&atime);
9018 /* PR 17533 file: 041-1244816-0.004. */
9020 printf (_("<corrupt time val: %lx"),
9021 (unsigned long) atime);
9023 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9024 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9025 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9031 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9034 print_vma (entry->d_un.d_val, PREFIX_HEX);
9040 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9041 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9046 switch (elf_header.e_machine)
9049 case EM_MIPS_RS3_LE:
9050 dynamic_section_mips_val (entry);
9053 dynamic_section_parisc_val (entry);
9056 dynamic_section_ia64_val (entry);
9059 print_vma (entry->d_un.d_val, PREFIX_HEX);
9071 get_ver_flags (unsigned int flags)
9073 static char buff[32];
9080 if (flags & VER_FLG_BASE)
9081 strcat (buff, "BASE ");
9083 if (flags & VER_FLG_WEAK)
9085 if (flags & VER_FLG_BASE)
9086 strcat (buff, "| ");
9088 strcat (buff, "WEAK ");
9091 if (flags & VER_FLG_INFO)
9093 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9094 strcat (buff, "| ");
9096 strcat (buff, "INFO ");
9099 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9100 strcat (buff, _("| <unknown>"));
9105 /* Display the contents of the version sections. */
9108 process_version_sections (FILE * file)
9110 Elf_Internal_Shdr * section;
9117 for (i = 0, section = section_headers;
9118 i < elf_header.e_shnum;
9121 switch (section->sh_type)
9123 case SHT_GNU_verdef:
9125 Elf_External_Verdef * edefs;
9132 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9133 printable_section_name (section),
9136 printf (_(" Addr: 0x"));
9137 printf_vma (section->sh_addr);
9138 printf (_(" Offset: %#08lx Link: %u (%s)"),
9139 (unsigned long) section->sh_offset, section->sh_link,
9140 printable_section_name_from_index (section->sh_link));
9142 edefs = (Elf_External_Verdef *)
9143 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9144 _("version definition section"));
9147 endbuf = (char *) edefs + section->sh_size;
9149 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9152 Elf_External_Verdef * edef;
9153 Elf_Internal_Verdef ent;
9154 Elf_External_Verdaux * eaux;
9155 Elf_Internal_Verdaux aux;
9159 /* Check for very large indicies. */
9160 if (idx > (size_t) (endbuf - (char *) edefs))
9163 vstart = ((char *) edefs) + idx;
9164 if (vstart + sizeof (*edef) > endbuf)
9167 edef = (Elf_External_Verdef *) vstart;
9169 ent.vd_version = BYTE_GET (edef->vd_version);
9170 ent.vd_flags = BYTE_GET (edef->vd_flags);
9171 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9172 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9173 ent.vd_hash = BYTE_GET (edef->vd_hash);
9174 ent.vd_aux = BYTE_GET (edef->vd_aux);
9175 ent.vd_next = BYTE_GET (edef->vd_next);
9177 printf (_(" %#06x: Rev: %d Flags: %s"),
9178 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9180 printf (_(" Index: %d Cnt: %d "),
9181 ent.vd_ndx, ent.vd_cnt);
9183 /* Check for overflow. */
9184 if (ent.vd_aux > (size_t) (endbuf - vstart))
9187 vstart += ent.vd_aux;
9189 eaux = (Elf_External_Verdaux *) vstart;
9191 aux.vda_name = BYTE_GET (eaux->vda_name);
9192 aux.vda_next = BYTE_GET (eaux->vda_next);
9194 if (VALID_DYNAMIC_NAME (aux.vda_name))
9195 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9197 printf (_("Name index: %ld\n"), aux.vda_name);
9199 isum = idx + ent.vd_aux;
9201 for (j = 1; j < ent.vd_cnt; j++)
9203 /* Check for overflow. */
9204 if (aux.vda_next > (size_t) (endbuf - vstart))
9207 isum += aux.vda_next;
9208 vstart += aux.vda_next;
9210 eaux = (Elf_External_Verdaux *) vstart;
9211 if (vstart + sizeof (*eaux) > endbuf)
9214 aux.vda_name = BYTE_GET (eaux->vda_name);
9215 aux.vda_next = BYTE_GET (eaux->vda_next);
9217 if (VALID_DYNAMIC_NAME (aux.vda_name))
9218 printf (_(" %#06x: Parent %d: %s\n"),
9219 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9221 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9222 isum, j, aux.vda_name);
9226 printf (_(" Version def aux past end of section\n"));
9228 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9229 if (idx + ent.vd_next <= idx)
9235 if (cnt < section->sh_info)
9236 printf (_(" Version definition past end of section\n"));
9242 case SHT_GNU_verneed:
9244 Elf_External_Verneed * eneed;
9251 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9252 printable_section_name (section), section->sh_info);
9254 printf (_(" Addr: 0x"));
9255 printf_vma (section->sh_addr);
9256 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9257 (unsigned long) section->sh_offset, section->sh_link,
9258 printable_section_name_from_index (section->sh_link));
9260 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9261 section->sh_offset, 1,
9263 _("Version Needs section"));
9266 endbuf = (char *) eneed + section->sh_size;
9268 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9270 Elf_External_Verneed * entry;
9271 Elf_Internal_Verneed ent;
9276 if (idx > (size_t) (endbuf - (char *) eneed))
9279 vstart = ((char *) eneed) + idx;
9280 if (vstart + sizeof (*entry) > endbuf)
9283 entry = (Elf_External_Verneed *) vstart;
9285 ent.vn_version = BYTE_GET (entry->vn_version);
9286 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9287 ent.vn_file = BYTE_GET (entry->vn_file);
9288 ent.vn_aux = BYTE_GET (entry->vn_aux);
9289 ent.vn_next = BYTE_GET (entry->vn_next);
9291 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9293 if (VALID_DYNAMIC_NAME (ent.vn_file))
9294 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9296 printf (_(" File: %lx"), ent.vn_file);
9298 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9300 /* Check for overflow. */
9301 if (ent.vn_aux > (size_t) (endbuf - vstart))
9304 vstart += ent.vn_aux;
9306 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9308 Elf_External_Vernaux * eaux;
9309 Elf_Internal_Vernaux aux;
9311 if (vstart + sizeof (*eaux) > endbuf)
9313 eaux = (Elf_External_Vernaux *) vstart;
9315 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9316 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9317 aux.vna_other = BYTE_GET (eaux->vna_other);
9318 aux.vna_name = BYTE_GET (eaux->vna_name);
9319 aux.vna_next = BYTE_GET (eaux->vna_next);
9321 if (VALID_DYNAMIC_NAME (aux.vna_name))
9322 printf (_(" %#06x: Name: %s"),
9323 isum, GET_DYNAMIC_NAME (aux.vna_name));
9325 printf (_(" %#06x: Name index: %lx"),
9326 isum, aux.vna_name);
9328 printf (_(" Flags: %s Version: %d\n"),
9329 get_ver_flags (aux.vna_flags), aux.vna_other);
9331 /* Check for overflow. */
9332 if (aux.vna_next > (size_t) (endbuf - vstart))
9335 isum += aux.vna_next;
9336 vstart += aux.vna_next;
9340 warn (_("Missing Version Needs auxillary information\n"));
9342 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9344 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9345 cnt = section->sh_info;
9351 if (cnt < section->sh_info)
9352 warn (_("Missing Version Needs information\n"));
9358 case SHT_GNU_versym:
9360 Elf_Internal_Shdr * link_section;
9363 unsigned char * edata;
9364 unsigned short * data;
9366 Elf_Internal_Sym * symbols;
9367 Elf_Internal_Shdr * string_sec;
9368 unsigned long num_syms;
9371 if (section->sh_link >= elf_header.e_shnum)
9374 link_section = section_headers + section->sh_link;
9375 total = section->sh_size / sizeof (Elf_External_Versym);
9377 if (link_section->sh_link >= elf_header.e_shnum)
9382 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9383 if (symbols == NULL)
9386 string_sec = section_headers + link_section->sh_link;
9388 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9389 string_sec->sh_size,
9390 _("version string table"));
9397 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9398 printable_section_name (section), (unsigned long) total);
9400 printf (_(" Addr: "));
9401 printf_vma (section->sh_addr);
9402 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9403 (unsigned long) section->sh_offset, section->sh_link,
9404 printable_section_name (link_section));
9406 off = offset_from_vma (file,
9407 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9408 total * sizeof (short));
9409 edata = (unsigned char *) get_data (NULL, file, off, total,
9411 _("version symbol data"));
9419 data = (short unsigned int *) cmalloc (total, sizeof (short));
9421 for (cnt = total; cnt --;)
9422 data[cnt] = byte_get (edata + cnt * sizeof (short),
9427 for (cnt = 0; cnt < total; cnt += 4)
9430 int check_def, check_need;
9433 printf (" %03x:", cnt);
9435 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9436 switch (data[cnt + j])
9439 fputs (_(" 0 (*local*) "), stdout);
9443 fputs (_(" 1 (*global*) "), stdout);
9447 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9448 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9450 /* If this index value is greater than the size of the symbols
9451 array, break to avoid an out-of-bounds read. */
9452 if ((unsigned long)(cnt + j) >= num_syms)
9454 warn (_("invalid index into symbol array\n"));
9460 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9461 || section_headers[symbols[cnt + j].st_shndx].sh_type
9464 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9471 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9473 Elf_Internal_Verneed ivn;
9474 unsigned long offset;
9476 offset = offset_from_vma
9477 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9478 sizeof (Elf_External_Verneed));
9482 Elf_Internal_Vernaux ivna;
9483 Elf_External_Verneed evn;
9484 Elf_External_Vernaux evna;
9485 unsigned long a_off;
9487 if (get_data (&evn, file, offset, sizeof (evn), 1,
9488 _("version need")) == NULL)
9491 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9492 ivn.vn_next = BYTE_GET (evn.vn_next);
9494 a_off = offset + ivn.vn_aux;
9498 if (get_data (&evna, file, a_off, sizeof (evna),
9499 1, _("version need aux (2)")) == NULL)
9506 ivna.vna_next = BYTE_GET (evna.vna_next);
9507 ivna.vna_other = BYTE_GET (evna.vna_other);
9510 a_off += ivna.vna_next;
9512 while (ivna.vna_other != data[cnt + j]
9513 && ivna.vna_next != 0);
9515 if (ivna.vna_other == data[cnt + j])
9517 ivna.vna_name = BYTE_GET (evna.vna_name);
9519 if (ivna.vna_name >= string_sec->sh_size)
9520 name = _("*invalid*");
9522 name = strtab + ivna.vna_name;
9523 nn += printf ("(%s%-*s",
9525 12 - (int) strlen (name),
9531 offset += ivn.vn_next;
9533 while (ivn.vn_next);
9536 if (check_def && data[cnt + j] != 0x8001
9537 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9539 Elf_Internal_Verdef ivd;
9540 Elf_External_Verdef evd;
9541 unsigned long offset;
9543 offset = offset_from_vma
9544 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9549 if (get_data (&evd, file, offset, sizeof (evd), 1,
9550 _("version def")) == NULL)
9553 /* PR 17531: file: 046-1082287-0.004. */
9554 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9559 ivd.vd_next = BYTE_GET (evd.vd_next);
9560 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9563 offset += ivd.vd_next;
9565 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9566 && ivd.vd_next != 0);
9568 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9570 Elf_External_Verdaux evda;
9571 Elf_Internal_Verdaux ivda;
9573 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9575 if (get_data (&evda, file,
9576 offset - ivd.vd_next + ivd.vd_aux,
9578 _("version def aux")) == NULL)
9581 ivda.vda_name = BYTE_GET (evda.vda_name);
9583 if (ivda.vda_name >= string_sec->sh_size)
9584 name = _("*invalid*");
9586 name = strtab + ivda.vda_name;
9587 nn += printf ("(%s%-*s",
9589 12 - (int) strlen (name),
9595 printf ("%*c", 18 - nn, ' ');
9613 printf (_("\nNo version information found in this file.\n"));
9619 get_symbol_binding (unsigned int binding)
9621 static char buff[32];
9625 case STB_LOCAL: return "LOCAL";
9626 case STB_GLOBAL: return "GLOBAL";
9627 case STB_WEAK: return "WEAK";
9629 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9630 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9632 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9634 if (binding == STB_GNU_UNIQUE
9635 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9636 /* GNU is still using the default value 0. */
9637 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9639 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9642 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9648 get_symbol_type (unsigned int type)
9650 static char buff[32];
9654 case STT_NOTYPE: return "NOTYPE";
9655 case STT_OBJECT: return "OBJECT";
9656 case STT_FUNC: return "FUNC";
9657 case STT_SECTION: return "SECTION";
9658 case STT_FILE: return "FILE";
9659 case STT_COMMON: return "COMMON";
9660 case STT_TLS: return "TLS";
9661 case STT_RELC: return "RELC";
9662 case STT_SRELC: return "SRELC";
9664 if (type >= STT_LOPROC && type <= STT_HIPROC)
9666 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9667 return "THUMB_FUNC";
9669 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9672 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9673 return "PARISC_MILLI";
9675 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9677 else if (type >= STT_LOOS && type <= STT_HIOS)
9679 if (elf_header.e_machine == EM_PARISC)
9681 if (type == STT_HP_OPAQUE)
9683 if (type == STT_HP_STUB)
9687 if (type == STT_GNU_IFUNC
9688 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9689 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9690 /* GNU is still using the default value 0. */
9691 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9694 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9697 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9703 get_symbol_visibility (unsigned int visibility)
9707 case STV_DEFAULT: return "DEFAULT";
9708 case STV_INTERNAL: return "INTERNAL";
9709 case STV_HIDDEN: return "HIDDEN";
9710 case STV_PROTECTED: return "PROTECTED";
9716 get_mips_symbol_other (unsigned int other)
9728 case STO_MICROMIPS | STO_MIPS_PIC:
9729 return "MICROMIPS, MIPS PIC";
9738 get_ia64_symbol_other (unsigned int other)
9742 static char res[32];
9746 /* Function types is for images and .STB files only. */
9747 switch (elf_header.e_type)
9751 switch (VMS_ST_FUNC_TYPE (other))
9753 case VMS_SFT_CODE_ADDR:
9754 strcat (res, " CA");
9756 case VMS_SFT_SYMV_IDX:
9757 strcat (res, " VEC");
9760 strcat (res, " FD");
9762 case VMS_SFT_RESERVE:
9763 strcat (res, " RSV");
9772 switch (VMS_ST_LINKAGE (other))
9774 case VMS_STL_IGNORE:
9775 strcat (res, " IGN");
9777 case VMS_STL_RESERVE:
9778 strcat (res, " RSV");
9781 strcat (res, " STD");
9784 strcat (res, " LNK");
9799 get_ppc64_symbol_other (unsigned int other)
9801 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9803 static char buf[32];
9804 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9805 PPC64_LOCAL_ENTRY_OFFSET (other));
9812 get_symbol_other (unsigned int other)
9814 const char * result = NULL;
9815 static char buff [32];
9820 switch (elf_header.e_machine)
9823 result = get_mips_symbol_other (other);
9826 result = get_ia64_symbol_other (other);
9829 result = get_ppc64_symbol_other (other);
9838 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9843 get_symbol_index_type (unsigned int type)
9845 static char buff[32];
9849 case SHN_UNDEF: return "UND";
9850 case SHN_ABS: return "ABS";
9851 case SHN_COMMON: return "COM";
9853 if (type == SHN_IA_64_ANSI_COMMON
9854 && elf_header.e_machine == EM_IA_64
9855 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9857 else if ((elf_header.e_machine == EM_X86_64
9858 || elf_header.e_machine == EM_L1OM
9859 || elf_header.e_machine == EM_K1OM)
9860 && type == SHN_X86_64_LCOMMON)
9862 else if ((type == SHN_MIPS_SCOMMON
9863 && elf_header.e_machine == EM_MIPS)
9864 || (type == SHN_TIC6X_SCOMMON
9865 && elf_header.e_machine == EM_TI_C6000))
9867 else if (type == SHN_MIPS_SUNDEFINED
9868 && elf_header.e_machine == EM_MIPS)
9870 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9871 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9872 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9873 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9874 else if (type >= SHN_LORESERVE)
9875 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9876 else if (type >= elf_header.e_shnum)
9877 sprintf (buff, _("bad section index[%3d]"), type);
9879 sprintf (buff, "%3d", type);
9887 get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
9889 unsigned char * e_data;
9892 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9893 attempting to allocate memory when the read is bound to fail. */
9894 if (ent_size * number > current_file_size)
9896 error (_("Invalid number of dynamic entries: %lu\n"),
9897 (unsigned long) number);
9901 e_data = (unsigned char *) cmalloc (number, ent_size);
9904 error (_("Out of memory reading %lu dynamic entries\n"),
9905 (unsigned long) number);
9909 if (fread (e_data, ent_size, number, file) != number)
9911 error (_("Unable to read in %lu bytes of dynamic data\n"),
9912 (unsigned long) (number * ent_size));
9917 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9920 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9921 (unsigned long) number);
9927 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9935 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9937 Elf_Internal_Sym * psym;
9940 n = print_vma (si, DEC_5);
9942 fputs (&" "[n], stdout);
9943 printf (" %3lu: ", hn);
9945 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9947 printf (_("<No info available for dynamic symbol number %lu>\n"),
9948 (unsigned long) si);
9952 psym = dynamic_symbols + si;
9953 print_vma (psym->st_value, LONG_HEX);
9955 print_vma (psym->st_size, DEC_5);
9957 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9958 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9959 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9960 /* Check to see if any other bits in the st_other field are set.
9961 Note - displaying this information disrupts the layout of the
9962 table being generated, but for the moment this case is very
9964 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9965 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9966 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9967 if (VALID_DYNAMIC_NAME (psym->st_name))
9968 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9970 printf (_(" <corrupt: %14ld>"), psym->st_name);
9975 get_symbol_version_string (FILE *file, int is_dynsym,
9977 unsigned long int strtab_size,
9978 unsigned int si, Elf_Internal_Sym *psym,
9979 enum versioned_symbol_info *sym_info,
9980 unsigned short *vna_other)
9982 const char *version_string = NULL;
9985 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9987 unsigned char data[2];
9988 unsigned short vers_data;
9989 unsigned long offset;
9993 offset = offset_from_vma
9994 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9995 sizeof data + si * sizeof (vers_data));
9997 if (get_data (&data, file, offset + si * sizeof (vers_data),
9998 sizeof (data), 1, _("version data")) == NULL)
10001 vers_data = byte_get (data, 2);
10003 is_nobits = (psym->st_shndx < elf_header.e_shnum
10004 && section_headers[psym->st_shndx].sh_type
10007 check_def = (psym->st_shndx != SHN_UNDEF);
10009 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10011 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10012 && (is_nobits || ! check_def))
10014 Elf_External_Verneed evn;
10015 Elf_Internal_Verneed ivn;
10016 Elf_Internal_Vernaux ivna;
10018 /* We must test both. */
10019 offset = offset_from_vma
10020 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10025 unsigned long vna_off;
10027 if (get_data (&evn, file, offset, sizeof (evn), 1,
10028 _("version need")) == NULL)
10031 ivna.vna_other = 0;
10036 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10037 ivn.vn_next = BYTE_GET (evn.vn_next);
10039 vna_off = offset + ivn.vn_aux;
10043 Elf_External_Vernaux evna;
10045 if (get_data (&evna, file, vna_off,
10047 _("version need aux (3)")) == NULL)
10050 ivna.vna_other = 0;
10055 ivna.vna_other = BYTE_GET (evna.vna_other);
10056 ivna.vna_next = BYTE_GET (evna.vna_next);
10057 ivna.vna_name = BYTE_GET (evna.vna_name);
10060 vna_off += ivna.vna_next;
10062 while (ivna.vna_other != vers_data
10063 && ivna.vna_next != 0);
10065 if (ivna.vna_other == vers_data)
10068 offset += ivn.vn_next;
10070 while (ivn.vn_next != 0);
10072 if (ivna.vna_other == vers_data)
10074 *sym_info = symbol_undefined;
10075 *vna_other = ivna.vna_other;
10076 version_string = (ivna.vna_name < strtab_size
10077 ? strtab + ivna.vna_name
10081 else if (! is_nobits)
10082 error (_("bad dynamic symbol\n"));
10089 if (vers_data != 0x8001
10090 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10092 Elf_Internal_Verdef ivd;
10093 Elf_Internal_Verdaux ivda;
10094 Elf_External_Verdaux evda;
10097 off = offset_from_vma
10099 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10100 sizeof (Elf_External_Verdef));
10104 Elf_External_Verdef evd;
10106 if (get_data (&evd, file, off, sizeof (evd),
10107 1, _("version def")) == NULL)
10115 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10116 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10117 ivd.vd_next = BYTE_GET (evd.vd_next);
10120 off += ivd.vd_next;
10122 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10123 && ivd.vd_next != 0);
10125 off -= ivd.vd_next;
10128 if (get_data (&evda, file, off, sizeof (evda),
10129 1, _("version def aux")) == NULL)
10130 return version_string;
10132 ivda.vda_name = BYTE_GET (evda.vda_name);
10134 if (psym->st_name != ivda.vda_name)
10136 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10137 ? symbol_hidden : symbol_public);
10138 version_string = (ivda.vda_name < strtab_size
10139 ? strtab + ivda.vda_name
10146 return version_string;
10149 /* Dump the symbol table. */
10151 process_symbol_table (FILE * file)
10153 Elf_Internal_Shdr * section;
10154 bfd_size_type nbuckets = 0;
10155 bfd_size_type nchains = 0;
10156 bfd_vma * buckets = NULL;
10157 bfd_vma * chains = NULL;
10158 bfd_vma ngnubuckets = 0;
10159 bfd_vma * gnubuckets = NULL;
10160 bfd_vma * gnuchains = NULL;
10161 bfd_vma gnusymidx = 0;
10162 bfd_size_type ngnuchains = 0;
10164 if (!do_syms && !do_dyn_syms && !do_histogram)
10167 if (dynamic_info[DT_HASH]
10169 || (do_using_dynamic
10171 && dynamic_strings != NULL)))
10173 unsigned char nb[8];
10174 unsigned char nc[8];
10175 unsigned int hash_ent_size = 4;
10177 if ((elf_header.e_machine == EM_ALPHA
10178 || elf_header.e_machine == EM_S390
10179 || elf_header.e_machine == EM_S390_OLD)
10180 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10184 (archive_file_offset
10185 + offset_from_vma (file, dynamic_info[DT_HASH],
10186 sizeof nb + sizeof nc)),
10189 error (_("Unable to seek to start of dynamic information\n"));
10193 if (fread (nb, hash_ent_size, 1, file) != 1)
10195 error (_("Failed to read in number of buckets\n"));
10199 if (fread (nc, hash_ent_size, 1, file) != 1)
10201 error (_("Failed to read in number of chains\n"));
10205 nbuckets = byte_get (nb, hash_ent_size);
10206 nchains = byte_get (nc, hash_ent_size);
10208 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10209 chains = get_dynamic_data (file, nchains, hash_ent_size);
10212 if (buckets == NULL || chains == NULL)
10214 if (do_using_dynamic)
10225 if (dynamic_info_DT_GNU_HASH
10227 || (do_using_dynamic
10229 && dynamic_strings != NULL)))
10231 unsigned char nb[16];
10232 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10233 bfd_vma buckets_vma;
10236 (archive_file_offset
10237 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10241 error (_("Unable to seek to start of dynamic information\n"));
10245 if (fread (nb, 16, 1, file) != 1)
10247 error (_("Failed to read in number of buckets\n"));
10251 ngnubuckets = byte_get (nb, 4);
10252 gnusymidx = byte_get (nb + 4, 4);
10253 bitmaskwords = byte_get (nb + 8, 4);
10254 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10256 buckets_vma += bitmaskwords * 4;
10258 buckets_vma += bitmaskwords * 8;
10261 (archive_file_offset
10262 + offset_from_vma (file, buckets_vma, 4)),
10265 error (_("Unable to seek to start of dynamic information\n"));
10269 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10271 if (gnubuckets == NULL)
10274 for (i = 0; i < ngnubuckets; i++)
10275 if (gnubuckets[i] != 0)
10277 if (gnubuckets[i] < gnusymidx)
10280 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10281 maxchain = gnubuckets[i];
10284 if (maxchain == 0xffffffff)
10287 maxchain -= gnusymidx;
10290 (archive_file_offset
10291 + offset_from_vma (file, buckets_vma
10292 + 4 * (ngnubuckets + maxchain), 4)),
10295 error (_("Unable to seek to start of dynamic information\n"));
10301 if (fread (nb, 4, 1, file) != 1)
10303 error (_("Failed to determine last chain length\n"));
10307 if (maxchain + 1 == 0)
10312 while ((byte_get (nb, 4) & 1) == 0);
10315 (archive_file_offset
10316 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10319 error (_("Unable to seek to start of dynamic information\n"));
10323 gnuchains = get_dynamic_data (file, maxchain, 4);
10324 ngnuchains = maxchain;
10327 if (gnuchains == NULL)
10332 if (do_using_dynamic)
10337 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10339 && do_using_dynamic
10340 && dynamic_strings != NULL
10341 && dynamic_symbols != NULL)
10345 if (dynamic_info[DT_HASH])
10349 printf (_("\nSymbol table for image:\n"));
10351 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10353 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10355 for (hn = 0; hn < nbuckets; hn++)
10360 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10361 print_dynamic_symbol (si, hn);
10365 if (dynamic_info_DT_GNU_HASH)
10367 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10369 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10371 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10373 for (hn = 0; hn < ngnubuckets; ++hn)
10374 if (gnubuckets[hn] != 0)
10376 bfd_vma si = gnubuckets[hn];
10377 bfd_vma off = si - gnusymidx;
10381 print_dynamic_symbol (si, hn);
10384 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10388 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10389 && section_headers != NULL)
10393 for (i = 0, section = section_headers;
10394 i < elf_header.e_shnum;
10398 char * strtab = NULL;
10399 unsigned long int strtab_size = 0;
10400 Elf_Internal_Sym * symtab;
10401 Elf_Internal_Sym * psym;
10402 unsigned long num_syms;
10404 if ((section->sh_type != SHT_SYMTAB
10405 && section->sh_type != SHT_DYNSYM)
10407 && section->sh_type == SHT_SYMTAB))
10410 if (section->sh_entsize == 0)
10412 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10413 printable_section_name (section));
10417 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10418 printable_section_name (section),
10419 (unsigned long) (section->sh_size / section->sh_entsize));
10422 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10424 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10426 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10427 if (symtab == NULL)
10430 if (section->sh_link == elf_header.e_shstrndx)
10432 strtab = string_table;
10433 strtab_size = string_table_length;
10435 else if (section->sh_link < elf_header.e_shnum)
10437 Elf_Internal_Shdr * string_sec;
10439 string_sec = section_headers + section->sh_link;
10441 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10442 1, string_sec->sh_size,
10443 _("string table"));
10444 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10447 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10449 const char *version_string;
10450 enum versioned_symbol_info sym_info;
10451 unsigned short vna_other;
10453 printf ("%6d: ", si);
10454 print_vma (psym->st_value, LONG_HEX);
10456 print_vma (psym->st_size, DEC_5);
10457 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10458 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10459 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10460 /* Check to see if any other bits in the st_other field are set.
10461 Note - displaying this information disrupts the layout of the
10462 table being generated, but for the moment this case is very rare. */
10463 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10464 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10465 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10466 print_symbol (25, psym->st_name < strtab_size
10467 ? strtab + psym->st_name : _("<corrupt>"));
10470 = get_symbol_version_string (file,
10471 section->sh_type == SHT_DYNSYM,
10472 strtab, strtab_size, si,
10473 psym, &sym_info, &vna_other);
10474 if (version_string)
10476 if (sym_info == symbol_undefined)
10477 printf ("@%s (%d)", version_string, vna_other);
10479 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10487 if (strtab != string_table)
10493 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10495 if (do_histogram && buckets != NULL)
10497 unsigned long * lengths;
10498 unsigned long * counts;
10501 unsigned long maxlength = 0;
10502 unsigned long nzero_counts = 0;
10503 unsigned long nsyms = 0;
10505 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10506 (unsigned long) nbuckets);
10508 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10509 if (lengths == NULL)
10511 error (_("Out of memory allocating space for histogram buckets\n"));
10515 printf (_(" Length Number %% of total Coverage\n"));
10516 for (hn = 0; hn < nbuckets; ++hn)
10518 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10521 if (maxlength < ++lengths[hn])
10524 /* PR binutils/17531: A corrupt binary could contain broken
10525 histogram data. Do not go into an infinite loop trying
10527 if (chains[si] == si)
10529 error (_("histogram chain links to itself\n"));
10535 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10536 if (counts == NULL)
10539 error (_("Out of memory allocating space for histogram counts\n"));
10543 for (hn = 0; hn < nbuckets; ++hn)
10544 ++counts[lengths[hn]];
10549 printf (" 0 %-10lu (%5.1f%%)\n",
10550 counts[0], (counts[0] * 100.0) / nbuckets);
10551 for (i = 1; i <= maxlength; ++i)
10553 nzero_counts += counts[i] * i;
10554 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10555 i, counts[i], (counts[i] * 100.0) / nbuckets,
10556 (nzero_counts * 100.0) / nsyms);
10564 if (buckets != NULL)
10570 if (do_histogram && gnubuckets != NULL)
10572 unsigned long * lengths;
10573 unsigned long * counts;
10575 unsigned long maxlength = 0;
10576 unsigned long nzero_counts = 0;
10577 unsigned long nsyms = 0;
10579 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10580 (unsigned long) ngnubuckets);
10582 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10583 if (lengths == NULL)
10585 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10589 printf (_(" Length Number %% of total Coverage\n"));
10591 for (hn = 0; hn < ngnubuckets; ++hn)
10592 if (gnubuckets[hn] != 0)
10594 bfd_vma off, length = 1;
10596 for (off = gnubuckets[hn] - gnusymidx;
10597 /* PR 17531 file: 010-77222-0.004. */
10598 off < ngnuchains && (gnuchains[off] & 1) == 0;
10601 lengths[hn] = length;
10602 if (length > maxlength)
10603 maxlength = length;
10607 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10608 if (counts == NULL)
10611 error (_("Out of memory allocating space for gnu histogram counts\n"));
10615 for (hn = 0; hn < ngnubuckets; ++hn)
10616 ++counts[lengths[hn]];
10618 if (ngnubuckets > 0)
10621 printf (" 0 %-10lu (%5.1f%%)\n",
10622 counts[0], (counts[0] * 100.0) / ngnubuckets);
10623 for (j = 1; j <= maxlength; ++j)
10625 nzero_counts += counts[j] * j;
10626 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10627 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10628 (nzero_counts * 100.0) / nsyms);
10642 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10646 if (dynamic_syminfo == NULL
10648 /* No syminfo, this is ok. */
10651 /* There better should be a dynamic symbol section. */
10652 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10656 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10657 dynamic_syminfo_offset, dynamic_syminfo_nent);
10659 printf (_(" Num: Name BoundTo Flags\n"));
10660 for (i = 0; i < dynamic_syminfo_nent; ++i)
10662 unsigned short int flags = dynamic_syminfo[i].si_flags;
10664 printf ("%4d: ", i);
10665 if (i >= num_dynamic_syms)
10666 printf (_("<corrupt index>"));
10667 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10668 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10670 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10673 switch (dynamic_syminfo[i].si_boundto)
10675 case SYMINFO_BT_SELF:
10676 fputs ("SELF ", stdout);
10678 case SYMINFO_BT_PARENT:
10679 fputs ("PARENT ", stdout);
10682 if (dynamic_syminfo[i].si_boundto > 0
10683 && dynamic_syminfo[i].si_boundto < dynamic_nent
10684 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10686 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10690 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10694 if (flags & SYMINFO_FLG_DIRECT)
10695 printf (" DIRECT");
10696 if (flags & SYMINFO_FLG_PASSTHRU)
10697 printf (" PASSTHRU");
10698 if (flags & SYMINFO_FLG_COPY)
10700 if (flags & SYMINFO_FLG_LAZYLOAD)
10701 printf (" LAZYLOAD");
10709 /* Check to see if the given reloc needs to be handled in a target specific
10710 manner. If so then process the reloc and return TRUE otherwise return
10714 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10715 unsigned char * start,
10716 Elf_Internal_Sym * symtab)
10718 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10720 switch (elf_header.e_machine)
10723 case EM_MSP430_OLD:
10725 static Elf_Internal_Sym * saved_sym = NULL;
10727 switch (reloc_type)
10729 case 10: /* R_MSP430_SYM_DIFF */
10730 if (uses_msp430x_relocs ())
10732 case 21: /* R_MSP430X_SYM_DIFF */
10733 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10736 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10737 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10738 goto handle_sym_diff;
10740 case 5: /* R_MSP430_16_BYTE */
10741 case 9: /* R_MSP430_8 */
10742 if (uses_msp430x_relocs ())
10744 goto handle_sym_diff;
10746 case 2: /* R_MSP430_ABS16 */
10747 case 15: /* R_MSP430X_ABS16 */
10748 if (! uses_msp430x_relocs ())
10750 goto handle_sym_diff;
10753 if (saved_sym != NULL)
10757 value = reloc->r_addend
10758 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10759 - saved_sym->st_value);
10761 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10769 if (saved_sym != NULL)
10770 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10777 case EM_CYGNUS_MN10300:
10779 static Elf_Internal_Sym * saved_sym = NULL;
10781 switch (reloc_type)
10783 case 34: /* R_MN10300_ALIGN */
10785 case 33: /* R_MN10300_SYM_DIFF */
10786 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10788 case 1: /* R_MN10300_32 */
10789 case 2: /* R_MN10300_16 */
10790 if (saved_sym != NULL)
10794 value = reloc->r_addend
10795 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10796 - saved_sym->st_value);
10798 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10805 if (saved_sym != NULL)
10806 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10816 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10817 DWARF debug sections. This is a target specific test. Note - we do not
10818 go through the whole including-target-headers-multiple-times route, (as
10819 we have already done with <elf/h8.h>) because this would become very
10820 messy and even then this function would have to contain target specific
10821 information (the names of the relocs instead of their numeric values).
10822 FIXME: This is not the correct way to solve this problem. The proper way
10823 is to have target specific reloc sizing and typing functions created by
10824 the reloc-macros.h header, in the same way that it already creates the
10825 reloc naming functions. */
10828 is_32bit_abs_reloc (unsigned int reloc_type)
10830 switch (elf_header.e_machine)
10834 return reloc_type == 1; /* R_386_32. */
10836 return reloc_type == 1; /* R_68K_32. */
10838 return reloc_type == 1; /* R_860_32. */
10840 return reloc_type == 2; /* R_960_32. */
10842 return reloc_type == 258; /* R_AARCH64_ABS32 */
10844 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10846 return reloc_type == 1; /* R_ARC_32. */
10848 return reloc_type == 2; /* R_ARM_ABS32 */
10851 return reloc_type == 1;
10852 case EM_ADAPTEVA_EPIPHANY:
10853 return reloc_type == 3;
10855 return reloc_type == 0x12; /* R_byte4_data. */
10857 return reloc_type == 3; /* R_CRIS_32. */
10859 return reloc_type == 3; /* R_CR16_NUM32. */
10861 return reloc_type == 15; /* R_CRX_NUM32. */
10862 case EM_CYGNUS_FRV:
10863 return reloc_type == 1;
10864 case EM_CYGNUS_D10V:
10866 return reloc_type == 6; /* R_D10V_32. */
10867 case EM_CYGNUS_D30V:
10869 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10871 return reloc_type == 3; /* R_DLX_RELOC_32. */
10872 case EM_CYGNUS_FR30:
10874 return reloc_type == 3; /* R_FR30_32. */
10878 return reloc_type == 1; /* R_H8_DIR32. */
10880 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10883 return reloc_type == 2; /* R_IP2K_32. */
10885 return reloc_type == 2; /* R_IQ2000_32. */
10886 case EM_LATTICEMICO32:
10887 return reloc_type == 3; /* R_LM32_32. */
10890 return reloc_type == 3; /* R_M32C_32. */
10892 return reloc_type == 34; /* R_M32R_32_RELA. */
10894 return reloc_type == 1; /* R_MCORE_ADDR32. */
10895 case EM_CYGNUS_MEP:
10896 return reloc_type == 4; /* R_MEP_32. */
10898 return reloc_type == 2; /* R_METAG_ADDR32. */
10899 case EM_MICROBLAZE:
10900 return reloc_type == 1; /* R_MICROBLAZE_32. */
10902 return reloc_type == 2; /* R_MIPS_32. */
10904 return reloc_type == 4; /* R_MMIX_32. */
10905 case EM_CYGNUS_MN10200:
10907 return reloc_type == 1; /* R_MN10200_32. */
10908 case EM_CYGNUS_MN10300:
10910 return reloc_type == 1; /* R_MN10300_32. */
10912 return reloc_type == 1; /* R_MOXIE_32. */
10913 case EM_MSP430_OLD:
10915 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10917 return reloc_type == 2; /* R_MT_32. */
10919 return reloc_type == 20; /* R_NDS32_RELA. */
10920 case EM_ALTERA_NIOS2:
10921 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
10923 return reloc_type == 1; /* R_NIOS_32. */
10925 return reloc_type == 1; /* R_OR1K_32. */
10927 return (reloc_type == 1 /* R_PARISC_DIR32. */
10928 || reloc_type == 41); /* R_PARISC_SECREL32. */
10931 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10933 return reloc_type == 1; /* R_PPC64_ADDR32. */
10935 return reloc_type == 1; /* R_PPC_ADDR32. */
10937 return reloc_type == 1; /* R_RL78_DIR32. */
10939 return reloc_type == 1; /* R_RX_DIR32. */
10941 return reloc_type == 1; /* R_I370_ADDR31. */
10944 return reloc_type == 4; /* R_S390_32. */
10946 return reloc_type == 8; /* R_SCORE_ABS32. */
10948 return reloc_type == 1; /* R_SH_DIR32. */
10949 case EM_SPARC32PLUS:
10952 return reloc_type == 3 /* R_SPARC_32. */
10953 || reloc_type == 23; /* R_SPARC_UA32. */
10955 return reloc_type == 6; /* R_SPU_ADDR32 */
10957 return reloc_type == 1; /* R_C6000_ABS32. */
10959 return reloc_type == 2; /* R_TILEGX_32. */
10961 return reloc_type == 1; /* R_TILEPRO_32. */
10962 case EM_CYGNUS_V850:
10964 return reloc_type == 6; /* R_V850_ABS32. */
10966 return reloc_type == 0x33; /* R_V810_WORD. */
10968 return reloc_type == 1; /* R_VAX_32. */
10972 return reloc_type == 10; /* R_X86_64_32. */
10975 return reloc_type == 3; /* R_XC16C_ABS_32. */
10977 return reloc_type == 4; /* R_XGATE_32. */
10979 return reloc_type == 1; /* R_XSTROMY16_32. */
10980 case EM_XTENSA_OLD:
10982 return reloc_type == 1; /* R_XTENSA_32. */
10984 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10985 elf_header.e_machine);
10990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10991 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10994 is_32bit_pcrel_reloc (unsigned int reloc_type)
10996 switch (elf_header.e_machine)
11000 return reloc_type == 2; /* R_386_PC32. */
11002 return reloc_type == 4; /* R_68K_PC32. */
11004 return reloc_type == 261; /* R_AARCH64_PREL32 */
11005 case EM_ADAPTEVA_EPIPHANY:
11006 return reloc_type == 6;
11008 return reloc_type == 10; /* R_ALPHA_SREL32. */
11010 return reloc_type == 3; /* R_ARM_REL32 */
11011 case EM_MICROBLAZE:
11012 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11014 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11016 return reloc_type == 9; /* R_PARISC_PCREL32. */
11018 return reloc_type == 26; /* R_PPC_REL32. */
11020 return reloc_type == 26; /* R_PPC64_REL32. */
11023 return reloc_type == 5; /* R_390_PC32. */
11025 return reloc_type == 2; /* R_SH_REL32. */
11026 case EM_SPARC32PLUS:
11029 return reloc_type == 6; /* R_SPARC_DISP32. */
11031 return reloc_type == 13; /* R_SPU_REL32. */
11033 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11035 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11039 return reloc_type == 2; /* R_X86_64_PC32. */
11040 case EM_XTENSA_OLD:
11042 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11044 /* Do not abort or issue an error message here. Not all targets use
11045 pc-relative 32-bit relocs in their DWARF debug information and we
11046 have already tested for target coverage in is_32bit_abs_reloc. A
11047 more helpful warning message will be generated by apply_relocations
11048 anyway, so just return. */
11053 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11054 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11057 is_64bit_abs_reloc (unsigned int reloc_type)
11059 switch (elf_header.e_machine)
11062 return reloc_type == 257; /* R_AARCH64_ABS64. */
11064 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11066 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11068 return reloc_type == 80; /* R_PARISC_DIR64. */
11070 return reloc_type == 38; /* R_PPC64_ADDR64. */
11071 case EM_SPARC32PLUS:
11074 return reloc_type == 54; /* R_SPARC_UA64. */
11078 return reloc_type == 1; /* R_X86_64_64. */
11081 return reloc_type == 22; /* R_S390_64. */
11083 return reloc_type == 1; /* R_TILEGX_64. */
11085 return reloc_type == 18; /* R_MIPS_64. */
11091 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11092 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11095 is_64bit_pcrel_reloc (unsigned int reloc_type)
11097 switch (elf_header.e_machine)
11100 return reloc_type == 260; /* R_AARCH64_PREL64. */
11102 return reloc_type == 11; /* R_ALPHA_SREL64. */
11104 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11106 return reloc_type == 72; /* R_PARISC_PCREL64. */
11108 return reloc_type == 44; /* R_PPC64_REL64. */
11109 case EM_SPARC32PLUS:
11112 return reloc_type == 46; /* R_SPARC_DISP64. */
11116 return reloc_type == 24; /* R_X86_64_PC64. */
11119 return reloc_type == 23; /* R_S390_PC64. */
11121 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11127 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11128 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11131 is_24bit_abs_reloc (unsigned int reloc_type)
11133 switch (elf_header.e_machine)
11135 case EM_CYGNUS_MN10200:
11137 return reloc_type == 4; /* R_MN10200_24. */
11143 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11144 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11147 is_16bit_abs_reloc (unsigned int reloc_type)
11149 switch (elf_header.e_machine)
11153 return reloc_type == 4; /* R_AVR_16. */
11154 case EM_ADAPTEVA_EPIPHANY:
11155 return reloc_type == 5;
11156 case EM_CYGNUS_D10V:
11158 return reloc_type == 3; /* R_D10V_16. */
11162 return reloc_type == R_H8_DIR16;
11165 return reloc_type == 1; /* R_IP2K_16. */
11168 return reloc_type == 1; /* R_M32C_16 */
11170 if (uses_msp430x_relocs ())
11171 return reloc_type == 2; /* R_MSP430_ABS16. */
11172 case EM_MSP430_OLD:
11173 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11175 return reloc_type == 19; /* R_NDS32_RELA. */
11176 case EM_ALTERA_NIOS2:
11177 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11179 return reloc_type == 9; /* R_NIOS_16. */
11181 return reloc_type == 2; /* R_OR1K_16. */
11183 return reloc_type == 2; /* R_C6000_ABS16. */
11186 return reloc_type == 2; /* R_XC16C_ABS_16. */
11187 case EM_CYGNUS_MN10200:
11189 return reloc_type == 2; /* R_MN10200_16. */
11190 case EM_CYGNUS_MN10300:
11192 return reloc_type == 2; /* R_MN10300_16. */
11194 return reloc_type == 3; /* R_XGATE_16. */
11200 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11201 relocation entries (possibly formerly used for SHT_GROUP sections). */
11204 is_none_reloc (unsigned int reloc_type)
11206 switch (elf_header.e_machine)
11208 case EM_68K: /* R_68K_NONE. */
11209 case EM_386: /* R_386_NONE. */
11210 case EM_SPARC32PLUS:
11212 case EM_SPARC: /* R_SPARC_NONE. */
11213 case EM_MIPS: /* R_MIPS_NONE. */
11214 case EM_PARISC: /* R_PARISC_NONE. */
11215 case EM_ALPHA: /* R_ALPHA_NONE. */
11216 case EM_ADAPTEVA_EPIPHANY:
11217 case EM_PPC: /* R_PPC_NONE. */
11218 case EM_PPC64: /* R_PPC64_NONE. */
11219 case EM_ARM: /* R_ARM_NONE. */
11220 case EM_IA_64: /* R_IA64_NONE. */
11221 case EM_SH: /* R_SH_NONE. */
11223 case EM_S390: /* R_390_NONE. */
11224 case EM_CRIS: /* R_CRIS_NONE. */
11225 case EM_X86_64: /* R_X86_64_NONE. */
11226 case EM_L1OM: /* R_X86_64_NONE. */
11227 case EM_K1OM: /* R_X86_64_NONE. */
11228 case EM_MN10300: /* R_MN10300_NONE. */
11229 case EM_MOXIE: /* R_MOXIE_NONE. */
11230 case EM_M32R: /* R_M32R_NONE. */
11231 case EM_TI_C6000:/* R_C6000_NONE. */
11232 case EM_TILEGX: /* R_TILEGX_NONE. */
11233 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11235 case EM_C166: /* R_XC16X_NONE. */
11236 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11237 case EM_NIOS32: /* R_NIOS_NONE. */
11238 case EM_OR1K: /* R_OR1K_NONE. */
11239 return reloc_type == 0;
11241 return reloc_type == 0 || reloc_type == 256;
11243 return (reloc_type == 0 /* R_XTENSA_NONE. */
11244 || reloc_type == 204 /* R_NDS32_DIFF8. */
11245 || reloc_type == 205 /* R_NDS32_DIFF16. */
11246 || reloc_type == 206 /* R_NDS32_DIFF32. */
11247 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11248 case EM_XTENSA_OLD:
11250 return (reloc_type == 0 /* R_XTENSA_NONE. */
11251 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11252 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11253 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11255 return reloc_type == 3; /* R_METAG_NONE. */
11260 /* Apply relocations to a section.
11261 Note: So far support has been added only for those relocations
11262 which can be found in debug sections.
11263 FIXME: Add support for more relocations ? */
11266 apply_relocations (void * file,
11267 Elf_Internal_Shdr * section,
11268 unsigned char * start)
11270 Elf_Internal_Shdr * relsec;
11271 unsigned char * end = start + section->sh_size;
11273 if (elf_header.e_type != ET_REL)
11276 /* Find the reloc section associated with the section. */
11277 for (relsec = section_headers;
11278 relsec < section_headers + elf_header.e_shnum;
11281 bfd_boolean is_rela;
11282 unsigned long num_relocs;
11283 Elf_Internal_Rela * relocs;
11284 Elf_Internal_Rela * rp;
11285 Elf_Internal_Shdr * symsec;
11286 Elf_Internal_Sym * symtab;
11287 unsigned long num_syms;
11288 Elf_Internal_Sym * sym;
11290 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11291 || relsec->sh_info >= elf_header.e_shnum
11292 || section_headers + relsec->sh_info != section
11293 || relsec->sh_size == 0
11294 || relsec->sh_link >= elf_header.e_shnum)
11297 is_rela = relsec->sh_type == SHT_RELA;
11301 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11302 relsec->sh_size, & relocs, & num_relocs))
11307 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11308 relsec->sh_size, & relocs, & num_relocs))
11312 /* SH uses RELA but uses in place value instead of the addend field. */
11313 if (elf_header.e_machine == EM_SH)
11316 symsec = section_headers + relsec->sh_link;
11317 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11319 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11322 unsigned int reloc_type;
11323 unsigned int reloc_size;
11324 unsigned char * rloc;
11325 unsigned long sym_index;
11327 reloc_type = get_reloc_type (rp->r_info);
11329 if (target_specific_reloc_handling (rp, start, symtab))
11331 else if (is_none_reloc (reloc_type))
11333 else if (is_32bit_abs_reloc (reloc_type)
11334 || is_32bit_pcrel_reloc (reloc_type))
11336 else if (is_64bit_abs_reloc (reloc_type)
11337 || is_64bit_pcrel_reloc (reloc_type))
11339 else if (is_24bit_abs_reloc (reloc_type))
11341 else if (is_16bit_abs_reloc (reloc_type))
11345 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11346 reloc_type, printable_section_name (section));
11350 rloc = start + rp->r_offset;
11351 if ((rloc + reloc_size) > end || (rloc < start))
11353 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11354 (unsigned long) rp->r_offset,
11355 printable_section_name (section));
11359 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11360 if (sym_index >= num_syms)
11362 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11363 sym_index, printable_section_name (section));
11366 sym = symtab + sym_index;
11368 /* If the reloc has a symbol associated with it,
11369 make sure that it is of an appropriate type.
11371 Relocations against symbols without type can happen.
11372 Gcc -feliminate-dwarf2-dups may generate symbols
11373 without type for debug info.
11375 Icc generates relocations against function symbols
11376 instead of local labels.
11378 Relocations against object symbols can happen, eg when
11379 referencing a global array. For an example of this see
11380 the _clz.o binary in libgcc.a. */
11382 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11384 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11385 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11386 (long int)(rp - relocs),
11387 printable_section_name (relsec));
11393 addend += rp->r_addend;
11394 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11395 partial_inplace. */
11397 || (elf_header.e_machine == EM_XTENSA
11398 && reloc_type == 1)
11399 || ((elf_header.e_machine == EM_PJ
11400 || elf_header.e_machine == EM_PJ_OLD)
11401 && reloc_type == 1)
11402 || ((elf_header.e_machine == EM_D30V
11403 || elf_header.e_machine == EM_CYGNUS_D30V)
11404 && reloc_type == 12))
11405 addend += byte_get (rloc, reloc_size);
11407 if (is_32bit_pcrel_reloc (reloc_type)
11408 || is_64bit_pcrel_reloc (reloc_type))
11410 /* On HPPA, all pc-relative relocations are biased by 8. */
11411 if (elf_header.e_machine == EM_PARISC)
11413 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11417 byte_put (rloc, addend + sym->st_value, reloc_size);
11426 #ifdef SUPPORT_DISASSEMBLY
11428 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11430 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11432 /* FIXME: XXX -- to be done --- XXX */
11438 /* Reads in the contents of SECTION from FILE, returning a pointer
11439 to a malloc'ed buffer or NULL if something went wrong. */
11442 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11444 bfd_size_type num_bytes;
11446 num_bytes = section->sh_size;
11448 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11450 printf (_("\nSection '%s' has no data to dump.\n"),
11451 printable_section_name (section));
11455 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11456 _("section contents"));
11461 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11463 Elf_Internal_Shdr * relsec;
11464 bfd_size_type num_bytes;
11468 bfd_boolean some_strings_shown;
11470 start = get_section_contents (section, file);
11474 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11476 /* If the section being dumped has relocations against it the user might
11477 be expecting these relocations to have been applied. Check for this
11478 case and issue a warning message in order to avoid confusion.
11479 FIXME: Maybe we ought to have an option that dumps a section with
11480 relocs applied ? */
11481 for (relsec = section_headers;
11482 relsec < section_headers + elf_header.e_shnum;
11485 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11486 || relsec->sh_info >= elf_header.e_shnum
11487 || section_headers + relsec->sh_info != section
11488 || relsec->sh_size == 0
11489 || relsec->sh_link >= elf_header.e_shnum)
11492 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11496 num_bytes = section->sh_size;
11498 end = start + num_bytes;
11499 some_strings_shown = FALSE;
11503 while (!ISPRINT (* data))
11504 if (++ data >= end)
11509 size_t maxlen = end - data;
11512 /* PR 11128: Use two separate invocations in order to work
11513 around bugs in the Solaris 8 implementation of printf. */
11514 printf (" [%6tx] ", data - start);
11516 printf (" [%6Ix] ", (size_t) (data - start));
11520 print_symbol ((int) maxlen, data);
11522 data += strnlen (data, maxlen);
11526 printf (_("<corrupt>\n"));
11529 some_strings_shown = TRUE;
11533 if (! some_strings_shown)
11534 printf (_(" No strings found in this section."));
11542 dump_section_as_bytes (Elf_Internal_Shdr * section,
11544 bfd_boolean relocate)
11546 Elf_Internal_Shdr * relsec;
11547 bfd_size_type bytes;
11549 unsigned char * data;
11550 unsigned char * start;
11552 start = (unsigned char *) get_section_contents (section, file);
11556 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11560 apply_relocations (file, section, start);
11564 /* If the section being dumped has relocations against it the user might
11565 be expecting these relocations to have been applied. Check for this
11566 case and issue a warning message in order to avoid confusion.
11567 FIXME: Maybe we ought to have an option that dumps a section with
11568 relocs applied ? */
11569 for (relsec = section_headers;
11570 relsec < section_headers + elf_header.e_shnum;
11573 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11574 || relsec->sh_info >= elf_header.e_shnum
11575 || section_headers + relsec->sh_info != section
11576 || relsec->sh_size == 0
11577 || relsec->sh_link >= elf_header.e_shnum)
11580 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11585 addr = section->sh_addr;
11586 bytes = section->sh_size;
11595 lbytes = (bytes > 16 ? 16 : bytes);
11597 printf (" 0x%8.8lx ", (unsigned long) addr);
11599 for (j = 0; j < 16; j++)
11602 printf ("%2.2x", data[j]);
11610 for (j = 0; j < lbytes; j++)
11613 if (k >= ' ' && k < 0x7f)
11631 /* Uncompresses a section that was compressed using zlib, in place. */
11634 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11635 dwarf_size_type *size ATTRIBUTE_UNUSED)
11637 #ifndef HAVE_ZLIB_H
11640 dwarf_size_type compressed_size = *size;
11641 unsigned char * compressed_buffer = *buffer;
11642 dwarf_size_type uncompressed_size;
11643 unsigned char * uncompressed_buffer;
11646 dwarf_size_type header_size = 12;
11648 /* Read the zlib header. In this case, it should be "ZLIB" followed
11649 by the uncompressed section size, 8 bytes in big-endian order. */
11650 if (compressed_size < header_size
11651 || ! streq ((char *) compressed_buffer, "ZLIB"))
11654 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11655 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11656 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11657 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11658 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11659 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11660 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11661 uncompressed_size += compressed_buffer[11];
11663 /* It is possible the section consists of several compressed
11664 buffers concatenated together, so we uncompress in a loop. */
11665 strm.zalloc = NULL;
11667 strm.opaque = NULL;
11668 strm.avail_in = compressed_size - header_size;
11669 strm.next_in = (Bytef *) compressed_buffer + header_size;
11670 strm.avail_out = uncompressed_size;
11671 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11673 rc = inflateInit (& strm);
11674 while (strm.avail_in > 0)
11678 strm.next_out = ((Bytef *) uncompressed_buffer
11679 + (uncompressed_size - strm.avail_out));
11680 rc = inflate (&strm, Z_FINISH);
11681 if (rc != Z_STREAM_END)
11683 rc = inflateReset (& strm);
11685 rc = inflateEnd (& strm);
11687 || strm.avail_out != 0)
11690 free (compressed_buffer);
11691 *buffer = uncompressed_buffer;
11692 *size = uncompressed_size;
11696 free (uncompressed_buffer);
11697 /* Indicate decompression failure. */
11700 #endif /* HAVE_ZLIB_H */
11704 load_specific_debug_section (enum dwarf_section_display_enum debug,
11705 Elf_Internal_Shdr * sec, void * file)
11707 struct dwarf_section * section = &debug_displays [debug].section;
11710 /* If it is already loaded, do nothing. */
11711 if (section->start != NULL)
11714 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11715 section->address = sec->sh_addr;
11716 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11718 sec->sh_size, buf);
11719 if (section->start == NULL)
11723 section->size = sec->sh_size;
11724 if (uncompress_section_contents (§ion->start, §ion->size))
11725 sec->sh_size = section->size;
11728 if (section->start == NULL)
11731 if (debug_displays [debug].relocate)
11732 apply_relocations ((FILE *) file, sec, section->start);
11737 /* If this is not NULL, load_debug_section will only look for sections
11738 within the list of sections given here. */
11739 unsigned int *section_subset = NULL;
11742 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11744 struct dwarf_section * section = &debug_displays [debug].section;
11745 Elf_Internal_Shdr * sec;
11747 /* Locate the debug section. */
11748 sec = find_section_in_set (section->uncompressed_name, section_subset);
11750 section->name = section->uncompressed_name;
11753 sec = find_section_in_set (section->compressed_name, section_subset);
11755 section->name = section->compressed_name;
11760 /* If we're loading from a subset of sections, and we've loaded
11761 a section matching this name before, it's likely that it's a
11763 if (section_subset != NULL)
11764 free_debug_section (debug);
11766 return load_specific_debug_section (debug, sec, (FILE *) file);
11770 free_debug_section (enum dwarf_section_display_enum debug)
11772 struct dwarf_section * section = &debug_displays [debug].section;
11774 if (section->start == NULL)
11777 free ((char *) section->start);
11778 section->start = NULL;
11779 section->address = 0;
11784 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11786 char * name = SECTION_NAME (section);
11787 const char * print_name = printable_section_name (section);
11788 bfd_size_type length;
11792 length = section->sh_size;
11795 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
11798 if (section->sh_type == SHT_NOBITS)
11800 /* There is no point in dumping the contents of a debugging section
11801 which has the NOBITS type - the bits in the file will be random.
11802 This can happen when a file containing a .eh_frame section is
11803 stripped with the --only-keep-debug command line option. */
11804 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11809 if (const_strneq (name, ".gnu.linkonce.wi."))
11810 name = ".debug_info";
11812 /* See if we know how to display the contents of this section. */
11813 for (i = 0; i < max; i++)
11814 if (streq (debug_displays[i].section.uncompressed_name, name)
11815 || (i == line && const_strneq (name, ".debug_line."))
11816 || streq (debug_displays[i].section.compressed_name, name))
11818 struct dwarf_section * sec = &debug_displays [i].section;
11819 int secondary = (section != find_section (name));
11822 free_debug_section ((enum dwarf_section_display_enum) i);
11824 if (i == line && const_strneq (name, ".debug_line."))
11826 else if (streq (sec->uncompressed_name, name))
11827 sec->name = sec->uncompressed_name;
11829 sec->name = sec->compressed_name;
11830 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11833 /* If this debug section is part of a CU/TU set in a .dwp file,
11834 restrict load_debug_section to the sections in that set. */
11835 section_subset = find_cu_tu_set (file, shndx);
11837 result &= debug_displays[i].display (sec, file);
11839 section_subset = NULL;
11841 if (secondary || (i != info && i != abbrev))
11842 free_debug_section ((enum dwarf_section_display_enum) i);
11850 printf (_("Unrecognized debug section: %s\n"), print_name);
11857 /* Set DUMP_SECTS for all sections where dumps were requested
11858 based on section name. */
11861 initialise_dumps_byname (void)
11863 struct dump_list_entry * cur;
11865 for (cur = dump_sects_byname; cur; cur = cur->next)
11870 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11871 if (streq (SECTION_NAME (section_headers + i), cur->name))
11873 request_dump_bynumber (i, cur->type);
11878 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11884 process_section_contents (FILE * file)
11886 Elf_Internal_Shdr * section;
11892 initialise_dumps_byname ();
11894 for (i = 0, section = section_headers;
11895 i < elf_header.e_shnum && i < num_dump_sects;
11898 #ifdef SUPPORT_DISASSEMBLY
11899 if (dump_sects[i] & DISASS_DUMP)
11900 disassemble_section (section, file);
11902 if (dump_sects[i] & HEX_DUMP)
11903 dump_section_as_bytes (section, file, FALSE);
11905 if (dump_sects[i] & RELOC_DUMP)
11906 dump_section_as_bytes (section, file, TRUE);
11908 if (dump_sects[i] & STRING_DUMP)
11909 dump_section_as_strings (section, file);
11911 if (dump_sects[i] & DEBUG_DUMP)
11912 display_debug_section (i, section, file);
11915 /* Check to see if the user requested a
11916 dump of a section that does not exist. */
11917 while (i++ < num_dump_sects)
11919 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11923 process_mips_fpe_exception (int mask)
11928 if (mask & OEX_FPU_INEX)
11929 fputs ("INEX", stdout), first = 0;
11930 if (mask & OEX_FPU_UFLO)
11931 printf ("%sUFLO", first ? "" : "|"), first = 0;
11932 if (mask & OEX_FPU_OFLO)
11933 printf ("%sOFLO", first ? "" : "|"), first = 0;
11934 if (mask & OEX_FPU_DIV0)
11935 printf ("%sDIV0", first ? "" : "|"), first = 0;
11936 if (mask & OEX_FPU_INVAL)
11937 printf ("%sINVAL", first ? "" : "|");
11940 fputs ("0", stdout);
11943 /* Display's the value of TAG at location P. If TAG is
11944 greater than 0 it is assumed to be an unknown tag, and
11945 a message is printed to this effect. Otherwise it is
11946 assumed that a message has already been printed.
11948 If the bottom bit of TAG is set it assumed to have a
11949 string value, otherwise it is assumed to have an integer
11952 Returns an updated P pointing to the first unread byte
11953 beyond the end of TAG's value.
11955 Reads at or beyond END will not be made. */
11957 static unsigned char *
11958 display_tag_value (int tag,
11960 const unsigned char * const end)
11965 printf (" Tag_unknown_%d: ", tag);
11969 warn (_("<corrupt tag>\n"));
11973 /* PR 17531 file: 027-19978-0.004. */
11974 size_t maxlen = (end - p) - 1;
11979 print_symbol ((int) maxlen, (const char *) p);
11980 p += strnlen ((char *) p, maxlen) + 1;
11984 printf (_("<corrupt string tag>"));
11985 p = (unsigned char *) end;
11993 val = read_uleb128 (p, &len, end);
11995 printf ("%ld (0x%lx)\n", val, val);
12002 /* ARM EABI attributes section. */
12007 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12009 const char ** table;
12010 } arm_attr_public_tag;
12012 static const char * arm_attr_tag_CPU_arch[] =
12013 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12014 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12015 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12016 static const char * arm_attr_tag_THUMB_ISA_use[] =
12017 {"No", "Thumb-1", "Thumb-2"};
12018 static const char * arm_attr_tag_FP_arch[] =
12019 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12020 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12021 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12022 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12023 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12024 static const char * arm_attr_tag_PCS_config[] =
12025 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12026 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12027 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12028 {"V6", "SB", "TLS", "Unused"};
12029 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12030 {"Absolute", "PC-relative", "SB-relative", "None"};
12031 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12032 {"Absolute", "PC-relative", "None"};
12033 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12034 {"None", "direct", "GOT-indirect"};
12035 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12036 {"None", "??? 1", "2", "??? 3", "4"};
12037 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12038 static const char * arm_attr_tag_ABI_FP_denormal[] =
12039 {"Unused", "Needed", "Sign only"};
12040 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12041 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12042 static const char * arm_attr_tag_ABI_FP_number_model[] =
12043 {"Unused", "Finite", "RTABI", "IEEE 754"};
12044 static const char * arm_attr_tag_ABI_enum_size[] =
12045 {"Unused", "small", "int", "forced to int"};
12046 static const char * arm_attr_tag_ABI_HardFP_use[] =
12047 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12048 static const char * arm_attr_tag_ABI_VFP_args[] =
12049 {"AAPCS", "VFP registers", "custom"};
12050 static const char * arm_attr_tag_ABI_WMMX_args[] =
12051 {"AAPCS", "WMMX registers", "custom"};
12052 static const char * arm_attr_tag_ABI_optimization_goals[] =
12053 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12054 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12055 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12056 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12057 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12058 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12059 static const char * arm_attr_tag_FP_HP_extension[] =
12060 {"Not Allowed", "Allowed"};
12061 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12062 {"None", "IEEE 754", "Alternative Format"};
12063 static const char * arm_attr_tag_MPextension_use[] =
12064 {"Not Allowed", "Allowed"};
12065 static const char * arm_attr_tag_DIV_use[] =
12066 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12067 "Allowed in v7-A with integer division extension"};
12068 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12069 static const char * arm_attr_tag_Virtualization_use[] =
12070 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12071 "TrustZone and Virtualization Extensions"};
12072 static const char * arm_attr_tag_MPextension_use_legacy[] =
12073 {"Not Allowed", "Allowed"};
12075 #define LOOKUP(id, name) \
12076 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12077 static arm_attr_public_tag arm_attr_public_tags[] =
12079 {4, "CPU_raw_name", 1, NULL},
12080 {5, "CPU_name", 1, NULL},
12081 LOOKUP(6, CPU_arch),
12082 {7, "CPU_arch_profile", 0, NULL},
12083 LOOKUP(8, ARM_ISA_use),
12084 LOOKUP(9, THUMB_ISA_use),
12085 LOOKUP(10, FP_arch),
12086 LOOKUP(11, WMMX_arch),
12087 LOOKUP(12, Advanced_SIMD_arch),
12088 LOOKUP(13, PCS_config),
12089 LOOKUP(14, ABI_PCS_R9_use),
12090 LOOKUP(15, ABI_PCS_RW_data),
12091 LOOKUP(16, ABI_PCS_RO_data),
12092 LOOKUP(17, ABI_PCS_GOT_use),
12093 LOOKUP(18, ABI_PCS_wchar_t),
12094 LOOKUP(19, ABI_FP_rounding),
12095 LOOKUP(20, ABI_FP_denormal),
12096 LOOKUP(21, ABI_FP_exceptions),
12097 LOOKUP(22, ABI_FP_user_exceptions),
12098 LOOKUP(23, ABI_FP_number_model),
12099 {24, "ABI_align_needed", 0, NULL},
12100 {25, "ABI_align_preserved", 0, NULL},
12101 LOOKUP(26, ABI_enum_size),
12102 LOOKUP(27, ABI_HardFP_use),
12103 LOOKUP(28, ABI_VFP_args),
12104 LOOKUP(29, ABI_WMMX_args),
12105 LOOKUP(30, ABI_optimization_goals),
12106 LOOKUP(31, ABI_FP_optimization_goals),
12107 {32, "compatibility", 0, NULL},
12108 LOOKUP(34, CPU_unaligned_access),
12109 LOOKUP(36, FP_HP_extension),
12110 LOOKUP(38, ABI_FP_16bit_format),
12111 LOOKUP(42, MPextension_use),
12112 LOOKUP(44, DIV_use),
12113 {64, "nodefaults", 0, NULL},
12114 {65, "also_compatible_with", 0, NULL},
12115 LOOKUP(66, T2EE_use),
12116 {67, "conformance", 1, NULL},
12117 LOOKUP(68, Virtualization_use),
12118 LOOKUP(70, MPextension_use_legacy)
12122 static unsigned char *
12123 display_arm_attribute (unsigned char * p,
12124 const unsigned char * const end)
12129 arm_attr_public_tag * attr;
12133 tag = read_uleb128 (p, &len, end);
12136 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12138 if (arm_attr_public_tags[i].tag == tag)
12140 attr = &arm_attr_public_tags[i];
12147 printf (" Tag_%s: ", attr->name);
12148 switch (attr->type)
12153 case 7: /* Tag_CPU_arch_profile. */
12154 val = read_uleb128 (p, &len, end);
12158 case 0: printf (_("None\n")); break;
12159 case 'A': printf (_("Application\n")); break;
12160 case 'R': printf (_("Realtime\n")); break;
12161 case 'M': printf (_("Microcontroller\n")); break;
12162 case 'S': printf (_("Application or Realtime\n")); break;
12163 default: printf ("??? (%d)\n", val); break;
12167 case 24: /* Tag_align_needed. */
12168 val = read_uleb128 (p, &len, end);
12172 case 0: printf (_("None\n")); break;
12173 case 1: printf (_("8-byte\n")); break;
12174 case 2: printf (_("4-byte\n")); break;
12175 case 3: printf ("??? 3\n"); break;
12178 printf (_("8-byte and up to %d-byte extended\n"),
12181 printf ("??? (%d)\n", val);
12186 case 25: /* Tag_align_preserved. */
12187 val = read_uleb128 (p, &len, end);
12191 case 0: printf (_("None\n")); break;
12192 case 1: printf (_("8-byte, except leaf SP\n")); break;
12193 case 2: printf (_("8-byte\n")); break;
12194 case 3: printf ("??? 3\n"); break;
12197 printf (_("8-byte and up to %d-byte extended\n"),
12200 printf ("??? (%d)\n", val);
12205 case 32: /* Tag_compatibility. */
12207 val = read_uleb128 (p, &len, end);
12209 printf (_("flag = %d, vendor = "), val);
12212 size_t maxlen = (end - p) - 1;
12214 print_symbol ((int) maxlen, (const char *) p);
12215 p += strnlen ((char *) p, maxlen) + 1;
12219 printf (_("<corrupt>"));
12220 p = (unsigned char *) end;
12226 case 64: /* Tag_nodefaults. */
12227 /* PR 17531: file: 001-505008-0.01. */
12230 printf (_("True\n"));
12233 case 65: /* Tag_also_compatible_with. */
12234 val = read_uleb128 (p, &len, end);
12236 if (val == 6 /* Tag_CPU_arch. */)
12238 val = read_uleb128 (p, &len, end);
12240 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12241 printf ("??? (%d)\n", val);
12243 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12247 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12257 return display_tag_value (-1, p, end);
12259 return display_tag_value (0, p, end);
12262 assert (attr->type & 0x80);
12263 val = read_uleb128 (p, &len, end);
12265 type = attr->type & 0x7f;
12267 printf ("??? (%d)\n", val);
12269 printf ("%s\n", attr->table[val]);
12274 return display_tag_value (tag, p, end);
12277 static unsigned char *
12278 display_gnu_attribute (unsigned char * p,
12279 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12280 const unsigned char * const end)
12286 tag = read_uleb128 (p, &len, end);
12289 /* Tag_compatibility is the only generic GNU attribute defined at
12293 val = read_uleb128 (p, &len, end);
12296 printf (_("flag = %d, vendor = "), val);
12299 printf (_("<corrupt>\n"));
12300 warn (_("corrupt vendor attribute\n"));
12306 size_t maxlen = (end - p) - 1;
12308 print_symbol ((int) maxlen, (const char *) p);
12309 p += strnlen ((char *) p, maxlen) + 1;
12313 printf (_("<corrupt>"));
12314 p = (unsigned char *) end;
12321 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12322 return display_proc_gnu_attribute (p, tag, end);
12324 return display_tag_value (tag, p, end);
12327 static unsigned char *
12328 display_power_gnu_attribute (unsigned char * p,
12330 const unsigned char * const end)
12335 if (tag == Tag_GNU_Power_ABI_FP)
12337 val = read_uleb128 (p, &len, end);
12339 printf (" Tag_GNU_Power_ABI_FP: ");
12344 printf (_("Hard or soft float\n"));
12347 printf (_("Hard float\n"));
12350 printf (_("Soft float\n"));
12353 printf (_("Single-precision hard float\n"));
12356 printf ("??? (%d)\n", val);
12362 if (tag == Tag_GNU_Power_ABI_Vector)
12364 val = read_uleb128 (p, &len, end);
12366 printf (" Tag_GNU_Power_ABI_Vector: ");
12370 printf (_("Any\n"));
12373 printf (_("Generic\n"));
12376 printf ("AltiVec\n");
12382 printf ("??? (%d)\n", val);
12388 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12392 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12396 val = read_uleb128 (p, &len, end);
12398 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12402 printf (_("Any\n"));
12405 printf ("r3/r4\n");
12408 printf (_("Memory\n"));
12411 printf ("??? (%d)\n", val);
12417 return display_tag_value (tag & 1, p, end);
12421 display_sparc_hwcaps (int mask)
12427 if (mask & ELF_SPARC_HWCAP_MUL32)
12428 fputs ("mul32", stdout), first = 0;
12429 if (mask & ELF_SPARC_HWCAP_DIV32)
12430 printf ("%sdiv32", first ? "" : "|"), first = 0;
12431 if (mask & ELF_SPARC_HWCAP_FSMULD)
12432 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12433 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12434 printf ("%sv8plus", first ? "" : "|"), first = 0;
12435 if (mask & ELF_SPARC_HWCAP_POPC)
12436 printf ("%spopc", first ? "" : "|"), first = 0;
12437 if (mask & ELF_SPARC_HWCAP_VIS)
12438 printf ("%svis", first ? "" : "|"), first = 0;
12439 if (mask & ELF_SPARC_HWCAP_VIS2)
12440 printf ("%svis2", first ? "" : "|"), first = 0;
12441 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12442 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12443 if (mask & ELF_SPARC_HWCAP_FMAF)
12444 printf ("%sfmaf", first ? "" : "|"), first = 0;
12445 if (mask & ELF_SPARC_HWCAP_VIS3)
12446 printf ("%svis3", first ? "" : "|"), first = 0;
12447 if (mask & ELF_SPARC_HWCAP_HPC)
12448 printf ("%shpc", first ? "" : "|"), first = 0;
12449 if (mask & ELF_SPARC_HWCAP_RANDOM)
12450 printf ("%srandom", first ? "" : "|"), first = 0;
12451 if (mask & ELF_SPARC_HWCAP_TRANS)
12452 printf ("%strans", first ? "" : "|"), first = 0;
12453 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12454 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12455 if (mask & ELF_SPARC_HWCAP_IMA)
12456 printf ("%sima", first ? "" : "|"), first = 0;
12457 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12458 printf ("%scspare", first ? "" : "|"), first = 0;
12461 fputc ('0', stdout);
12462 fputc ('\n', stdout);
12466 display_sparc_hwcaps2 (int mask)
12472 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12473 fputs ("fjathplus", stdout), first = 0;
12474 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12475 printf ("%svis3b", first ? "" : "|"), first = 0;
12476 if (mask & ELF_SPARC_HWCAP2_ADP)
12477 printf ("%sadp", first ? "" : "|"), first = 0;
12478 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12479 printf ("%ssparc5", first ? "" : "|"), first = 0;
12480 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12481 printf ("%smwait", first ? "" : "|"), first = 0;
12482 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12483 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12484 if (mask & ELF_SPARC_HWCAP2_XMONT)
12485 printf ("%sxmont2", first ? "" : "|"), first = 0;
12486 if (mask & ELF_SPARC_HWCAP2_NSEC)
12487 printf ("%snsec", first ? "" : "|"), first = 0;
12488 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12489 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12490 if (mask & ELF_SPARC_HWCAP2_FJDES)
12491 printf ("%sfjdes", first ? "" : "|"), first = 0;
12492 if (mask & ELF_SPARC_HWCAP2_FJAES)
12493 printf ("%sfjaes", first ? "" : "|"), first = 0;
12496 fputc ('0', stdout);
12497 fputc ('\n', stdout);
12500 static unsigned char *
12501 display_sparc_gnu_attribute (unsigned char * p,
12503 const unsigned char * const end)
12508 if (tag == Tag_GNU_Sparc_HWCAPS)
12510 val = read_uleb128 (p, &len, end);
12512 printf (" Tag_GNU_Sparc_HWCAPS: ");
12513 display_sparc_hwcaps (val);
12516 if (tag == Tag_GNU_Sparc_HWCAPS2)
12518 val = read_uleb128 (p, &len, end);
12520 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12521 display_sparc_hwcaps2 (val);
12525 return display_tag_value (tag, p, end);
12529 print_mips_fp_abi_value (int val)
12533 case Val_GNU_MIPS_ABI_FP_ANY:
12534 printf (_("Hard or soft float\n"));
12536 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12537 printf (_("Hard float (double precision)\n"));
12539 case Val_GNU_MIPS_ABI_FP_SINGLE:
12540 printf (_("Hard float (single precision)\n"));
12542 case Val_GNU_MIPS_ABI_FP_SOFT:
12543 printf (_("Soft float\n"));
12545 case Val_GNU_MIPS_ABI_FP_OLD_64:
12546 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12548 case Val_GNU_MIPS_ABI_FP_XX:
12549 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12551 case Val_GNU_MIPS_ABI_FP_64:
12552 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12554 case Val_GNU_MIPS_ABI_FP_64A:
12555 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12558 printf ("??? (%d)\n", val);
12563 static unsigned char *
12564 display_mips_gnu_attribute (unsigned char * p,
12566 const unsigned char * const end)
12568 if (tag == Tag_GNU_MIPS_ABI_FP)
12573 val = read_uleb128 (p, &len, end);
12575 printf (" Tag_GNU_MIPS_ABI_FP: ");
12577 print_mips_fp_abi_value (val);
12582 if (tag == Tag_GNU_MIPS_ABI_MSA)
12587 val = read_uleb128 (p, &len, end);
12589 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12593 case Val_GNU_MIPS_ABI_MSA_ANY:
12594 printf (_("Any MSA or not\n"));
12596 case Val_GNU_MIPS_ABI_MSA_128:
12597 printf (_("128-bit MSA\n"));
12600 printf ("??? (%d)\n", val);
12606 return display_tag_value (tag & 1, p, end);
12609 static unsigned char *
12610 display_tic6x_attribute (unsigned char * p,
12611 const unsigned char * const end)
12617 tag = read_uleb128 (p, &len, end);
12623 val = read_uleb128 (p, &len, end);
12625 printf (" Tag_ISA: ");
12629 case C6XABI_Tag_ISA_none:
12630 printf (_("None\n"));
12632 case C6XABI_Tag_ISA_C62X:
12635 case C6XABI_Tag_ISA_C67X:
12638 case C6XABI_Tag_ISA_C67XP:
12639 printf ("C67x+\n");
12641 case C6XABI_Tag_ISA_C64X:
12644 case C6XABI_Tag_ISA_C64XP:
12645 printf ("C64x+\n");
12647 case C6XABI_Tag_ISA_C674X:
12648 printf ("C674x\n");
12651 printf ("??? (%d)\n", val);
12656 case Tag_ABI_wchar_t:
12657 val = read_uleb128 (p, &len, end);
12659 printf (" Tag_ABI_wchar_t: ");
12663 printf (_("Not used\n"));
12666 printf (_("2 bytes\n"));
12669 printf (_("4 bytes\n"));
12672 printf ("??? (%d)\n", val);
12677 case Tag_ABI_stack_align_needed:
12678 val = read_uleb128 (p, &len, end);
12680 printf (" Tag_ABI_stack_align_needed: ");
12684 printf (_("8-byte\n"));
12687 printf (_("16-byte\n"));
12690 printf ("??? (%d)\n", val);
12695 case Tag_ABI_stack_align_preserved:
12696 val = read_uleb128 (p, &len, end);
12698 printf (" Tag_ABI_stack_align_preserved: ");
12702 printf (_("8-byte\n"));
12705 printf (_("16-byte\n"));
12708 printf ("??? (%d)\n", val);
12714 val = read_uleb128 (p, &len, end);
12716 printf (" Tag_ABI_DSBT: ");
12720 printf (_("DSBT addressing not used\n"));
12723 printf (_("DSBT addressing used\n"));
12726 printf ("??? (%d)\n", val);
12732 val = read_uleb128 (p, &len, end);
12734 printf (" Tag_ABI_PID: ");
12738 printf (_("Data addressing position-dependent\n"));
12741 printf (_("Data addressing position-independent, GOT near DP\n"));
12744 printf (_("Data addressing position-independent, GOT far from DP\n"));
12747 printf ("??? (%d)\n", val);
12753 val = read_uleb128 (p, &len, end);
12755 printf (" Tag_ABI_PIC: ");
12759 printf (_("Code addressing position-dependent\n"));
12762 printf (_("Code addressing position-independent\n"));
12765 printf ("??? (%d)\n", val);
12770 case Tag_ABI_array_object_alignment:
12771 val = read_uleb128 (p, &len, end);
12773 printf (" Tag_ABI_array_object_alignment: ");
12777 printf (_("8-byte\n"));
12780 printf (_("4-byte\n"));
12783 printf (_("16-byte\n"));
12786 printf ("??? (%d)\n", val);
12791 case Tag_ABI_array_object_align_expected:
12792 val = read_uleb128 (p, &len, end);
12794 printf (" Tag_ABI_array_object_align_expected: ");
12798 printf (_("8-byte\n"));
12801 printf (_("4-byte\n"));
12804 printf (_("16-byte\n"));
12807 printf ("??? (%d)\n", val);
12812 case Tag_ABI_compatibility:
12814 val = read_uleb128 (p, &len, end);
12816 printf (" Tag_ABI_compatibility: ");
12817 printf (_("flag = %d, vendor = "), val);
12820 size_t maxlen = (end - p) - 1;
12822 print_symbol ((int) maxlen, (const char *) p);
12823 p += strnlen ((char *) p, maxlen) + 1;
12827 printf (_("<corrupt>"));
12828 p = (unsigned char *) end;
12834 case Tag_ABI_conformance:
12836 printf (" Tag_ABI_conformance: \"");
12839 size_t maxlen = (end - p) - 1;
12841 print_symbol ((int) maxlen, (const char *) p);
12842 p += strnlen ((char *) p, maxlen) + 1;
12846 printf (_("<corrupt>"));
12847 p = (unsigned char *) end;
12854 return display_tag_value (tag, p, end);
12858 display_raw_attribute (unsigned char * p, unsigned char * end)
12860 unsigned long addr = 0;
12861 size_t bytes = end - p;
12868 int lbytes = (bytes > 16 ? 16 : bytes);
12870 printf (" 0x%8.8lx ", addr);
12872 for (j = 0; j < 16; j++)
12875 printf ("%2.2x", p[j]);
12883 for (j = 0; j < lbytes; j++)
12886 if (k >= ' ' && k < 0x7f)
12902 static unsigned char *
12903 display_msp430x_attribute (unsigned char * p,
12904 const unsigned char * const end)
12910 tag = read_uleb128 (p, & len, end);
12915 case OFBA_MSPABI_Tag_ISA:
12916 val = read_uleb128 (p, &len, end);
12918 printf (" Tag_ISA: ");
12921 case 0: printf (_("None\n")); break;
12922 case 1: printf (_("MSP430\n")); break;
12923 case 2: printf (_("MSP430X\n")); break;
12924 default: printf ("??? (%d)\n", val); break;
12928 case OFBA_MSPABI_Tag_Code_Model:
12929 val = read_uleb128 (p, &len, end);
12931 printf (" Tag_Code_Model: ");
12934 case 0: printf (_("None\n")); break;
12935 case 1: printf (_("Small\n")); break;
12936 case 2: printf (_("Large\n")); break;
12937 default: printf ("??? (%d)\n", val); break;
12941 case OFBA_MSPABI_Tag_Data_Model:
12942 val = read_uleb128 (p, &len, end);
12944 printf (" Tag_Data_Model: ");
12947 case 0: printf (_("None\n")); break;
12948 case 1: printf (_("Small\n")); break;
12949 case 2: printf (_("Large\n")); break;
12950 case 3: printf (_("Restricted Large\n")); break;
12951 default: printf ("??? (%d)\n", val); break;
12956 printf (_(" <unknown tag %d>: "), tag);
12963 size_t maxlen = (end - p) - 1;
12965 print_symbol ((int) maxlen, (const char *) p);
12966 p += strnlen ((char *) p, maxlen) + 1;
12970 printf (_("<corrupt>"));
12971 p = (unsigned char *) end;
12977 val = read_uleb128 (p, &len, end);
12979 printf ("%d (0x%x)\n", val, val);
12989 process_attributes (FILE * file,
12990 const char * public_name,
12991 unsigned int proc_type,
12992 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12993 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12995 Elf_Internal_Shdr * sect;
12998 /* Find the section header so that we get the size. */
12999 for (i = 0, sect = section_headers;
13000 i < elf_header.e_shnum;
13003 unsigned char * contents;
13006 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13009 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13010 sect->sh_size, _("attributes"));
13011 if (contents == NULL)
13017 bfd_vma section_len;
13019 section_len = sect->sh_size - 1;
13022 while (section_len > 0)
13025 unsigned int namelen;
13026 bfd_boolean public_section;
13027 bfd_boolean gnu_section;
13029 if (section_len <= 4)
13031 error (_("Tag section ends prematurely\n"));
13034 attr_len = byte_get (p, 4);
13037 if (attr_len > section_len)
13039 error (_("Bad attribute length (%u > %u)\n"),
13040 (unsigned) attr_len, (unsigned) section_len);
13041 attr_len = section_len;
13043 /* PR 17531: file: 001-101425-0.004 */
13044 else if (attr_len < 5)
13046 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13050 section_len -= attr_len;
13053 namelen = strnlen ((char *) p, attr_len) + 1;
13054 if (namelen == 0 || namelen >= attr_len)
13056 error (_("Corrupt attribute section name\n"));
13060 printf (_("Attribute Section: "));
13061 print_symbol (INT_MAX, (const char *) p);
13064 if (public_name && streq ((char *) p, public_name))
13065 public_section = TRUE;
13067 public_section = FALSE;
13069 if (streq ((char *) p, "gnu"))
13070 gnu_section = TRUE;
13072 gnu_section = FALSE;
13075 attr_len -= namelen;
13077 while (attr_len > 0 && p < contents + sect->sh_size)
13082 unsigned char * end;
13084 /* PR binutils/17531: Safe handling of corrupt files. */
13087 error (_("Unused bytes at end of section\n"));
13093 size = byte_get (p, 4);
13094 if (size > attr_len)
13096 error (_("Bad subsection length (%u > %u)\n"),
13097 (unsigned) size, (unsigned) attr_len);
13100 /* PR binutils/17531: Safe handling of corrupt files. */
13103 error (_("Bad subsection length (%u < 6)\n"),
13110 end = p + size - 1;
13111 assert (end <= contents + sect->sh_size);
13117 printf (_("File Attributes\n"));
13120 printf (_("Section Attributes:"));
13123 printf (_("Symbol Attributes:"));
13129 val = read_uleb128 (p, &j, end);
13133 printf (" %d", val);
13138 printf (_("Unknown tag: %d\n"), tag);
13139 public_section = FALSE;
13143 if (public_section && display_pub_attribute != NULL)
13146 p = display_pub_attribute (p, end);
13149 else if (gnu_section && display_proc_gnu_attribute != NULL)
13152 p = display_gnu_attribute (p,
13153 display_proc_gnu_attribute,
13159 printf (_(" Unknown attribute:\n"));
13160 display_raw_attribute (p, end);
13169 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13177 process_arm_specific (FILE * file)
13179 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13180 display_arm_attribute, NULL);
13184 process_power_specific (FILE * file)
13186 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13187 display_power_gnu_attribute);
13191 process_sparc_specific (FILE * file)
13193 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13194 display_sparc_gnu_attribute);
13198 process_tic6x_specific (FILE * file)
13200 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13201 display_tic6x_attribute, NULL);
13205 process_msp430x_specific (FILE * file)
13207 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13208 display_msp430x_attribute, NULL);
13211 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13212 Print the Address, Access and Initial fields of an entry at VMA ADDR
13213 and return the VMA of the next entry. */
13216 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13219 print_vma (addr, LONG_HEX);
13221 if (addr < pltgot + 0xfff0)
13222 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13224 printf ("%10s", "");
13227 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13232 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13233 print_vma (entry, LONG_HEX);
13235 return addr + (is_32bit_elf ? 4 : 8);
13238 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13239 PLTGOT. Print the Address and Initial fields of an entry at VMA
13240 ADDR and return the VMA of the next entry. */
13243 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13246 print_vma (addr, LONG_HEX);
13249 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13254 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13255 print_vma (entry, LONG_HEX);
13257 return addr + (is_32bit_elf ? 4 : 8);
13261 print_mips_ases (unsigned int mask)
13263 if (mask & AFL_ASE_DSP)
13264 fputs ("\n\tDSP ASE", stdout);
13265 if (mask & AFL_ASE_DSPR2)
13266 fputs ("\n\tDSP R2 ASE", stdout);
13267 if (mask & AFL_ASE_EVA)
13268 fputs ("\n\tEnhanced VA Scheme", stdout);
13269 if (mask & AFL_ASE_MCU)
13270 fputs ("\n\tMCU (MicroController) ASE", stdout);
13271 if (mask & AFL_ASE_MDMX)
13272 fputs ("\n\tMDMX ASE", stdout);
13273 if (mask & AFL_ASE_MIPS3D)
13274 fputs ("\n\tMIPS-3D ASE", stdout);
13275 if (mask & AFL_ASE_MT)
13276 fputs ("\n\tMT ASE", stdout);
13277 if (mask & AFL_ASE_SMARTMIPS)
13278 fputs ("\n\tSmartMIPS ASE", stdout);
13279 if (mask & AFL_ASE_VIRT)
13280 fputs ("\n\tVZ ASE", stdout);
13281 if (mask & AFL_ASE_MSA)
13282 fputs ("\n\tMSA ASE", stdout);
13283 if (mask & AFL_ASE_MIPS16)
13284 fputs ("\n\tMIPS16 ASE", stdout);
13285 if (mask & AFL_ASE_MICROMIPS)
13286 fputs ("\n\tMICROMIPS ASE", stdout);
13287 if (mask & AFL_ASE_XPA)
13288 fputs ("\n\tXPA ASE", stdout);
13290 fprintf (stdout, "\n\t%s", _("None"));
13291 else if ((mask & ~AFL_ASE_MASK) != 0)
13292 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13296 print_mips_isa_ext (unsigned int isa_ext)
13301 fputs (_("None"), stdout);
13304 fputs ("RMI XLR", stdout);
13306 case AFL_EXT_OCTEON3:
13307 fputs ("Cavium Networks Octeon3", stdout);
13309 case AFL_EXT_OCTEON2:
13310 fputs ("Cavium Networks Octeon2", stdout);
13312 case AFL_EXT_OCTEONP:
13313 fputs ("Cavium Networks OcteonP", stdout);
13315 case AFL_EXT_LOONGSON_3A:
13316 fputs ("Loongson 3A", stdout);
13318 case AFL_EXT_OCTEON:
13319 fputs ("Cavium Networks Octeon", stdout);
13322 fputs ("Toshiba R5900", stdout);
13325 fputs ("MIPS R4650", stdout);
13328 fputs ("LSI R4010", stdout);
13331 fputs ("NEC VR4100", stdout);
13334 fputs ("Toshiba R3900", stdout);
13336 case AFL_EXT_10000:
13337 fputs ("MIPS R10000", stdout);
13340 fputs ("Broadcom SB-1", stdout);
13343 fputs ("NEC VR4111/VR4181", stdout);
13346 fputs ("NEC VR4120", stdout);
13349 fputs ("NEC VR5400", stdout);
13352 fputs ("NEC VR5500", stdout);
13354 case AFL_EXT_LOONGSON_2E:
13355 fputs ("ST Microelectronics Loongson 2E", stdout);
13357 case AFL_EXT_LOONGSON_2F:
13358 fputs ("ST Microelectronics Loongson 2F", stdout);
13361 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13366 get_mips_reg_size (int reg_size)
13368 return (reg_size == AFL_REG_NONE) ? 0
13369 : (reg_size == AFL_REG_32) ? 32
13370 : (reg_size == AFL_REG_64) ? 64
13371 : (reg_size == AFL_REG_128) ? 128
13376 process_mips_specific (FILE * file)
13378 Elf_Internal_Dyn * entry;
13379 Elf_Internal_Shdr *sect = NULL;
13380 size_t liblist_offset = 0;
13381 size_t liblistno = 0;
13382 size_t conflictsno = 0;
13383 size_t options_offset = 0;
13384 size_t conflicts_offset = 0;
13385 size_t pltrelsz = 0;
13387 bfd_vma pltgot = 0;
13388 bfd_vma mips_pltgot = 0;
13389 bfd_vma jmprel = 0;
13390 bfd_vma local_gotno = 0;
13391 bfd_vma gotsym = 0;
13392 bfd_vma symtabno = 0;
13394 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13395 display_mips_gnu_attribute);
13397 sect = find_section (".MIPS.abiflags");
13401 Elf_External_ABIFlags_v0 *abiflags_ext;
13402 Elf_Internal_ABIFlags_v0 abiflags_in;
13404 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13405 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13408 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13409 sect->sh_size, _("MIPS ABI Flags section"));
13412 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13413 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13414 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13415 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13416 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13417 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13418 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13419 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13420 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13421 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13422 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13424 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13425 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13426 if (abiflags_in.isa_rev > 1)
13427 printf ("r%d", abiflags_in.isa_rev);
13428 printf ("\nGPR size: %d",
13429 get_mips_reg_size (abiflags_in.gpr_size));
13430 printf ("\nCPR1 size: %d",
13431 get_mips_reg_size (abiflags_in.cpr1_size));
13432 printf ("\nCPR2 size: %d",
13433 get_mips_reg_size (abiflags_in.cpr2_size));
13434 fputs ("\nFP ABI: ", stdout);
13435 print_mips_fp_abi_value (abiflags_in.fp_abi);
13436 fputs ("ISA Extension: ", stdout);
13437 print_mips_isa_ext (abiflags_in.isa_ext);
13438 fputs ("\nASEs:", stdout);
13439 print_mips_ases (abiflags_in.ases);
13440 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13441 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13442 fputc ('\n', stdout);
13443 free (abiflags_ext);
13448 /* We have a lot of special sections. Thanks SGI! */
13449 if (dynamic_section == NULL)
13450 /* No information available. */
13453 for (entry = dynamic_section;
13454 /* PR 17531 file: 012-50589-0.004. */
13455 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13457 switch (entry->d_tag)
13459 case DT_MIPS_LIBLIST:
13461 = offset_from_vma (file, entry->d_un.d_val,
13462 liblistno * sizeof (Elf32_External_Lib));
13464 case DT_MIPS_LIBLISTNO:
13465 liblistno = entry->d_un.d_val;
13467 case DT_MIPS_OPTIONS:
13468 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13470 case DT_MIPS_CONFLICT:
13472 = offset_from_vma (file, entry->d_un.d_val,
13473 conflictsno * sizeof (Elf32_External_Conflict));
13475 case DT_MIPS_CONFLICTNO:
13476 conflictsno = entry->d_un.d_val;
13479 pltgot = entry->d_un.d_ptr;
13481 case DT_MIPS_LOCAL_GOTNO:
13482 local_gotno = entry->d_un.d_val;
13484 case DT_MIPS_GOTSYM:
13485 gotsym = entry->d_un.d_val;
13487 case DT_MIPS_SYMTABNO:
13488 symtabno = entry->d_un.d_val;
13490 case DT_MIPS_PLTGOT:
13491 mips_pltgot = entry->d_un.d_ptr;
13494 pltrel = entry->d_un.d_val;
13497 pltrelsz = entry->d_un.d_val;
13500 jmprel = entry->d_un.d_ptr;
13506 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13508 Elf32_External_Lib * elib;
13511 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13513 sizeof (Elf32_External_Lib),
13514 _("liblist section data"));
13517 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13518 (unsigned long) liblistno);
13519 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13522 for (cnt = 0; cnt < liblistno; ++cnt)
13529 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13530 atime = BYTE_GET (elib[cnt].l_time_stamp);
13531 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13532 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13533 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13535 tmp = gmtime (&atime);
13536 snprintf (timebuf, sizeof (timebuf),
13537 "%04u-%02u-%02uT%02u:%02u:%02u",
13538 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13539 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13541 printf ("%3lu: ", (unsigned long) cnt);
13542 if (VALID_DYNAMIC_NAME (liblist.l_name))
13543 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13545 printf (_("<corrupt: %9ld>"), liblist.l_name);
13546 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13547 liblist.l_version);
13549 if (liblist.l_flags == 0)
13553 static const struct
13560 { " EXACT_MATCH", LL_EXACT_MATCH },
13561 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13562 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13563 { " EXPORTS", LL_EXPORTS },
13564 { " DELAY_LOAD", LL_DELAY_LOAD },
13565 { " DELTA", LL_DELTA }
13567 int flags = liblist.l_flags;
13570 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13571 if ((flags & l_flags_vals[fcnt].bit) != 0)
13573 fputs (l_flags_vals[fcnt].name, stdout);
13574 flags ^= l_flags_vals[fcnt].bit;
13577 printf (" %#x", (unsigned int) flags);
13587 if (options_offset != 0)
13589 Elf_External_Options * eopt;
13590 Elf_Internal_Options * iopt;
13591 Elf_Internal_Options * option;
13594 sect = section_headers;
13596 /* Find the section header so that we get the size. */
13597 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13598 /* PR 17533 file: 012-277276-0.004. */
13601 error (_("No MIPS_OPTIONS header found\n"));
13605 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13606 sect->sh_size, _("options"));
13609 iopt = (Elf_Internal_Options *)
13610 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13613 error (_("Out of memory allocatinf space for MIPS options\n"));
13620 while (offset < sect->sh_size)
13622 Elf_External_Options * eoption;
13624 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13626 option->kind = BYTE_GET (eoption->kind);
13627 option->size = BYTE_GET (eoption->size);
13628 option->section = BYTE_GET (eoption->section);
13629 option->info = BYTE_GET (eoption->info);
13631 offset += option->size;
13637 printf (_("\nSection '%s' contains %d entries:\n"),
13638 printable_section_name (sect), cnt);
13646 switch (option->kind)
13649 /* This shouldn't happen. */
13650 printf (" NULL %d %lx", option->section, option->info);
13653 printf (" REGINFO ");
13654 if (elf_header.e_machine == EM_MIPS)
13657 Elf32_External_RegInfo * ereg;
13658 Elf32_RegInfo reginfo;
13660 ereg = (Elf32_External_RegInfo *) (option + 1);
13661 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13662 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13663 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13664 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13665 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13666 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13668 printf ("GPR %08lx GP 0x%lx\n",
13669 reginfo.ri_gprmask,
13670 (unsigned long) reginfo.ri_gp_value);
13671 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13672 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13673 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13678 Elf64_External_RegInfo * ereg;
13679 Elf64_Internal_RegInfo reginfo;
13681 ereg = (Elf64_External_RegInfo *) (option + 1);
13682 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13683 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13684 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13685 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13686 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13687 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13689 printf ("GPR %08lx GP 0x",
13690 reginfo.ri_gprmask);
13691 printf_vma (reginfo.ri_gp_value);
13694 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13695 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13696 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13700 case ODK_EXCEPTIONS:
13701 fputs (" EXCEPTIONS fpe_min(", stdout);
13702 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13703 fputs (") fpe_max(", stdout);
13704 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13705 fputs (")", stdout);
13707 if (option->info & OEX_PAGE0)
13708 fputs (" PAGE0", stdout);
13709 if (option->info & OEX_SMM)
13710 fputs (" SMM", stdout);
13711 if (option->info & OEX_FPDBUG)
13712 fputs (" FPDBUG", stdout);
13713 if (option->info & OEX_DISMISS)
13714 fputs (" DISMISS", stdout);
13717 fputs (" PAD ", stdout);
13718 if (option->info & OPAD_PREFIX)
13719 fputs (" PREFIX", stdout);
13720 if (option->info & OPAD_POSTFIX)
13721 fputs (" POSTFIX", stdout);
13722 if (option->info & OPAD_SYMBOL)
13723 fputs (" SYMBOL", stdout);
13726 fputs (" HWPATCH ", stdout);
13727 if (option->info & OHW_R4KEOP)
13728 fputs (" R4KEOP", stdout);
13729 if (option->info & OHW_R8KPFETCH)
13730 fputs (" R8KPFETCH", stdout);
13731 if (option->info & OHW_R5KEOP)
13732 fputs (" R5KEOP", stdout);
13733 if (option->info & OHW_R5KCVTL)
13734 fputs (" R5KCVTL", stdout);
13737 fputs (" FILL ", stdout);
13738 /* XXX Print content of info word? */
13741 fputs (" TAGS ", stdout);
13742 /* XXX Print content of info word? */
13745 fputs (" HWAND ", stdout);
13746 if (option->info & OHWA0_R4KEOP_CHECKED)
13747 fputs (" R4KEOP_CHECKED", stdout);
13748 if (option->info & OHWA0_R4KEOP_CLEAN)
13749 fputs (" R4KEOP_CLEAN", stdout);
13752 fputs (" HWOR ", stdout);
13753 if (option->info & OHWA0_R4KEOP_CHECKED)
13754 fputs (" R4KEOP_CHECKED", stdout);
13755 if (option->info & OHWA0_R4KEOP_CLEAN)
13756 fputs (" R4KEOP_CLEAN", stdout);
13759 printf (" GP_GROUP %#06lx self-contained %#06lx",
13760 option->info & OGP_GROUP,
13761 (option->info & OGP_SELF) >> 16);
13764 printf (" IDENT %#06lx self-contained %#06lx",
13765 option->info & OGP_GROUP,
13766 (option->info & OGP_SELF) >> 16);
13769 /* This shouldn't happen. */
13770 printf (" %3d ??? %d %lx",
13771 option->kind, option->section, option->info);
13775 len = sizeof (* eopt);
13776 while (len < option->size)
13777 if (((char *) option)[len] >= ' '
13778 && ((char *) option)[len] < 0x7f)
13779 printf ("%c", ((char *) option)[len++]);
13781 printf ("\\%03o", ((char *) option)[len++]);
13783 fputs ("\n", stdout);
13791 if (conflicts_offset != 0 && conflictsno != 0)
13793 Elf32_Conflict * iconf;
13796 if (dynamic_symbols == NULL)
13798 error (_("conflict list found without a dynamic symbol table\n"));
13802 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13805 error (_("Out of memory allocating space for dynamic conflicts\n"));
13811 Elf32_External_Conflict * econf32;
13813 econf32 = (Elf32_External_Conflict *)
13814 get_data (NULL, file, conflicts_offset, conflictsno,
13815 sizeof (* econf32), _("conflict"));
13819 for (cnt = 0; cnt < conflictsno; ++cnt)
13820 iconf[cnt] = BYTE_GET (econf32[cnt]);
13826 Elf64_External_Conflict * econf64;
13828 econf64 = (Elf64_External_Conflict *)
13829 get_data (NULL, file, conflicts_offset, conflictsno,
13830 sizeof (* econf64), _("conflict"));
13834 for (cnt = 0; cnt < conflictsno; ++cnt)
13835 iconf[cnt] = BYTE_GET (econf64[cnt]);
13840 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13841 (unsigned long) conflictsno);
13842 puts (_(" Num: Index Value Name"));
13844 for (cnt = 0; cnt < conflictsno; ++cnt)
13846 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
13848 if (iconf[cnt] >= num_dynamic_syms)
13849 printf (_("<corrupt symbol index>"));
13852 Elf_Internal_Sym * psym;
13854 psym = & dynamic_symbols[iconf[cnt]];
13855 print_vma (psym->st_value, FULL_HEX);
13857 if (VALID_DYNAMIC_NAME (psym->st_name))
13858 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13860 printf (_("<corrupt: %14ld>"), psym->st_name);
13868 if (pltgot != 0 && local_gotno != 0)
13870 bfd_vma ent, local_end, global_end;
13872 unsigned char * data;
13876 addr_size = (is_32bit_elf ? 4 : 8);
13877 local_end = pltgot + local_gotno * addr_size;
13879 /* PR binutils/17533 file: 012-111227-0.004 */
13880 if (symtabno < gotsym)
13882 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13883 (long) gotsym, (long) symtabno);
13887 global_end = local_end + (symtabno - gotsym) * addr_size;
13888 assert (global_end >= local_end);
13889 offset = offset_from_vma (file, pltgot, global_end - pltgot);
13890 data = (unsigned char *) get_data (NULL, file, offset,
13891 global_end - pltgot, 1,
13892 _("Global Offset Table data"));
13896 printf (_("\nPrimary GOT:\n"));
13897 printf (_(" Canonical gp value: "));
13898 print_vma (pltgot + 0x7ff0, LONG_HEX);
13901 printf (_(" Reserved entries:\n"));
13902 printf (_(" %*s %10s %*s Purpose\n"),
13903 addr_size * 2, _("Address"), _("Access"),
13904 addr_size * 2, _("Initial"));
13905 ent = print_mips_got_entry (data, pltgot, ent);
13906 printf (_(" Lazy resolver\n"));
13908 && (byte_get (data + ent - pltgot, addr_size)
13909 >> (addr_size * 8 - 1)) != 0)
13911 ent = print_mips_got_entry (data, pltgot, ent);
13912 printf (_(" Module pointer (GNU extension)\n"));
13916 if (ent < local_end)
13918 printf (_(" Local entries:\n"));
13919 printf (" %*s %10s %*s\n",
13920 addr_size * 2, _("Address"), _("Access"),
13921 addr_size * 2, _("Initial"));
13922 while (ent < local_end)
13924 ent = print_mips_got_entry (data, pltgot, ent);
13930 if (gotsym < symtabno)
13934 printf (_(" Global entries:\n"));
13935 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13936 addr_size * 2, _("Address"),
13938 addr_size * 2, _("Initial"),
13939 addr_size * 2, _("Sym.Val."),
13941 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13942 _("Ndx"), _("Name"));
13944 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13946 for (i = gotsym; i < symtabno; i++)
13948 ent = print_mips_got_entry (data, pltgot, ent);
13951 if (dynamic_symbols == NULL)
13952 printf (_("<no dynamic symbols>"));
13953 else if (i < num_dynamic_syms)
13955 Elf_Internal_Sym * psym = dynamic_symbols + i;
13957 print_vma (psym->st_value, LONG_HEX);
13958 printf (" %-7s %3s ",
13959 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13960 get_symbol_index_type (psym->st_shndx));
13962 if (VALID_DYNAMIC_NAME (psym->st_name))
13963 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13965 printf (_("<corrupt: %14ld>"), psym->st_name);
13968 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13969 (unsigned long) i);
13980 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13983 size_t offset, rel_offset;
13984 unsigned long count, i;
13985 unsigned char * data;
13986 int addr_size, sym_width;
13987 Elf_Internal_Rela * rels;
13989 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13990 if (pltrel == DT_RELA)
13992 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13997 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14002 addr_size = (is_32bit_elf ? 4 : 8);
14003 end = mips_pltgot + (2 + count) * addr_size;
14005 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14006 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14007 1, _("Procedure Linkage Table data"));
14011 printf ("\nPLT GOT:\n\n");
14012 printf (_(" Reserved entries:\n"));
14013 printf (_(" %*s %*s Purpose\n"),
14014 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14015 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14016 printf (_(" PLT lazy resolver\n"));
14017 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14018 printf (_(" Module pointer\n"));
14021 printf (_(" Entries:\n"));
14022 printf (" %*s %*s %*s %-7s %3s %s\n",
14023 addr_size * 2, _("Address"),
14024 addr_size * 2, _("Initial"),
14025 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14026 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14027 for (i = 0; i < count; i++)
14029 unsigned long idx = get_reloc_symindex (rels[i].r_info);
14031 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14034 if (idx >= num_dynamic_syms)
14035 printf (_("<corrupt symbol index: %lu>"), idx);
14038 Elf_Internal_Sym * psym = dynamic_symbols + idx;
14040 print_vma (psym->st_value, LONG_HEX);
14041 printf (" %-7s %3s ",
14042 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14043 get_symbol_index_type (psym->st_shndx));
14044 if (VALID_DYNAMIC_NAME (psym->st_name))
14045 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14047 printf (_("<corrupt: %14ld>"), psym->st_name);
14062 process_nds32_specific (FILE * file)
14064 Elf_Internal_Shdr *sect = NULL;
14066 sect = find_section (".nds32_e_flags");
14069 unsigned int *flag;
14071 printf ("\nNDS32 elf flags section:\n");
14072 flag = get_data (NULL, file, sect->sh_offset, 1,
14073 sect->sh_size, _("NDS32 elf flags section"));
14075 switch ((*flag) & 0x3)
14078 printf ("(VEC_SIZE):\tNo entry.\n");
14081 printf ("(VEC_SIZE):\t4 bytes\n");
14084 printf ("(VEC_SIZE):\t16 bytes\n");
14087 printf ("(VEC_SIZE):\treserved\n");
14096 process_gnu_liblist (FILE * file)
14098 Elf_Internal_Shdr * section;
14099 Elf_Internal_Shdr * string_sec;
14100 Elf32_External_Lib * elib;
14102 size_t strtab_size;
14109 for (i = 0, section = section_headers;
14110 i < elf_header.e_shnum;
14113 switch (section->sh_type)
14115 case SHT_GNU_LIBLIST:
14116 if (section->sh_link >= elf_header.e_shnum)
14119 elib = (Elf32_External_Lib *)
14120 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14121 _("liblist section data"));
14125 string_sec = section_headers + section->sh_link;
14127 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14128 string_sec->sh_size,
14129 _("liblist string table"));
14131 || section->sh_entsize != sizeof (Elf32_External_Lib))
14137 strtab_size = string_sec->sh_size;
14139 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14140 printable_section_name (section),
14141 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14143 puts (_(" Library Time Stamp Checksum Version Flags"));
14145 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14153 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14154 atime = BYTE_GET (elib[cnt].l_time_stamp);
14155 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14156 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14157 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14159 tmp = gmtime (&atime);
14160 snprintf (timebuf, sizeof (timebuf),
14161 "%04u-%02u-%02uT%02u:%02u:%02u",
14162 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14163 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14165 printf ("%3lu: ", (unsigned long) cnt);
14167 printf ("%-20s", liblist.l_name < strtab_size
14168 ? strtab + liblist.l_name : _("<corrupt>"));
14170 printf ("%-20.20s", liblist.l_name < strtab_size
14171 ? strtab + liblist.l_name : _("<corrupt>"));
14172 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14173 liblist.l_version, liblist.l_flags);
14184 static const char *
14185 get_note_type (unsigned e_type)
14187 static char buff[64];
14189 if (elf_header.e_type == ET_CORE)
14193 return _("NT_AUXV (auxiliary vector)");
14195 return _("NT_PRSTATUS (prstatus structure)");
14197 return _("NT_FPREGSET (floating point registers)");
14199 return _("NT_PRPSINFO (prpsinfo structure)");
14200 case NT_TASKSTRUCT:
14201 return _("NT_TASKSTRUCT (task structure)");
14203 return _("NT_PRXFPREG (user_xfpregs structure)");
14205 return _("NT_PPC_VMX (ppc Altivec registers)");
14207 return _("NT_PPC_VSX (ppc VSX registers)");
14209 return _("NT_386_TLS (x86 TLS information)");
14210 case NT_386_IOPERM:
14211 return _("NT_386_IOPERM (x86 I/O permissions)");
14212 case NT_X86_XSTATE:
14213 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14214 case NT_S390_HIGH_GPRS:
14215 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14216 case NT_S390_TIMER:
14217 return _("NT_S390_TIMER (s390 timer register)");
14218 case NT_S390_TODCMP:
14219 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14220 case NT_S390_TODPREG:
14221 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14223 return _("NT_S390_CTRS (s390 control registers)");
14224 case NT_S390_PREFIX:
14225 return _("NT_S390_PREFIX (s390 prefix register)");
14226 case NT_S390_LAST_BREAK:
14227 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14228 case NT_S390_SYSTEM_CALL:
14229 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14231 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14233 return _("NT_ARM_VFP (arm VFP registers)");
14235 return _("NT_ARM_TLS (AArch TLS registers)");
14236 case NT_ARM_HW_BREAK:
14237 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14238 case NT_ARM_HW_WATCH:
14239 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14241 return _("NT_PSTATUS (pstatus structure)");
14243 return _("NT_FPREGS (floating point registers)");
14245 return _("NT_PSINFO (psinfo structure)");
14247 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14249 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14250 case NT_WIN32PSTATUS:
14251 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14253 return _("NT_SIGINFO (siginfo_t data)");
14255 return _("NT_FILE (mapped files)");
14263 return _("NT_VERSION (version)");
14265 return _("NT_ARCH (architecture)");
14270 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14275 print_core_note (Elf_Internal_Note *pnote)
14277 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14278 bfd_vma count, page_size;
14279 unsigned char *descdata, *filenames, *descend;
14281 if (pnote->type != NT_FILE)
14287 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14288 /* Still "successful". */
14293 if (pnote->descsz < 2 * addr_size)
14295 printf (_(" Malformed note - too short for header\n"));
14299 descdata = (unsigned char *) pnote->descdata;
14300 descend = descdata + pnote->descsz;
14302 if (descdata[pnote->descsz - 1] != '\0')
14304 printf (_(" Malformed note - does not end with \\0\n"));
14308 count = byte_get (descdata, addr_size);
14309 descdata += addr_size;
14311 page_size = byte_get (descdata, addr_size);
14312 descdata += addr_size;
14314 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14316 printf (_(" Malformed note - too short for supplied file count\n"));
14320 printf (_(" Page size: "));
14321 print_vma (page_size, DEC);
14324 printf (_(" %*s%*s%*s\n"),
14325 (int) (2 + 2 * addr_size), _("Start"),
14326 (int) (4 + 2 * addr_size), _("End"),
14327 (int) (4 + 2 * addr_size), _("Page Offset"));
14328 filenames = descdata + count * 3 * addr_size;
14329 while (--count > 0)
14331 bfd_vma start, end, file_ofs;
14333 if (filenames == descend)
14335 printf (_(" Malformed note - filenames end too early\n"));
14339 start = byte_get (descdata, addr_size);
14340 descdata += addr_size;
14341 end = byte_get (descdata, addr_size);
14342 descdata += addr_size;
14343 file_ofs = byte_get (descdata, addr_size);
14344 descdata += addr_size;
14347 print_vma (start, FULL_HEX);
14349 print_vma (end, FULL_HEX);
14351 print_vma (file_ofs, FULL_HEX);
14352 printf ("\n %s\n", filenames);
14354 filenames += 1 + strlen ((char *) filenames);
14360 static const char *
14361 get_gnu_elf_note_type (unsigned e_type)
14363 static char buff[64];
14367 case NT_GNU_ABI_TAG:
14368 return _("NT_GNU_ABI_TAG (ABI version tag)");
14370 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14371 case NT_GNU_BUILD_ID:
14372 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14373 case NT_GNU_GOLD_VERSION:
14374 return _("NT_GNU_GOLD_VERSION (gold version)");
14379 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14384 print_gnu_note (Elf_Internal_Note *pnote)
14386 switch (pnote->type)
14388 case NT_GNU_BUILD_ID:
14392 printf (_(" Build ID: "));
14393 for (i = 0; i < pnote->descsz; ++i)
14394 printf ("%02x", pnote->descdata[i] & 0xff);
14399 case NT_GNU_ABI_TAG:
14401 unsigned long os, major, minor, subminor;
14402 const char *osname;
14404 /* PR 17531: file: 030-599401-0.004. */
14405 if (pnote->descsz < 16)
14407 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14411 os = byte_get ((unsigned char *) pnote->descdata, 4);
14412 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14413 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14414 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14418 case GNU_ABI_TAG_LINUX:
14421 case GNU_ABI_TAG_HURD:
14424 case GNU_ABI_TAG_SOLARIS:
14425 osname = "Solaris";
14427 case GNU_ABI_TAG_FREEBSD:
14428 osname = "FreeBSD";
14430 case GNU_ABI_TAG_NETBSD:
14434 osname = "Unknown";
14438 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14439 major, minor, subminor);
14443 case NT_GNU_GOLD_VERSION:
14447 printf (_(" Version: "));
14448 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14449 printf ("%c", pnote->descdata[i]);
14458 static const char *
14459 get_netbsd_elfcore_note_type (unsigned e_type)
14461 static char buff[64];
14463 if (e_type == NT_NETBSDCORE_PROCINFO)
14465 /* NetBSD core "procinfo" structure. */
14466 return _("NetBSD procinfo structure");
14469 /* As of Jan 2002 there are no other machine-independent notes
14470 defined for NetBSD core files. If the note type is less
14471 than the start of the machine-dependent note types, we don't
14474 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14476 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14480 switch (elf_header.e_machine)
14482 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14483 and PT_GETFPREGS == mach+2. */
14488 case EM_SPARC32PLUS:
14492 case NT_NETBSDCORE_FIRSTMACH + 0:
14493 return _("PT_GETREGS (reg structure)");
14494 case NT_NETBSDCORE_FIRSTMACH + 2:
14495 return _("PT_GETFPREGS (fpreg structure)");
14501 /* On all other arch's, PT_GETREGS == mach+1 and
14502 PT_GETFPREGS == mach+3. */
14506 case NT_NETBSDCORE_FIRSTMACH + 1:
14507 return _("PT_GETREGS (reg structure)");
14508 case NT_NETBSDCORE_FIRSTMACH + 3:
14509 return _("PT_GETFPREGS (fpreg structure)");
14515 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14516 e_type - NT_NETBSDCORE_FIRSTMACH);
14520 static const char *
14521 get_stapsdt_note_type (unsigned e_type)
14523 static char buff[64];
14528 return _("NT_STAPSDT (SystemTap probe descriptors)");
14534 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14539 print_stapsdt_note (Elf_Internal_Note *pnote)
14541 int addr_size = is_32bit_elf ? 4 : 8;
14542 char *data = pnote->descdata;
14543 char *data_end = pnote->descdata + pnote->descsz;
14544 bfd_vma pc, base_addr, semaphore;
14545 char *provider, *probe, *arg_fmt;
14547 pc = byte_get ((unsigned char *) data, addr_size);
14549 base_addr = byte_get ((unsigned char *) data, addr_size);
14551 semaphore = byte_get ((unsigned char *) data, addr_size);
14555 data += strlen (data) + 1;
14557 data += strlen (data) + 1;
14559 data += strlen (data) + 1;
14561 printf (_(" Provider: %s\n"), provider);
14562 printf (_(" Name: %s\n"), probe);
14563 printf (_(" Location: "));
14564 print_vma (pc, FULL_HEX);
14565 printf (_(", Base: "));
14566 print_vma (base_addr, FULL_HEX);
14567 printf (_(", Semaphore: "));
14568 print_vma (semaphore, FULL_HEX);
14570 printf (_(" Arguments: %s\n"), arg_fmt);
14572 return data == data_end;
14575 static const char *
14576 get_ia64_vms_note_type (unsigned e_type)
14578 static char buff[64];
14583 return _("NT_VMS_MHD (module header)");
14585 return _("NT_VMS_LNM (language name)");
14587 return _("NT_VMS_SRC (source files)");
14589 return "NT_VMS_TITLE";
14591 return _("NT_VMS_EIDC (consistency check)");
14592 case NT_VMS_FPMODE:
14593 return _("NT_VMS_FPMODE (FP mode)");
14594 case NT_VMS_LINKTIME:
14595 return "NT_VMS_LINKTIME";
14596 case NT_VMS_IMGNAM:
14597 return _("NT_VMS_IMGNAM (image name)");
14599 return _("NT_VMS_IMGID (image id)");
14600 case NT_VMS_LINKID:
14601 return _("NT_VMS_LINKID (link id)");
14602 case NT_VMS_IMGBID:
14603 return _("NT_VMS_IMGBID (build id)");
14604 case NT_VMS_GSTNAM:
14605 return _("NT_VMS_GSTNAM (sym table name)");
14606 case NT_VMS_ORIG_DYN:
14607 return "NT_VMS_ORIG_DYN";
14608 case NT_VMS_PATCHTIME:
14609 return "NT_VMS_PATCHTIME";
14611 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14617 print_ia64_vms_note (Elf_Internal_Note * pnote)
14619 switch (pnote->type)
14622 if (pnote->descsz > 36)
14624 size_t l = strlen (pnote->descdata + 34);
14625 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14626 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14627 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14628 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14631 printf (_(" Invalid size\n"));
14634 printf (_(" Language: %s\n"), pnote->descdata);
14637 case NT_VMS_FPMODE:
14638 printf (_(" Floating Point mode: "));
14639 printf ("0x%016" BFD_VMA_FMT "x\n",
14640 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14642 case NT_VMS_LINKTIME:
14643 printf (_(" Link time: "));
14645 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14648 case NT_VMS_PATCHTIME:
14649 printf (_(" Patch time: "));
14651 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14654 case NT_VMS_ORIG_DYN:
14655 printf (_(" Major id: %u, minor id: %u\n"),
14656 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14657 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14658 printf (_(" Last modified : "));
14660 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14661 printf (_("\n Link flags : "));
14662 printf ("0x%016" BFD_VMA_FMT "x\n",
14663 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14664 printf (_(" Header flags: 0x%08x\n"),
14665 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14666 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14669 case NT_VMS_IMGNAM:
14670 printf (_(" Image name: %s\n"), pnote->descdata);
14672 case NT_VMS_GSTNAM:
14673 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14676 printf (_(" Image id: %s\n"), pnote->descdata);
14678 case NT_VMS_LINKID:
14679 printf (_(" Linker id: %s\n"), pnote->descdata);
14687 /* Note that by the ELF standard, the name field is already null byte
14688 terminated, and namesz includes the terminating null byte.
14689 I.E. the value of namesz for the name "FSF" is 4.
14691 If the value of namesz is zero, there is no name present. */
14693 process_note (Elf_Internal_Note * pnote)
14695 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14698 if (pnote->namesz == 0)
14699 /* If there is no note name, then use the default set of
14700 note type strings. */
14701 nt = get_note_type (pnote->type);
14703 else if (const_strneq (pnote->namedata, "GNU"))
14704 /* GNU-specific object file notes. */
14705 nt = get_gnu_elf_note_type (pnote->type);
14707 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14708 /* NetBSD-specific core file notes. */
14709 nt = get_netbsd_elfcore_note_type (pnote->type);
14711 else if (strneq (pnote->namedata, "SPU/", 4))
14713 /* SPU-specific core file notes. */
14714 nt = pnote->namedata + 4;
14718 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14719 /* VMS/ia64-specific file notes. */
14720 nt = get_ia64_vms_note_type (pnote->type);
14722 else if (const_strneq (pnote->namedata, "stapsdt"))
14723 nt = get_stapsdt_note_type (pnote->type);
14726 /* Don't recognize this note name; just use the default set of
14727 note type strings. */
14728 nt = get_note_type (pnote->type);
14730 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14732 if (const_strneq (pnote->namedata, "IPF/VMS"))
14733 return print_ia64_vms_note (pnote);
14734 else if (const_strneq (pnote->namedata, "GNU"))
14735 return print_gnu_note (pnote);
14736 else if (const_strneq (pnote->namedata, "stapsdt"))
14737 return print_stapsdt_note (pnote);
14738 else if (const_strneq (pnote->namedata, "CORE"))
14739 return print_core_note (pnote);
14746 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14748 Elf_External_Note * pnotes;
14749 Elf_External_Note * external;
14755 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14757 if (pnotes == NULL)
14762 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14763 (unsigned long) offset, (unsigned long) length);
14764 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14766 while ((char *) external < (char *) pnotes + length)
14768 Elf_Internal_Note inote;
14771 char * temp = NULL;
14772 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14774 if (!is_ia64_vms ())
14776 /* PR binutils/15191
14777 Make sure that there is enough data to read. */
14778 min_notesz = offsetof (Elf_External_Note, name);
14779 if (data_remaining < min_notesz)
14781 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14782 (int) data_remaining);
14785 inote.type = BYTE_GET (external->type);
14786 inote.namesz = BYTE_GET (external->namesz);
14787 inote.namedata = external->name;
14788 inote.descsz = BYTE_GET (external->descsz);
14789 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14790 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14791 next = inote.descdata + align_power (inote.descsz, 2);
14795 Elf64_External_VMS_Note *vms_external;
14797 /* PR binutils/15191
14798 Make sure that there is enough data to read. */
14799 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14800 if (data_remaining < min_notesz)
14802 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14803 (int) data_remaining);
14807 vms_external = (Elf64_External_VMS_Note *) external;
14808 inote.type = BYTE_GET (vms_external->type);
14809 inote.namesz = BYTE_GET (vms_external->namesz);
14810 inote.namedata = vms_external->name;
14811 inote.descsz = BYTE_GET (vms_external->descsz);
14812 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14813 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14814 next = inote.descdata + align_power (inote.descsz, 3);
14817 if (inote.descdata < (char *) external + min_notesz
14818 || next < (char *) external + min_notesz
14819 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14820 || inote.namedata + inote.namesz < inote.namedata
14821 || inote.descdata + inote.descsz < inote.descdata
14822 || data_remaining < (size_t)(next - (char *) external))
14824 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14825 (unsigned long) ((char *) external - (char *) pnotes));
14826 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14827 inote.type, inote.namesz, inote.descsz);
14831 external = (Elf_External_Note *) next;
14833 /* Verify that name is null terminated. It appears that at least
14834 one version of Linux (RedHat 6.0) generates corefiles that don't
14835 comply with the ELF spec by failing to include the null byte in
14837 if (inote.namedata[inote.namesz - 1] != '\0')
14839 temp = (char *) malloc (inote.namesz + 1);
14842 error (_("Out of memory allocating space for inote name\n"));
14847 strncpy (temp, inote.namedata, inote.namesz);
14848 temp[inote.namesz] = 0;
14850 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14851 inote.namedata = temp;
14854 res &= process_note (& inote);
14869 process_corefile_note_segments (FILE * file)
14871 Elf_Internal_Phdr * segment;
14875 if (! get_program_headers (file))
14878 for (i = 0, segment = program_headers;
14879 i < elf_header.e_phnum;
14882 if (segment->p_type == PT_NOTE)
14883 res &= process_corefile_note_segment (file,
14884 (bfd_vma) segment->p_offset,
14885 (bfd_vma) segment->p_filesz);
14892 process_note_sections (FILE * file)
14894 Elf_Internal_Shdr * section;
14899 for (i = 0, section = section_headers;
14900 i < elf_header.e_shnum && section != NULL;
14902 if (section->sh_type == SHT_NOTE)
14904 res &= process_corefile_note_segment (file,
14905 (bfd_vma) section->sh_offset,
14906 (bfd_vma) section->sh_size);
14911 /* Try processing NOTE segments instead. */
14912 return process_corefile_note_segments (file);
14918 process_notes (FILE * file)
14920 /* If we have not been asked to display the notes then do nothing. */
14924 if (elf_header.e_type != ET_CORE)
14925 return process_note_sections (file);
14927 /* No program headers means no NOTE segment. */
14928 if (elf_header.e_phnum > 0)
14929 return process_corefile_note_segments (file);
14931 printf (_("No note segments present in the core file.\n"));
14936 process_arch_specific (FILE * file)
14941 switch (elf_header.e_machine)
14944 return process_arm_specific (file);
14946 case EM_MIPS_RS3_LE:
14947 return process_mips_specific (file);
14950 return process_nds32_specific (file);
14953 return process_power_specific (file);
14956 case EM_SPARC32PLUS:
14958 return process_sparc_specific (file);
14961 return process_tic6x_specific (file);
14964 return process_msp430x_specific (file);
14972 get_file_header (FILE * file)
14974 /* Read in the identity array. */
14975 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14978 /* Determine how to read the rest of the header. */
14979 switch (elf_header.e_ident[EI_DATA])
14981 default: /* fall through */
14982 case ELFDATANONE: /* fall through */
14984 byte_get = byte_get_little_endian;
14985 byte_put = byte_put_little_endian;
14988 byte_get = byte_get_big_endian;
14989 byte_put = byte_put_big_endian;
14993 /* For now we only support 32 bit and 64 bit ELF files. */
14994 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14996 /* Read in the rest of the header. */
14999 Elf32_External_Ehdr ehdr32;
15001 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15004 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15005 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15006 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15007 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15008 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15009 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15010 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15011 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15012 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15013 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15014 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15015 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15016 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15020 Elf64_External_Ehdr ehdr64;
15022 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15023 we will not be able to cope with the 64bit data found in
15024 64 ELF files. Detect this now and abort before we start
15025 overwriting things. */
15026 if (sizeof (bfd_vma) < 8)
15028 error (_("This instance of readelf has been built without support for a\n\
15029 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15033 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15036 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15037 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15038 elf_header.e_version = BYTE_GET (ehdr64.e_version);
15039 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15040 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15041 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
15042 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15043 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15044 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15045 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15046 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15047 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15048 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15051 if (elf_header.e_shoff)
15053 /* There may be some extensions in the first section header. Don't
15054 bomb if we can't read it. */
15056 get_32bit_section_headers (file, TRUE);
15058 get_64bit_section_headers (file, TRUE);
15064 /* Process one ELF object file according to the command line options.
15065 This file may actually be stored in an archive. The file is
15066 positioned at the start of the ELF object. */
15069 process_object (char * file_name, FILE * file)
15073 if (! get_file_header (file))
15075 error (_("%s: Failed to read file header\n"), file_name);
15079 /* Initialise per file variables. */
15080 for (i = ARRAY_SIZE (version_info); i--;)
15081 version_info[i] = 0;
15083 for (i = ARRAY_SIZE (dynamic_info); i--;)
15084 dynamic_info[i] = 0;
15085 dynamic_info_DT_GNU_HASH = 0;
15087 /* Process the file. */
15089 printf (_("\nFile: %s\n"), file_name);
15091 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15092 Note we do this even if cmdline_dump_sects is empty because we
15093 must make sure that the dump_sets array is zeroed out before each
15094 object file is processed. */
15095 if (num_dump_sects > num_cmdline_dump_sects)
15096 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15098 if (num_cmdline_dump_sects > 0)
15100 if (num_dump_sects == 0)
15101 /* A sneaky way of allocating the dump_sects array. */
15102 request_dump_bynumber (num_cmdline_dump_sects, 0);
15104 assert (num_dump_sects >= num_cmdline_dump_sects);
15105 memcpy (dump_sects, cmdline_dump_sects,
15106 num_cmdline_dump_sects * sizeof (* dump_sects));
15109 if (! process_file_header ())
15112 if (! process_section_headers (file))
15114 /* Without loaded section headers we cannot process lots of
15116 do_unwind = do_version = do_dump = do_arch = 0;
15118 if (! do_using_dynamic)
15119 do_syms = do_dyn_syms = do_reloc = 0;
15122 if (! process_section_groups (file))
15124 /* Without loaded section groups we cannot process unwind. */
15128 if (process_program_headers (file))
15129 process_dynamic_section (file);
15131 process_relocs (file);
15133 process_unwind (file);
15135 process_symbol_table (file);
15137 process_syminfo (file);
15139 process_version_sections (file);
15141 process_section_contents (file);
15143 process_notes (file);
15145 process_gnu_liblist (file);
15147 process_arch_specific (file);
15149 if (program_headers)
15151 free (program_headers);
15152 program_headers = NULL;
15155 if (section_headers)
15157 free (section_headers);
15158 section_headers = NULL;
15163 free (string_table);
15164 string_table = NULL;
15165 string_table_length = 0;
15168 if (dynamic_strings)
15170 free (dynamic_strings);
15171 dynamic_strings = NULL;
15172 dynamic_strings_length = 0;
15175 if (dynamic_symbols)
15177 free (dynamic_symbols);
15178 dynamic_symbols = NULL;
15179 num_dynamic_syms = 0;
15182 if (dynamic_syminfo)
15184 free (dynamic_syminfo);
15185 dynamic_syminfo = NULL;
15188 if (dynamic_section)
15190 free (dynamic_section);
15191 dynamic_section = NULL;
15194 if (section_headers_groups)
15196 free (section_headers_groups);
15197 section_headers_groups = NULL;
15200 if (section_groups)
15202 struct group_list * g;
15203 struct group_list * next;
15205 for (i = 0; i < group_count; i++)
15207 for (g = section_groups [i].root; g != NULL; g = next)
15214 free (section_groups);
15215 section_groups = NULL;
15218 free_debug_memory ();
15223 /* Process an ELF archive.
15224 On entry the file is positioned just after the ARMAG string. */
15227 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15229 struct archive_info arch;
15230 struct archive_info nested_arch;
15236 /* The ARCH structure is used to hold information about this archive. */
15237 arch.file_name = NULL;
15239 arch.index_array = NULL;
15240 arch.sym_table = NULL;
15241 arch.longnames = NULL;
15243 /* The NESTED_ARCH structure is used as a single-item cache of information
15244 about a nested archive (when members of a thin archive reside within
15245 another regular archive file). */
15246 nested_arch.file_name = NULL;
15247 nested_arch.file = NULL;
15248 nested_arch.index_array = NULL;
15249 nested_arch.sym_table = NULL;
15250 nested_arch.longnames = NULL;
15252 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15258 if (do_archive_index)
15260 if (arch.sym_table == NULL)
15261 error (_("%s: unable to dump the index as none was found\n"), file_name);
15264 unsigned long i, l;
15265 unsigned long current_pos;
15267 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15268 file_name, (unsigned long) arch.index_num, arch.sym_size);
15269 current_pos = ftell (file);
15271 for (i = l = 0; i < arch.index_num; i++)
15273 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15275 char * member_name;
15277 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15279 if (member_name != NULL)
15281 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15283 if (qualified_name != NULL)
15285 printf (_("Contents of binary %s at offset "), qualified_name);
15286 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15288 free (qualified_name);
15293 if (l >= arch.sym_size)
15295 error (_("%s: end of the symbol table reached before the end of the index\n"),
15299 /* PR 17531: file: 0b6630b2. */
15300 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15301 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15304 if (arch.uses_64bit_indicies)
15309 if (l < arch.sym_size)
15310 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15311 file_name, arch.sym_size - l);
15313 if (fseek (file, current_pos, SEEK_SET) != 0)
15315 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15321 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15322 && !do_segments && !do_header && !do_dump && !do_version
15323 && !do_histogram && !do_debugging && !do_arch && !do_notes
15324 && !do_section_groups && !do_dyn_syms)
15326 ret = 0; /* Archive index only. */
15337 char * qualified_name;
15339 /* Read the next archive header. */
15340 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15342 error (_("%s: failed to seek to next archive header\n"), file_name);
15345 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15346 if (got != sizeof arch.arhdr)
15350 error (_("%s: failed to read archive header\n"), file_name);
15354 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15356 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15361 arch.next_arhdr_offset += sizeof arch.arhdr;
15363 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15364 if (archive_file_size & 01)
15365 ++archive_file_size;
15367 name = get_archive_member_name (&arch, &nested_arch);
15370 error (_("%s: bad archive file name\n"), file_name);
15374 namelen = strlen (name);
15376 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15377 if (qualified_name == NULL)
15379 error (_("%s: bad archive file name\n"), file_name);
15384 if (is_thin_archive && arch.nested_member_origin == 0)
15386 /* This is a proxy for an external member of a thin archive. */
15387 FILE * member_file;
15388 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15389 if (member_file_name == NULL)
15395 member_file = fopen (member_file_name, "rb");
15396 if (member_file == NULL)
15398 error (_("Input file '%s' is not readable.\n"), member_file_name);
15399 free (member_file_name);
15404 archive_file_offset = arch.nested_member_origin;
15406 ret |= process_object (qualified_name, member_file);
15408 fclose (member_file);
15409 free (member_file_name);
15411 else if (is_thin_archive)
15413 /* PR 15140: Allow for corrupt thin archives. */
15414 if (nested_arch.file == NULL)
15416 error (_("%s: contains corrupt thin archive: %s\n"),
15422 /* This is a proxy for a member of a nested archive. */
15423 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15425 /* The nested archive file will have been opened and setup by
15426 get_archive_member_name. */
15427 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15429 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15434 ret |= process_object (qualified_name, nested_arch.file);
15438 archive_file_offset = arch.next_arhdr_offset;
15439 arch.next_arhdr_offset += archive_file_size;
15441 ret |= process_object (qualified_name, file);
15444 if (dump_sects != NULL)
15448 num_dump_sects = 0;
15451 free (qualified_name);
15455 if (nested_arch.file != NULL)
15456 fclose (nested_arch.file);
15457 release_archive (&nested_arch);
15458 release_archive (&arch);
15464 process_file (char * file_name)
15467 struct stat statbuf;
15468 char armag[SARMAG];
15471 if (stat (file_name, &statbuf) < 0)
15473 if (errno == ENOENT)
15474 error (_("'%s': No such file\n"), file_name);
15476 error (_("Could not locate '%s'. System error message: %s\n"),
15477 file_name, strerror (errno));
15481 if (! S_ISREG (statbuf.st_mode))
15483 error (_("'%s' is not an ordinary file\n"), file_name);
15487 file = fopen (file_name, "rb");
15490 error (_("Input file '%s' is not readable.\n"), file_name);
15494 if (fread (armag, SARMAG, 1, file) != 1)
15496 error (_("%s: Failed to read file's magic number\n"), file_name);
15501 current_file_size = (bfd_size_type) statbuf.st_size;
15503 if (memcmp (armag, ARMAG, SARMAG) == 0)
15504 ret = process_archive (file_name, file, FALSE);
15505 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15506 ret = process_archive (file_name, file, TRUE);
15509 if (do_archive_index)
15510 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15514 archive_file_size = archive_file_offset = 0;
15515 ret = process_object (file_name, file);
15520 current_file_size = 0;
15524 #ifdef SUPPORT_DISASSEMBLY
15525 /* Needed by the i386 disassembler. For extra credit, someone could
15526 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15530 print_address (unsigned int addr, FILE * outfile)
15532 fprintf (outfile,"0x%8.8x", addr);
15535 /* Needed by the i386 disassembler. */
15537 db_task_printsym (unsigned int addr)
15539 print_address (addr, stderr);
15544 main (int argc, char ** argv)
15548 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15549 setlocale (LC_MESSAGES, "");
15551 #if defined (HAVE_SETLOCALE)
15552 setlocale (LC_CTYPE, "");
15554 bindtextdomain (PACKAGE, LOCALEDIR);
15555 textdomain (PACKAGE);
15557 expandargv (&argc, &argv);
15559 parse_args (argc, argv);
15561 if (num_dump_sects > 0)
15563 /* Make a copy of the dump_sects array. */
15564 cmdline_dump_sects = (dump_type *)
15565 malloc (num_dump_sects * sizeof (* dump_sects));
15566 if (cmdline_dump_sects == NULL)
15567 error (_("Out of memory allocating dump request table.\n"));
15570 memcpy (cmdline_dump_sects, dump_sects,
15571 num_dump_sects * sizeof (* dump_sects));
15572 num_cmdline_dump_sects = num_dump_sects;
15576 if (optind < (argc - 1))
15580 while (optind < argc)
15581 err |= process_file (argv[optind++]);
15583 if (dump_sects != NULL)
15585 if (cmdline_dump_sects != NULL)
15586 free (cmdline_dump_sects);