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 section->sh_size, printable_section_name (section), section->sh_entsize);
4794 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4795 section->sh_size, _("symbols"));
4800 if (symtab_shndx_hdr != NULL
4801 && (symtab_shndx_hdr->sh_link
4802 == (unsigned long) (section - section_headers)))
4804 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4805 symtab_shndx_hdr->sh_offset,
4806 1, symtab_shndx_hdr->sh_size,
4807 _("symbol table section indicies"));
4810 /* PR17531: file: heap-buffer-overflow */
4811 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4813 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4814 printable_section_name (symtab_shndx_hdr),
4815 (unsigned long) symtab_shndx_hdr->sh_size,
4816 (unsigned long) section->sh_size);
4821 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4825 error (_("Out of memory reading %lu symbols\n"),
4826 (unsigned long) number);
4830 for (j = 0, psym = isyms; j < number; j++, psym++)
4832 psym->st_name = BYTE_GET (esyms[j].st_name);
4833 psym->st_value = BYTE_GET (esyms[j].st_value);
4834 psym->st_size = BYTE_GET (esyms[j].st_size);
4835 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4836 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4838 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4839 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4840 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4841 psym->st_info = BYTE_GET (esyms[j].st_info);
4842 psym->st_other = BYTE_GET (esyms[j].st_other);
4851 if (num_syms_return != NULL)
4852 * num_syms_return = isyms == NULL ? 0 : number;
4857 static Elf_Internal_Sym *
4858 get_64bit_elf_symbols (FILE * file,
4859 Elf_Internal_Shdr * section,
4860 unsigned long * num_syms_return)
4862 unsigned long number = 0;
4863 Elf64_External_Sym * esyms = NULL;
4864 Elf_External_Sym_Shndx * shndx = NULL;
4865 Elf_Internal_Sym * isyms = NULL;
4866 Elf_Internal_Sym * psym;
4869 if (section->sh_size == 0)
4871 if (num_syms_return != NULL)
4872 * num_syms_return = 0;
4876 /* Run some sanity checks first. */
4877 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4879 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4880 printable_section_name (section), (unsigned long) section->sh_entsize);
4884 if (section->sh_size > current_file_size)
4886 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4887 printable_section_name (section), (unsigned long) section->sh_size);
4891 number = section->sh_size / section->sh_entsize;
4893 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4895 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4896 section->sh_size, printable_section_name (section), section->sh_entsize);
4900 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4901 section->sh_size, _("symbols"));
4905 if (symtab_shndx_hdr != NULL
4906 && (symtab_shndx_hdr->sh_link
4907 == (unsigned long) (section - section_headers)))
4909 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4910 symtab_shndx_hdr->sh_offset,
4911 1, symtab_shndx_hdr->sh_size,
4912 _("symbol table section indicies"));
4915 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4917 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4918 printable_section_name (symtab_shndx_hdr),
4919 (unsigned long) symtab_shndx_hdr->sh_size,
4920 (unsigned long) section->sh_size);
4925 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4929 error (_("Out of memory reading %lu symbols\n"),
4930 (unsigned long) number);
4934 for (j = 0, psym = isyms; j < number; j++, psym++)
4936 psym->st_name = BYTE_GET (esyms[j].st_name);
4937 psym->st_info = BYTE_GET (esyms[j].st_info);
4938 psym->st_other = BYTE_GET (esyms[j].st_other);
4939 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4941 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4943 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4944 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4945 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4947 psym->st_value = BYTE_GET (esyms[j].st_value);
4948 psym->st_size = BYTE_GET (esyms[j].st_size);
4957 if (num_syms_return != NULL)
4958 * num_syms_return = isyms == NULL ? 0 : number;
4964 get_elf_section_flags (bfd_vma sh_flags)
4966 static char buff[1024];
4968 int field_size = is_32bit_elf ? 8 : 16;
4970 int size = sizeof (buff) - (field_size + 4 + 1);
4971 bfd_vma os_flags = 0;
4972 bfd_vma proc_flags = 0;
4973 bfd_vma unknown_flags = 0;
4981 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4982 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4983 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4984 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4985 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4986 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4987 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4988 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4989 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4990 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4991 /* IA-64 specific. */
4992 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4993 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4994 /* IA-64 OpenVMS specific. */
4995 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4996 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4997 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4998 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4999 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5000 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5002 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5003 /* SPARC specific. */
5004 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5007 if (do_section_details)
5009 sprintf (buff, "[%*.*lx]: ",
5010 field_size, field_size, (unsigned long) sh_flags);
5011 p += field_size + 4;
5018 flag = sh_flags & - sh_flags;
5021 if (do_section_details)
5025 case SHF_WRITE: sindex = 0; break;
5026 case SHF_ALLOC: sindex = 1; break;
5027 case SHF_EXECINSTR: sindex = 2; break;
5028 case SHF_MERGE: sindex = 3; break;
5029 case SHF_STRINGS: sindex = 4; break;
5030 case SHF_INFO_LINK: sindex = 5; break;
5031 case SHF_LINK_ORDER: sindex = 6; break;
5032 case SHF_OS_NONCONFORMING: sindex = 7; break;
5033 case SHF_GROUP: sindex = 8; break;
5034 case SHF_TLS: sindex = 9; break;
5035 case SHF_EXCLUDE: sindex = 18; break;
5039 switch (elf_header.e_machine)
5042 if (flag == SHF_IA_64_SHORT)
5044 else if (flag == SHF_IA_64_NORECOV)
5047 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5050 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5051 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5052 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5053 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5054 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5055 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5066 case EM_OLD_SPARCV9:
5067 case EM_SPARC32PLUS:
5070 if (flag == SHF_ORDERED)
5080 if (p != buff + field_size + 4)
5082 if (size < (10 + 2))
5089 size -= flags [sindex].len;
5090 p = stpcpy (p, flags [sindex].str);
5092 else if (flag & SHF_MASKOS)
5094 else if (flag & SHF_MASKPROC)
5097 unknown_flags |= flag;
5103 case SHF_WRITE: *p = 'W'; break;
5104 case SHF_ALLOC: *p = 'A'; break;
5105 case SHF_EXECINSTR: *p = 'X'; break;
5106 case SHF_MERGE: *p = 'M'; break;
5107 case SHF_STRINGS: *p = 'S'; break;
5108 case SHF_INFO_LINK: *p = 'I'; break;
5109 case SHF_LINK_ORDER: *p = 'L'; break;
5110 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5111 case SHF_GROUP: *p = 'G'; break;
5112 case SHF_TLS: *p = 'T'; break;
5113 case SHF_EXCLUDE: *p = 'E'; break;
5116 if ((elf_header.e_machine == EM_X86_64
5117 || elf_header.e_machine == EM_L1OM
5118 || elf_header.e_machine == EM_K1OM)
5119 && flag == SHF_X86_64_LARGE)
5121 else if (flag & SHF_MASKOS)
5124 sh_flags &= ~ SHF_MASKOS;
5126 else if (flag & SHF_MASKPROC)
5129 sh_flags &= ~ SHF_MASKPROC;
5139 if (do_section_details)
5143 size -= 5 + field_size;
5144 if (p != buff + field_size + 4)
5152 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5153 (unsigned long) os_flags);
5154 p += 5 + field_size;
5158 size -= 7 + field_size;
5159 if (p != buff + field_size + 4)
5167 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5168 (unsigned long) proc_flags);
5169 p += 7 + field_size;
5173 size -= 10 + field_size;
5174 if (p != buff + field_size + 4)
5182 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5183 (unsigned long) unknown_flags);
5184 p += 10 + field_size;
5193 process_section_headers (FILE * file)
5195 Elf_Internal_Shdr * section;
5198 section_headers = NULL;
5200 if (elf_header.e_shnum == 0)
5202 /* PR binutils/12467. */
5203 if (elf_header.e_shoff != 0)
5204 warn (_("possibly corrupt ELF file header - it has a non-zero"
5205 " section header offset, but no section headers\n"));
5206 else if (do_sections)
5207 printf (_("\nThere are no sections in this file.\n"));
5212 if (do_sections && !do_header)
5213 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5214 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5218 if (! get_32bit_section_headers (file, FALSE))
5221 else if (! get_64bit_section_headers (file, FALSE))
5224 /* Read in the string table, so that we have names to display. */
5225 if (elf_header.e_shstrndx != SHN_UNDEF
5226 && elf_header.e_shstrndx < elf_header.e_shnum)
5228 section = section_headers + elf_header.e_shstrndx;
5230 if (section->sh_size != 0)
5232 string_table = (char *) get_data (NULL, file, section->sh_offset,
5233 1, section->sh_size,
5236 string_table_length = string_table != NULL ? section->sh_size : 0;
5240 /* Scan the sections for the dynamic symbol table
5241 and dynamic string table and debug sections. */
5242 dynamic_symbols = NULL;
5243 dynamic_strings = NULL;
5244 dynamic_syminfo = NULL;
5245 symtab_shndx_hdr = NULL;
5247 eh_addr_size = is_32bit_elf ? 4 : 8;
5248 switch (elf_header.e_machine)
5251 case EM_MIPS_RS3_LE:
5252 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5253 FDE addresses. However, the ABI also has a semi-official ILP32
5254 variant for which the normal FDE address size rules apply.
5256 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5257 section, where XX is the size of longs in bits. Unfortunately,
5258 earlier compilers provided no way of distinguishing ILP32 objects
5259 from LP64 objects, so if there's any doubt, we should assume that
5260 the official LP64 form is being used. */
5261 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5262 && find_section (".gcc_compiled_long32") == NULL)
5268 switch (elf_header.e_flags & EF_H8_MACH)
5270 case E_H8_MACH_H8300:
5271 case E_H8_MACH_H8300HN:
5272 case E_H8_MACH_H8300SN:
5273 case E_H8_MACH_H8300SXN:
5276 case E_H8_MACH_H8300H:
5277 case E_H8_MACH_H8300S:
5278 case E_H8_MACH_H8300SX:
5286 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5288 case EF_M32C_CPU_M16C:
5295 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5298 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5299 if (section->sh_entsize != expected_entsize) \
5302 sprintf_vma (buf, section->sh_entsize); \
5303 /* Note: coded this way so that there is a single string for \
5305 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5306 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5307 (unsigned) expected_entsize); \
5308 section->sh_entsize = expected_entsize; \
5313 #define CHECK_ENTSIZE(section, i, type) \
5314 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5315 sizeof (Elf64_External_##type))
5317 for (i = 0, section = section_headers;
5318 i < elf_header.e_shnum;
5321 char * name = SECTION_NAME (section);
5323 if (section->sh_type == SHT_DYNSYM)
5325 if (dynamic_symbols != NULL)
5327 error (_("File contains multiple dynamic symbol tables\n"));
5331 CHECK_ENTSIZE (section, i, Sym);
5332 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5334 else if (section->sh_type == SHT_STRTAB
5335 && streq (name, ".dynstr"))
5337 if (dynamic_strings != NULL)
5339 error (_("File contains multiple dynamic string tables\n"));
5343 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5344 1, section->sh_size,
5345 _("dynamic strings"));
5346 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5348 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5350 if (symtab_shndx_hdr != NULL)
5352 error (_("File contains multiple symtab shndx tables\n"));
5355 symtab_shndx_hdr = section;
5357 else if (section->sh_type == SHT_SYMTAB)
5358 CHECK_ENTSIZE (section, i, Sym);
5359 else if (section->sh_type == SHT_GROUP)
5360 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5361 else if (section->sh_type == SHT_REL)
5362 CHECK_ENTSIZE (section, i, Rel);
5363 else if (section->sh_type == SHT_RELA)
5364 CHECK_ENTSIZE (section, i, Rela);
5365 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5366 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5367 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5368 || do_debug_str || do_debug_loc || do_debug_ranges
5369 || do_debug_addr || do_debug_cu_index)
5370 && (const_strneq (name, ".debug_")
5371 || const_strneq (name, ".zdebug_")))
5374 name += sizeof (".zdebug_") - 1;
5376 name += sizeof (".debug_") - 1;
5379 || (do_debug_info && const_strneq (name, "info"))
5380 || (do_debug_info && const_strneq (name, "types"))
5381 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5382 || (do_debug_lines && strcmp (name, "line") == 0)
5383 || (do_debug_lines && const_strneq (name, "line."))
5384 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5385 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5386 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5387 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5388 || (do_debug_aranges && const_strneq (name, "aranges"))
5389 || (do_debug_ranges && const_strneq (name, "ranges"))
5390 || (do_debug_frames && const_strneq (name, "frame"))
5391 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5392 || (do_debug_macinfo && const_strneq (name, "macro"))
5393 || (do_debug_str && const_strneq (name, "str"))
5394 || (do_debug_loc && const_strneq (name, "loc"))
5395 || (do_debug_addr && const_strneq (name, "addr"))
5396 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5397 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5399 request_dump_bynumber (i, DEBUG_DUMP);
5401 /* Linkonce section to be combined with .debug_info at link time. */
5402 else if ((do_debugging || do_debug_info)
5403 && const_strneq (name, ".gnu.linkonce.wi."))
5404 request_dump_bynumber (i, DEBUG_DUMP);
5405 else if (do_debug_frames && streq (name, ".eh_frame"))
5406 request_dump_bynumber (i, DEBUG_DUMP);
5407 else if (do_gdb_index && streq (name, ".gdb_index"))
5408 request_dump_bynumber (i, DEBUG_DUMP);
5409 /* Trace sections for Itanium VMS. */
5410 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5411 || do_trace_aranges)
5412 && const_strneq (name, ".trace_"))
5414 name += sizeof (".trace_") - 1;
5417 || (do_trace_info && streq (name, "info"))
5418 || (do_trace_abbrevs && streq (name, "abbrev"))
5419 || (do_trace_aranges && streq (name, "aranges"))
5421 request_dump_bynumber (i, DEBUG_DUMP);
5428 if (elf_header.e_shnum > 1)
5429 printf (_("\nSection Headers:\n"));
5431 printf (_("\nSection Header:\n"));
5435 if (do_section_details)
5437 printf (_(" [Nr] Name\n"));
5438 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5442 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5446 if (do_section_details)
5448 printf (_(" [Nr] Name\n"));
5449 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5453 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5457 if (do_section_details)
5459 printf (_(" [Nr] Name\n"));
5460 printf (_(" Type Address Offset Link\n"));
5461 printf (_(" Size EntSize Info Align\n"));
5465 printf (_(" [Nr] Name Type Address Offset\n"));
5466 printf (_(" Size EntSize Flags Link Info Align\n"));
5470 if (do_section_details)
5471 printf (_(" Flags\n"));
5473 for (i = 0, section = section_headers;
5474 i < elf_header.e_shnum;
5477 printf (" [%2u] ", i);
5478 if (do_section_details)
5479 printf ("%s\n ", printable_section_name (section));
5481 print_symbol (-17, SECTION_NAME (section));
5483 printf (do_wide ? " %-15s " : " %-15.15s ",
5484 get_section_type_name (section->sh_type));
5488 const char * link_too_big = NULL;
5490 print_vma (section->sh_addr, LONG_HEX);
5492 printf ( " %6.6lx %6.6lx %2.2lx",
5493 (unsigned long) section->sh_offset,
5494 (unsigned long) section->sh_size,
5495 (unsigned long) section->sh_entsize);
5497 if (do_section_details)
5498 fputs (" ", stdout);
5500 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5502 if (section->sh_link >= elf_header.e_shnum)
5505 /* The sh_link value is out of range. Normally this indicates
5506 an error but it can have special values in Solaris binaries. */
5507 switch (elf_header.e_machine)
5514 case EM_OLD_SPARCV9:
5515 case EM_SPARC32PLUS:
5518 if (section->sh_link == (SHN_BEFORE & 0xffff))
5519 link_too_big = "BEFORE";
5520 else if (section->sh_link == (SHN_AFTER & 0xffff))
5521 link_too_big = "AFTER";
5528 if (do_section_details)
5530 if (link_too_big != NULL && * link_too_big)
5531 printf ("<%s> ", link_too_big);
5533 printf ("%2u ", section->sh_link);
5534 printf ("%3u %2lu\n", section->sh_info,
5535 (unsigned long) section->sh_addralign);
5538 printf ("%2u %3u %2lu\n",
5541 (unsigned long) section->sh_addralign);
5543 if (link_too_big && ! * link_too_big)
5544 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5545 i, section->sh_link);
5549 print_vma (section->sh_addr, LONG_HEX);
5551 if ((long) section->sh_offset == section->sh_offset)
5552 printf (" %6.6lx", (unsigned long) section->sh_offset);
5556 print_vma (section->sh_offset, LONG_HEX);
5559 if ((unsigned long) section->sh_size == section->sh_size)
5560 printf (" %6.6lx", (unsigned long) section->sh_size);
5564 print_vma (section->sh_size, LONG_HEX);
5567 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5568 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5572 print_vma (section->sh_entsize, LONG_HEX);
5575 if (do_section_details)
5576 fputs (" ", stdout);
5578 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5580 printf ("%2u %3u ", section->sh_link, section->sh_info);
5582 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5583 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5586 print_vma (section->sh_addralign, DEC);
5590 else if (do_section_details)
5592 printf (" %-15.15s ",
5593 get_section_type_name (section->sh_type));
5594 print_vma (section->sh_addr, LONG_HEX);
5595 if ((long) section->sh_offset == section->sh_offset)
5596 printf (" %16.16lx", (unsigned long) section->sh_offset);
5600 print_vma (section->sh_offset, LONG_HEX);
5602 printf (" %u\n ", section->sh_link);
5603 print_vma (section->sh_size, LONG_HEX);
5605 print_vma (section->sh_entsize, LONG_HEX);
5607 printf (" %-16u %lu\n",
5609 (unsigned long) section->sh_addralign);
5614 print_vma (section->sh_addr, LONG_HEX);
5615 if ((long) section->sh_offset == section->sh_offset)
5616 printf (" %8.8lx", (unsigned long) section->sh_offset);
5620 print_vma (section->sh_offset, LONG_HEX);
5623 print_vma (section->sh_size, LONG_HEX);
5625 print_vma (section->sh_entsize, LONG_HEX);
5627 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5629 printf (" %2u %3u %lu\n",
5632 (unsigned long) section->sh_addralign);
5635 if (do_section_details)
5636 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5639 if (!do_section_details)
5641 if (elf_header.e_machine == EM_X86_64
5642 || elf_header.e_machine == EM_L1OM
5643 || elf_header.e_machine == EM_K1OM)
5644 printf (_("Key to Flags:\n\
5645 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5646 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5647 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5649 printf (_("Key to Flags:\n\
5650 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5651 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5652 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5659 get_group_flags (unsigned int flags)
5661 static char buff[32];
5671 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5678 process_section_groups (FILE * file)
5680 Elf_Internal_Shdr * section;
5682 struct group * group;
5683 Elf_Internal_Shdr * symtab_sec;
5684 Elf_Internal_Shdr * strtab_sec;
5685 Elf_Internal_Sym * symtab;
5686 unsigned long num_syms;
5690 /* Don't process section groups unless needed. */
5691 if (!do_unwind && !do_section_groups)
5694 if (elf_header.e_shnum == 0)
5696 if (do_section_groups)
5697 printf (_("\nThere are no sections to group in this file.\n"));
5702 if (section_headers == NULL)
5704 error (_("Section headers are not available!\n"));
5705 /* PR 13622: This can happen with a corrupt ELF header. */
5709 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5710 sizeof (struct group *));
5712 if (section_headers_groups == NULL)
5714 error (_("Out of memory reading %u section group headers\n"),
5715 elf_header.e_shnum);
5719 /* Scan the sections for the group section. */
5721 for (i = 0, section = section_headers;
5722 i < elf_header.e_shnum;
5724 if (section->sh_type == SHT_GROUP)
5727 if (group_count == 0)
5729 if (do_section_groups)
5730 printf (_("\nThere are no section groups in this file.\n"));
5735 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5737 if (section_groups == NULL)
5739 error (_("Out of memory reading %lu groups\n"),
5740 (unsigned long) group_count);
5750 for (i = 0, section = section_headers, group = section_groups;
5751 i < elf_header.e_shnum;
5754 if (section->sh_type == SHT_GROUP)
5756 const char * name = printable_section_name (section);
5757 const char * group_name;
5758 unsigned char * start;
5759 unsigned char * indices;
5760 unsigned int entry, j, size;
5761 Elf_Internal_Shdr * sec;
5762 Elf_Internal_Sym * sym;
5764 /* Get the symbol table. */
5765 if (section->sh_link >= elf_header.e_shnum
5766 || ((sec = section_headers + section->sh_link)->sh_type
5769 error (_("Bad sh_link in group section `%s'\n"), name);
5773 if (symtab_sec != sec)
5778 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5783 error (_("Corrupt header in group section `%s'\n"), name);
5787 if (section->sh_info >= num_syms)
5789 error (_("Bad sh_info in group section `%s'\n"), name);
5793 sym = symtab + section->sh_info;
5795 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5797 if (sym->st_shndx == 0
5798 || sym->st_shndx >= elf_header.e_shnum)
5800 error (_("Bad sh_info in group section `%s'\n"), name);
5804 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5813 /* Get the string table. */
5814 if (symtab_sec->sh_link >= elf_header.e_shnum)
5823 != (sec = section_headers + symtab_sec->sh_link))
5829 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5830 1, strtab_sec->sh_size,
5832 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5834 group_name = sym->st_name < strtab_size
5835 ? strtab + sym->st_name : _("<corrupt>");
5838 /* PR 17531: file: loop. */
5839 if (section->sh_entsize > section->sh_size)
5841 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5842 printable_section_name (section),
5843 section->sh_entsize, section->sh_size);
5847 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5848 1, section->sh_size,
5854 size = (section->sh_size / section->sh_entsize) - 1;
5855 entry = byte_get (indices, 4);
5858 if (do_section_groups)
5860 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5861 get_group_flags (entry), i, name, group_name, size);
5863 printf (_(" [Index] Name\n"));
5866 group->group_index = i;
5868 for (j = 0; j < size; j++)
5870 struct group_list * g;
5872 entry = byte_get (indices, 4);
5875 if (entry >= elf_header.e_shnum)
5877 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5878 entry, i, elf_header.e_shnum - 1);
5882 if (section_headers_groups [entry] != NULL)
5886 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5888 section_headers_groups [entry]->group_index);
5893 /* Intel C/C++ compiler may put section 0 in a
5894 section group. We just warn it the first time
5895 and ignore it afterwards. */
5896 static int warned = 0;
5899 error (_("section 0 in group section [%5u]\n"),
5900 section_headers_groups [entry]->group_index);
5906 section_headers_groups [entry] = group;
5908 if (do_section_groups)
5910 sec = section_headers + entry;
5911 printf (" [%5u] %s\n", entry, printable_section_name (sec));
5914 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5915 g->section_index = entry;
5916 g->next = group->root;
5934 /* Data used to display dynamic fixups. */
5936 struct ia64_vms_dynfixup
5938 bfd_vma needed_ident; /* Library ident number. */
5939 bfd_vma needed; /* Index in the dstrtab of the library name. */
5940 bfd_vma fixup_needed; /* Index of the library. */
5941 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5942 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5945 /* Data used to display dynamic relocations. */
5947 struct ia64_vms_dynimgrela
5949 bfd_vma img_rela_cnt; /* Number of relocations. */
5950 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5953 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5957 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5958 const char *strtab, unsigned int strtab_sz)
5960 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5962 const char *lib_name;
5964 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5965 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5966 _("dynamic section image fixups"));
5970 if (fixup->needed < strtab_sz)
5971 lib_name = strtab + fixup->needed;
5974 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5975 (unsigned long) fixup->needed);
5978 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5979 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5981 (_("Seg Offset Type SymVec DataType\n"));
5983 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5988 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5989 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5990 type = BYTE_GET (imfs [i].type);
5991 rtype = elf_ia64_reloc_type (type);
5993 printf (" 0x%08x ", type);
5995 printf (" %-32s ", rtype);
5996 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5997 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6003 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6006 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6008 Elf64_External_VMS_IMAGE_RELA *imrs;
6011 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6012 1, imgrela->img_rela_cnt * sizeof (*imrs),
6013 _("dynamic section image relocations"));
6017 printf (_("\nImage relocs\n"));
6019 (_("Seg Offset Type Addend Seg Sym Off\n"));
6021 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6026 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6027 printf ("%08" BFD_VMA_FMT "x ",
6028 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6029 type = BYTE_GET (imrs [i].type);
6030 rtype = elf_ia64_reloc_type (type);
6032 printf ("0x%08x ", type);
6034 printf ("%-31s ", rtype);
6035 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6036 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6037 printf ("%08" BFD_VMA_FMT "x\n",
6038 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6044 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6047 process_ia64_vms_dynamic_relocs (FILE *file)
6049 struct ia64_vms_dynfixup fixup;
6050 struct ia64_vms_dynimgrela imgrela;
6051 Elf_Internal_Dyn *entry;
6053 bfd_vma strtab_off = 0;
6054 bfd_vma strtab_sz = 0;
6055 char *strtab = NULL;
6057 memset (&fixup, 0, sizeof (fixup));
6058 memset (&imgrela, 0, sizeof (imgrela));
6060 /* Note: the order of the entries is specified by the OpenVMS specs. */
6061 for (entry = dynamic_section;
6062 entry < dynamic_section + dynamic_nent;
6065 switch (entry->d_tag)
6067 case DT_IA_64_VMS_STRTAB_OFFSET:
6068 strtab_off = entry->d_un.d_val;
6071 strtab_sz = entry->d_un.d_val;
6073 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6074 1, strtab_sz, _("dynamic string section"));
6077 case DT_IA_64_VMS_NEEDED_IDENT:
6078 fixup.needed_ident = entry->d_un.d_val;
6081 fixup.needed = entry->d_un.d_val;
6083 case DT_IA_64_VMS_FIXUP_NEEDED:
6084 fixup.fixup_needed = entry->d_un.d_val;
6086 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6087 fixup.fixup_rela_cnt = entry->d_un.d_val;
6089 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6090 fixup.fixup_rela_off = entry->d_un.d_val;
6092 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6095 case DT_IA_64_VMS_IMG_RELA_CNT:
6096 imgrela.img_rela_cnt = entry->d_un.d_val;
6098 case DT_IA_64_VMS_IMG_RELA_OFF:
6099 imgrela.img_rela_off = entry->d_un.d_val;
6101 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6121 } dynamic_relocations [] =
6123 { "REL", DT_REL, DT_RELSZ, FALSE },
6124 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6125 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6128 /* Process the reloc section. */
6131 process_relocs (FILE * file)
6133 unsigned long rel_size;
6134 unsigned long rel_offset;
6140 if (do_using_dynamic)
6144 int has_dynamic_reloc;
6147 has_dynamic_reloc = 0;
6149 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6151 is_rela = dynamic_relocations [i].rela;
6152 name = dynamic_relocations [i].name;
6153 rel_size = dynamic_info [dynamic_relocations [i].size];
6154 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6156 has_dynamic_reloc |= rel_size;
6158 if (is_rela == UNKNOWN)
6160 if (dynamic_relocations [i].reloc == DT_JMPREL)
6161 switch (dynamic_info[DT_PLTREL])
6175 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6176 name, rel_offset, rel_size);
6178 dump_relocations (file,
6179 offset_from_vma (file, rel_offset, rel_size),
6181 dynamic_symbols, num_dynamic_syms,
6182 dynamic_strings, dynamic_strings_length,
6188 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6190 if (! has_dynamic_reloc)
6191 printf (_("\nThere are no dynamic relocations in this file.\n"));
6195 Elf_Internal_Shdr * section;
6199 for (i = 0, section = section_headers;
6200 i < elf_header.e_shnum;
6203 if ( section->sh_type != SHT_RELA
6204 && section->sh_type != SHT_REL)
6207 rel_offset = section->sh_offset;
6208 rel_size = section->sh_size;
6212 Elf_Internal_Shdr * strsec;
6215 printf (_("\nRelocation section "));
6217 if (string_table == NULL)
6218 printf ("%d", section->sh_name);
6220 printf ("'%s'", printable_section_name (section));
6222 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6223 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6225 is_rela = section->sh_type == SHT_RELA;
6227 if (section->sh_link != 0
6228 && section->sh_link < elf_header.e_shnum)
6230 Elf_Internal_Shdr * symsec;
6231 Elf_Internal_Sym * symtab;
6232 unsigned long nsyms;
6233 unsigned long strtablen = 0;
6234 char * strtab = NULL;
6236 symsec = section_headers + section->sh_link;
6237 if (symsec->sh_type != SHT_SYMTAB
6238 && symsec->sh_type != SHT_DYNSYM)
6241 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6246 if (symsec->sh_link != 0
6247 && symsec->sh_link < elf_header.e_shnum)
6249 strsec = section_headers + symsec->sh_link;
6251 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6254 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6257 dump_relocations (file, rel_offset, rel_size,
6258 symtab, nsyms, strtab, strtablen,
6260 symsec->sh_type == SHT_DYNSYM);
6266 dump_relocations (file, rel_offset, rel_size,
6267 NULL, 0, NULL, 0, is_rela, 0);
6274 printf (_("\nThere are no relocations in this file.\n"));
6280 /* Process the unwind section. */
6282 #include "unwind-ia64.h"
6284 /* An absolute address consists of a section and an offset. If the
6285 section is NULL, the offset itself is the address, otherwise, the
6286 address equals to LOAD_ADDRESS(section) + offset. */
6290 unsigned short section;
6294 #define ABSADDR(a) \
6296 ? section_headers [(a).section].sh_addr + (a).offset \
6299 struct ia64_unw_table_entry
6301 struct absaddr start;
6303 struct absaddr info;
6306 struct ia64_unw_aux_info
6309 struct ia64_unw_table_entry *table; /* Unwind table. */
6310 unsigned long table_len; /* Length of unwind table. */
6311 unsigned char * info; /* Unwind info. */
6312 unsigned long info_size; /* Size of unwind info. */
6313 bfd_vma info_addr; /* starting address of unwind info. */
6314 bfd_vma seg_base; /* Starting address of segment. */
6315 Elf_Internal_Sym * symtab; /* The symbol table. */
6316 unsigned long nsyms; /* Number of symbols. */
6317 char * strtab; /* The string table. */
6318 unsigned long strtab_size; /* Size of string table. */
6322 find_symbol_for_address (Elf_Internal_Sym * symtab,
6323 unsigned long nsyms,
6324 const char * strtab,
6325 unsigned long strtab_size,
6326 struct absaddr addr,
6327 const char ** symname,
6330 bfd_vma dist = 0x100000;
6331 Elf_Internal_Sym * sym;
6332 Elf_Internal_Sym * best = NULL;
6335 REMOVE_ARCH_BITS (addr.offset);
6337 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6339 bfd_vma value = sym->st_value;
6341 REMOVE_ARCH_BITS (value);
6343 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6344 && sym->st_name != 0
6345 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6346 && addr.offset >= value
6347 && addr.offset - value < dist)
6350 dist = addr.offset - value;
6358 *symname = (best->st_name >= strtab_size
6359 ? _("<corrupt>") : strtab + best->st_name);
6365 *offset = addr.offset;
6369 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6371 struct ia64_unw_table_entry * tp;
6374 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6378 const unsigned char * dp;
6379 const unsigned char * head;
6380 const char * procname;
6382 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6383 aux->strtab_size, tp->start, &procname, &offset);
6385 fputs ("\n<", stdout);
6389 fputs (procname, stdout);
6392 printf ("+%lx", (unsigned long) offset);
6395 fputs (">: [", stdout);
6396 print_vma (tp->start.offset, PREFIX_HEX);
6397 fputc ('-', stdout);
6398 print_vma (tp->end.offset, PREFIX_HEX);
6399 printf ("], info at +0x%lx\n",
6400 (unsigned long) (tp->info.offset - aux->seg_base));
6402 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6403 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6405 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6406 (unsigned) UNW_VER (stamp),
6407 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6408 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6409 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6410 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6412 if (UNW_VER (stamp) != 1)
6414 printf (_("\tUnknown version.\n"));
6419 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6420 dp = unw_decode (dp, in_body, & in_body);
6425 slurp_ia64_unwind_table (FILE * file,
6426 struct ia64_unw_aux_info * aux,
6427 Elf_Internal_Shdr * sec)
6429 unsigned long size, nrelas, i;
6430 Elf_Internal_Phdr * seg;
6431 struct ia64_unw_table_entry * tep;
6432 Elf_Internal_Shdr * relsec;
6433 Elf_Internal_Rela * rela;
6434 Elf_Internal_Rela * rp;
6435 unsigned char * table;
6437 Elf_Internal_Sym * sym;
6438 const char * relname;
6440 /* First, find the starting address of the segment that includes
6443 if (elf_header.e_phnum)
6445 if (! get_program_headers (file))
6448 for (seg = program_headers;
6449 seg < program_headers + elf_header.e_phnum;
6452 if (seg->p_type != PT_LOAD)
6455 if (sec->sh_addr >= seg->p_vaddr
6456 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6458 aux->seg_base = seg->p_vaddr;
6464 /* Second, build the unwind table from the contents of the unwind section: */
6465 size = sec->sh_size;
6466 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6471 aux->table = (struct ia64_unw_table_entry *)
6472 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6474 for (tp = table; tp < table + size; ++tep)
6476 tep->start.section = SHN_UNDEF;
6477 tep->end.section = SHN_UNDEF;
6478 tep->info.section = SHN_UNDEF;
6479 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6480 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6481 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6482 tep->start.offset += aux->seg_base;
6483 tep->end.offset += aux->seg_base;
6484 tep->info.offset += aux->seg_base;
6488 /* Third, apply any relocations to the unwind table: */
6489 for (relsec = section_headers;
6490 relsec < section_headers + elf_header.e_shnum;
6493 if (relsec->sh_type != SHT_RELA
6494 || relsec->sh_info >= elf_header.e_shnum
6495 || section_headers + relsec->sh_info != sec)
6498 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6502 for (rp = rela; rp < rela + nrelas; ++rp)
6504 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6505 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6507 if (! const_strneq (relname, "R_IA64_SEGREL"))
6509 warn (_("Skipping unexpected relocation type %s\n"), relname);
6513 i = rp->r_offset / (3 * eh_addr_size);
6515 switch (rp->r_offset/eh_addr_size % 3)
6518 aux->table[i].start.section = sym->st_shndx;
6519 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6522 aux->table[i].end.section = sym->st_shndx;
6523 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6526 aux->table[i].info.section = sym->st_shndx;
6527 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6537 aux->table_len = size / (3 * eh_addr_size);
6542 ia64_process_unwind (FILE * file)
6544 Elf_Internal_Shdr * sec;
6545 Elf_Internal_Shdr * unwsec = NULL;
6546 Elf_Internal_Shdr * strsec;
6547 unsigned long i, unwcount = 0, unwstart = 0;
6548 struct ia64_unw_aux_info aux;
6550 memset (& aux, 0, sizeof (aux));
6552 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6554 if (sec->sh_type == SHT_SYMTAB
6555 && sec->sh_link < elf_header.e_shnum)
6557 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6559 strsec = section_headers + sec->sh_link;
6560 if (aux.strtab != NULL)
6562 error (_("Multiple auxillary string tables encountered\n"));
6565 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6568 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6570 else if (sec->sh_type == SHT_IA_64_UNWIND)
6575 printf (_("\nThere are no unwind sections in this file.\n"));
6577 while (unwcount-- > 0)
6582 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6583 i < elf_header.e_shnum; ++i, ++sec)
6584 if (sec->sh_type == SHT_IA_64_UNWIND)
6589 /* We have already counted the number of SHT_IA64_UNWIND
6590 sections so the loop above should never fail. */
6591 assert (unwsec != NULL);
6594 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6596 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6598 /* We need to find which section group it is in. */
6599 struct group_list * g;
6601 if (section_headers_groups == NULL
6602 || section_headers_groups [i] == NULL)
6603 i = elf_header.e_shnum;
6606 g = section_headers_groups [i]->root;
6608 for (; g != NULL; g = g->next)
6610 sec = section_headers + g->section_index;
6612 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6617 i = elf_header.e_shnum;
6620 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6622 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6623 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6624 suffix = SECTION_NAME (unwsec) + len;
6625 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6627 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6628 && streq (SECTION_NAME (sec) + len2, suffix))
6633 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6634 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6635 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6636 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6638 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6639 suffix = SECTION_NAME (unwsec) + len;
6640 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6642 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6643 && streq (SECTION_NAME (sec) + len2, suffix))
6647 if (i == elf_header.e_shnum)
6649 printf (_("\nCould not find unwind info section for "));
6651 if (string_table == NULL)
6652 printf ("%d", unwsec->sh_name);
6654 printf ("'%s'", printable_section_name (unwsec));
6658 aux.info_addr = sec->sh_addr;
6659 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6662 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6664 printf (_("\nUnwind section "));
6666 if (string_table == NULL)
6667 printf ("%d", unwsec->sh_name);
6669 printf ("'%s'", printable_section_name (unwsec));
6671 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6672 (unsigned long) unwsec->sh_offset,
6673 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6675 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6677 if (aux.table_len > 0)
6678 dump_ia64_unwind (& aux);
6681 free ((char *) aux.table);
6683 free ((char *) aux.info);
6692 free ((char *) aux.strtab);
6695 struct hppa_unw_table_entry
6697 struct absaddr start;
6699 unsigned int Cannot_unwind:1; /* 0 */
6700 unsigned int Millicode:1; /* 1 */
6701 unsigned int Millicode_save_sr0:1; /* 2 */
6702 unsigned int Region_description:2; /* 3..4 */
6703 unsigned int reserved1:1; /* 5 */
6704 unsigned int Entry_SR:1; /* 6 */
6705 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6706 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6707 unsigned int Args_stored:1; /* 16 */
6708 unsigned int Variable_Frame:1; /* 17 */
6709 unsigned int Separate_Package_Body:1; /* 18 */
6710 unsigned int Frame_Extension_Millicode:1; /* 19 */
6711 unsigned int Stack_Overflow_Check:1; /* 20 */
6712 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6713 unsigned int Ada_Region:1; /* 22 */
6714 unsigned int cxx_info:1; /* 23 */
6715 unsigned int cxx_try_catch:1; /* 24 */
6716 unsigned int sched_entry_seq:1; /* 25 */
6717 unsigned int reserved2:1; /* 26 */
6718 unsigned int Save_SP:1; /* 27 */
6719 unsigned int Save_RP:1; /* 28 */
6720 unsigned int Save_MRP_in_frame:1; /* 29 */
6721 unsigned int extn_ptr_defined:1; /* 30 */
6722 unsigned int Cleanup_defined:1; /* 31 */
6724 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6725 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6726 unsigned int Large_frame:1; /* 2 */
6727 unsigned int Pseudo_SP_Set:1; /* 3 */
6728 unsigned int reserved4:1; /* 4 */
6729 unsigned int Total_frame_size:27; /* 5..31 */
6732 struct hppa_unw_aux_info
6734 struct hppa_unw_table_entry *table; /* Unwind table. */
6735 unsigned long table_len; /* Length of unwind table. */
6736 bfd_vma seg_base; /* Starting address of segment. */
6737 Elf_Internal_Sym * symtab; /* The symbol table. */
6738 unsigned long nsyms; /* Number of symbols. */
6739 char * strtab; /* The string table. */
6740 unsigned long strtab_size; /* Size of string table. */
6744 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6746 struct hppa_unw_table_entry * tp;
6748 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6751 const char * procname;
6753 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6754 aux->strtab_size, tp->start, &procname,
6757 fputs ("\n<", stdout);
6761 fputs (procname, stdout);
6764 printf ("+%lx", (unsigned long) offset);
6767 fputs (">: [", stdout);
6768 print_vma (tp->start.offset, PREFIX_HEX);
6769 fputc ('-', stdout);
6770 print_vma (tp->end.offset, PREFIX_HEX);
6773 #define PF(_m) if (tp->_m) printf (#_m " ");
6774 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6777 PF(Millicode_save_sr0);
6778 /* PV(Region_description); */
6784 PF(Separate_Package_Body);
6785 PF(Frame_Extension_Millicode);
6786 PF(Stack_Overflow_Check);
6787 PF(Two_Instruction_SP_Increment);
6791 PF(sched_entry_seq);
6794 PF(Save_MRP_in_frame);
6795 PF(extn_ptr_defined);
6796 PF(Cleanup_defined);
6797 PF(MPE_XL_interrupt_marker);
6798 PF(HP_UX_interrupt_marker);
6801 PV(Total_frame_size);
6810 slurp_hppa_unwind_table (FILE * file,
6811 struct hppa_unw_aux_info * aux,
6812 Elf_Internal_Shdr * sec)
6814 unsigned long size, unw_ent_size, nentries, nrelas, i;
6815 Elf_Internal_Phdr * seg;
6816 struct hppa_unw_table_entry * tep;
6817 Elf_Internal_Shdr * relsec;
6818 Elf_Internal_Rela * rela;
6819 Elf_Internal_Rela * rp;
6820 unsigned char * table;
6822 Elf_Internal_Sym * sym;
6823 const char * relname;
6825 /* First, find the starting address of the segment that includes
6828 if (elf_header.e_phnum)
6830 if (! get_program_headers (file))
6833 for (seg = program_headers;
6834 seg < program_headers + elf_header.e_phnum;
6837 if (seg->p_type != PT_LOAD)
6840 if (sec->sh_addr >= seg->p_vaddr
6841 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6843 aux->seg_base = seg->p_vaddr;
6849 /* Second, build the unwind table from the contents of the unwind
6851 size = sec->sh_size;
6852 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6858 nentries = size / unw_ent_size;
6859 size = unw_ent_size * nentries;
6861 tep = aux->table = (struct hppa_unw_table_entry *)
6862 xcmalloc (nentries, sizeof (aux->table[0]));
6864 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6866 unsigned int tmp1, tmp2;
6868 tep->start.section = SHN_UNDEF;
6869 tep->end.section = SHN_UNDEF;
6871 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6872 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6873 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6874 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6876 tep->start.offset += aux->seg_base;
6877 tep->end.offset += aux->seg_base;
6879 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6880 tep->Millicode = (tmp1 >> 30) & 0x1;
6881 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6882 tep->Region_description = (tmp1 >> 27) & 0x3;
6883 tep->reserved1 = (tmp1 >> 26) & 0x1;
6884 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6885 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6886 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6887 tep->Args_stored = (tmp1 >> 15) & 0x1;
6888 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6889 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6890 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6891 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6892 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6893 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6894 tep->cxx_info = (tmp1 >> 8) & 0x1;
6895 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6896 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6897 tep->reserved2 = (tmp1 >> 5) & 0x1;
6898 tep->Save_SP = (tmp1 >> 4) & 0x1;
6899 tep->Save_RP = (tmp1 >> 3) & 0x1;
6900 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6901 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6902 tep->Cleanup_defined = tmp1 & 0x1;
6904 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6905 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6906 tep->Large_frame = (tmp2 >> 29) & 0x1;
6907 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6908 tep->reserved4 = (tmp2 >> 27) & 0x1;
6909 tep->Total_frame_size = tmp2 & 0x7ffffff;
6913 /* Third, apply any relocations to the unwind table. */
6914 for (relsec = section_headers;
6915 relsec < section_headers + elf_header.e_shnum;
6918 if (relsec->sh_type != SHT_RELA
6919 || relsec->sh_info >= elf_header.e_shnum
6920 || section_headers + relsec->sh_info != sec)
6923 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6927 for (rp = rela; rp < rela + nrelas; ++rp)
6929 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6930 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6932 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6933 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6935 warn (_("Skipping unexpected relocation type %s\n"), relname);
6939 i = rp->r_offset / unw_ent_size;
6941 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6944 aux->table[i].start.section = sym->st_shndx;
6945 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6948 aux->table[i].end.section = sym->st_shndx;
6949 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6959 aux->table_len = nentries;
6965 hppa_process_unwind (FILE * file)
6967 struct hppa_unw_aux_info aux;
6968 Elf_Internal_Shdr * unwsec = NULL;
6969 Elf_Internal_Shdr * strsec;
6970 Elf_Internal_Shdr * sec;
6973 if (string_table == NULL)
6976 memset (& aux, 0, sizeof (aux));
6978 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6980 if (sec->sh_type == SHT_SYMTAB
6981 && sec->sh_link < elf_header.e_shnum)
6983 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6985 strsec = section_headers + sec->sh_link;
6986 if (aux.strtab != NULL)
6988 error (_("Multiple auxillary string tables encountered\n"));
6991 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6994 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6996 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7001 printf (_("\nThere are no unwind sections in this file.\n"));
7003 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7005 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7007 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7008 printable_section_name (sec),
7009 (unsigned long) sec->sh_offset,
7010 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7012 slurp_hppa_unwind_table (file, &aux, sec);
7013 if (aux.table_len > 0)
7014 dump_hppa_unwind (&aux);
7017 free ((char *) aux.table);
7025 free ((char *) aux.strtab);
7030 unsigned char * data; /* The unwind data. */
7031 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7032 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7033 unsigned long nrelas; /* The number of relocations. */
7034 unsigned int rel_type; /* REL or RELA ? */
7035 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7038 struct arm_unw_aux_info
7040 FILE * file; /* The file containing the unwind sections. */
7041 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7042 unsigned long nsyms; /* Number of symbols. */
7043 char * strtab; /* The file's string table. */
7044 unsigned long strtab_size; /* Size of string table. */
7048 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7049 bfd_vma fn, struct absaddr addr)
7051 const char *procname;
7054 if (addr.section == SHN_UNDEF)
7057 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7058 aux->strtab_size, addr, &procname,
7061 print_vma (fn, PREFIX_HEX);
7065 fputs (" <", stdout);
7066 fputs (procname, stdout);
7069 printf ("+0x%lx", (unsigned long) sym_offset);
7070 fputc ('>', stdout);
7077 arm_free_section (struct arm_section *arm_sec)
7079 if (arm_sec->data != NULL)
7080 free (arm_sec->data);
7082 if (arm_sec->rela != NULL)
7083 free (arm_sec->rela);
7086 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7087 cached section and install SEC instead.
7088 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7089 and return its valued in * WORDP, relocating if necessary.
7090 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7091 relocation's offset in ADDR.
7092 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7093 into the string table of the symbol associated with the reloc. If no
7094 reloc was applied store -1 there.
7095 5) Return TRUE upon success, FALSE otherwise. */
7098 get_unwind_section_word (struct arm_unw_aux_info * aux,
7099 struct arm_section * arm_sec,
7100 Elf_Internal_Shdr * sec,
7101 bfd_vma word_offset,
7102 unsigned int * wordp,
7103 struct absaddr * addr,
7106 Elf_Internal_Rela *rp;
7107 Elf_Internal_Sym *sym;
7108 const char * relname;
7110 bfd_boolean wrapped;
7112 if (sec == NULL || arm_sec == NULL)
7115 addr->section = SHN_UNDEF;
7118 if (sym_name != NULL)
7119 *sym_name = (bfd_vma) -1;
7121 /* If necessary, update the section cache. */
7122 if (sec != arm_sec->sec)
7124 Elf_Internal_Shdr *relsec;
7126 arm_free_section (arm_sec);
7129 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7130 sec->sh_size, _("unwind data"));
7131 arm_sec->rela = NULL;
7132 arm_sec->nrelas = 0;
7134 for (relsec = section_headers;
7135 relsec < section_headers + elf_header.e_shnum;
7138 if (relsec->sh_info >= elf_header.e_shnum
7139 || section_headers + relsec->sh_info != sec
7140 /* PR 15745: Check the section type as well. */
7141 || (relsec->sh_type != SHT_REL
7142 && relsec->sh_type != SHT_RELA))
7145 arm_sec->rel_type = relsec->sh_type;
7146 if (relsec->sh_type == SHT_REL)
7148 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7150 & arm_sec->rela, & arm_sec->nrelas))
7153 else /* relsec->sh_type == SHT_RELA */
7155 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7157 & arm_sec->rela, & arm_sec->nrelas))
7163 arm_sec->next_rela = arm_sec->rela;
7166 /* If there is no unwind data we can do nothing. */
7167 if (arm_sec->data == NULL)
7170 /* If the offset is invalid then fail. */
7171 if (word_offset > sec->sh_size - 4)
7174 /* Get the word at the required offset. */
7175 word = byte_get (arm_sec->data + word_offset, 4);
7177 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7178 if (arm_sec->rela == NULL)
7184 /* Look through the relocs to find the one that applies to the provided offset. */
7186 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7188 bfd_vma prelval, offset;
7190 if (rp->r_offset > word_offset && !wrapped)
7195 if (rp->r_offset > word_offset)
7198 if (rp->r_offset & 3)
7200 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7201 (unsigned long) rp->r_offset);
7205 if (rp->r_offset < word_offset)
7208 /* PR 17531: file: 027-161405-0.004 */
7209 if (aux->symtab == NULL)
7212 if (arm_sec->rel_type == SHT_REL)
7214 offset = word & 0x7fffffff;
7215 if (offset & 0x40000000)
7216 offset |= ~ (bfd_vma) 0x7fffffff;
7218 else if (arm_sec->rel_type == SHT_RELA)
7219 offset = rp->r_addend;
7222 error (_("Unknown section relocation type %d encountered\n"),
7227 /* PR 17531 file: 027-1241568-0.004. */
7228 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7230 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7231 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7235 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7236 offset += sym->st_value;
7237 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7239 /* Check that we are processing the expected reloc type. */
7240 if (elf_header.e_machine == EM_ARM)
7242 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7243 if (relname == NULL)
7245 warn (_("Skipping unknown ARM relocation type: %d\n"),
7246 (int) ELF32_R_TYPE (rp->r_info));
7250 if (streq (relname, "R_ARM_NONE"))
7253 if (! streq (relname, "R_ARM_PREL31"))
7255 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7259 else if (elf_header.e_machine == EM_TI_C6000)
7261 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7262 if (relname == NULL)
7264 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7265 (int) ELF32_R_TYPE (rp->r_info));
7269 if (streq (relname, "R_C6000_NONE"))
7272 if (! streq (relname, "R_C6000_PREL31"))
7274 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7282 /* This function currently only supports ARM and TI unwinders. */
7283 warn (_("Only TI and ARM unwinders are currently supported\n"));
7287 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7288 addr->section = sym->st_shndx;
7289 addr->offset = offset;
7292 * sym_name = sym->st_name;
7297 arm_sec->next_rela = rp;
7302 static const char *tic6x_unwind_regnames[16] =
7304 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7305 "A14", "A13", "A12", "A11", "A10",
7306 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7310 decode_tic6x_unwind_regmask (unsigned int mask)
7314 for (i = 12; mask; mask >>= 1, i--)
7318 fputs (tic6x_unwind_regnames[i], stdout);
7320 fputs (", ", stdout);
7326 if (remaining == 0 && more_words) \
7329 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7330 data_offset, & word, & addr, NULL)) \
7336 #define GET_OP(OP) \
7341 (OP) = word >> 24; \
7346 printf (_("[Truncated opcode]\n")); \
7349 printf ("0x%02x ", OP)
7352 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7353 unsigned int word, unsigned int remaining,
7354 unsigned int more_words,
7355 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7356 struct arm_section *data_arm_sec)
7358 struct absaddr addr;
7360 /* Decode the unwinding instructions. */
7363 unsigned int op, op2;
7372 printf (" 0x%02x ", op);
7374 if ((op & 0xc0) == 0x00)
7376 int offset = ((op & 0x3f) << 2) + 4;
7378 printf (" vsp = vsp + %d", offset);
7380 else if ((op & 0xc0) == 0x40)
7382 int offset = ((op & 0x3f) << 2) + 4;
7384 printf (" vsp = vsp - %d", offset);
7386 else if ((op & 0xf0) == 0x80)
7389 if (op == 0x80 && op2 == 0)
7390 printf (_("Refuse to unwind"));
7393 unsigned int mask = ((op & 0x0f) << 8) | op2;
7398 for (i = 0; i < 12; i++)
7399 if (mask & (1 << i))
7405 printf ("r%d", 4 + i);
7410 else if ((op & 0xf0) == 0x90)
7412 if (op == 0x9d || op == 0x9f)
7413 printf (_(" [Reserved]"));
7415 printf (" vsp = r%d", op & 0x0f);
7417 else if ((op & 0xf0) == 0xa0)
7419 int end = 4 + (op & 0x07);
7424 for (i = 4; i <= end; i++)
7440 else if (op == 0xb0)
7441 printf (_(" finish"));
7442 else if (op == 0xb1)
7445 if (op2 == 0 || (op2 & 0xf0) != 0)
7446 printf (_("[Spare]"));
7449 unsigned int mask = op2 & 0x0f;
7454 for (i = 0; i < 12; i++)
7455 if (mask & (1 << i))
7466 else if (op == 0xb2)
7468 unsigned char buf[9];
7469 unsigned int i, len;
7470 unsigned long offset;
7472 for (i = 0; i < sizeof (buf); i++)
7475 if ((buf[i] & 0x80) == 0)
7478 if (i == sizeof (buf))
7479 printf (_("corrupt change to vsp"));
7482 offset = read_uleb128 (buf, &len, buf + i + 1);
7483 assert (len == i + 1);
7484 offset = offset * 4 + 0x204;
7485 printf ("vsp = vsp + %ld", offset);
7488 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7490 unsigned int first, last;
7497 printf ("pop {D%d", first);
7499 printf ("-D%d", first + last);
7502 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7504 unsigned int count = op & 0x07;
7508 printf ("-D%d", 8 + count);
7511 else if (op >= 0xc0 && op <= 0xc5)
7513 unsigned int count = op & 0x07;
7515 printf (" pop {wR10");
7517 printf ("-wR%d", 10 + count);
7520 else if (op == 0xc6)
7522 unsigned int first, last;
7527 printf ("pop {wR%d", first);
7529 printf ("-wR%d", first + last);
7532 else if (op == 0xc7)
7535 if (op2 == 0 || (op2 & 0xf0) != 0)
7536 printf (_("[Spare]"));
7539 unsigned int mask = op2 & 0x0f;
7544 for (i = 0; i < 4; i++)
7545 if (mask & (1 << i))
7551 printf ("wCGR%d", i);
7557 printf (_(" [unsupported opcode]"));
7563 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7564 unsigned int word, unsigned int remaining,
7565 unsigned int more_words,
7566 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7567 struct arm_section *data_arm_sec)
7569 struct absaddr addr;
7571 /* Decode the unwinding instructions. */
7574 unsigned int op, op2;
7583 printf (" 0x%02x ", op);
7585 if ((op & 0xc0) == 0x00)
7587 int offset = ((op & 0x3f) << 3) + 8;
7588 printf (" sp = sp + %d", offset);
7590 else if ((op & 0xc0) == 0x80)
7593 if (op == 0x80 && op2 == 0)
7594 printf (_("Refuse to unwind"));
7597 unsigned int mask = ((op & 0x1f) << 8) | op2;
7599 printf ("pop compact {");
7603 decode_tic6x_unwind_regmask (mask);
7607 else if ((op & 0xf0) == 0xc0)
7615 unsigned int offset;
7619 /* Scan entire instruction first so that GET_OP output is not
7620 interleaved with disassembly. */
7622 for (i = 0; nregs < (op & 0xf); i++)
7628 regpos[nregs].offset = i * 2;
7629 regpos[nregs].reg = reg;
7636 regpos[nregs].offset = i * 2 + 1;
7637 regpos[nregs].reg = reg;
7642 printf (_("pop frame {"));
7644 for (i = i * 2; i > 0; i--)
7646 if (regpos[reg].offset == i - 1)
7648 name = tic6x_unwind_regnames[regpos[reg].reg];
7655 fputs (name, stdout);
7662 else if (op == 0xd0)
7663 printf (" MOV FP, SP");
7664 else if (op == 0xd1)
7665 printf (" __c6xabi_pop_rts");
7666 else if (op == 0xd2)
7668 unsigned char buf[9];
7669 unsigned int i, len;
7670 unsigned long offset;
7672 for (i = 0; i < sizeof (buf); i++)
7675 if ((buf[i] & 0x80) == 0)
7678 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7679 if (i == sizeof (buf))
7681 printf ("<corrupt sp adjust>\n");
7682 warn (_("Corrupt stack pointer adjustment detected\n"));
7686 offset = read_uleb128 (buf, &len, buf + i + 1);
7687 assert (len == i + 1);
7688 offset = offset * 8 + 0x408;
7689 printf (_("sp = sp + %ld"), offset);
7691 else if ((op & 0xf0) == 0xe0)
7693 if ((op & 0x0f) == 7)
7696 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7700 printf (_(" [unsupported opcode]"));
7707 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7711 offset = word & 0x7fffffff;
7712 if (offset & 0x40000000)
7713 offset |= ~ (bfd_vma) 0x7fffffff;
7715 if (elf_header.e_machine == EM_TI_C6000)
7718 return offset + where;
7722 decode_arm_unwind (struct arm_unw_aux_info * aux,
7724 unsigned int remaining,
7725 bfd_vma data_offset,
7726 Elf_Internal_Shdr * data_sec,
7727 struct arm_section * data_arm_sec)
7730 unsigned int more_words = 0;
7731 struct absaddr addr;
7732 bfd_vma sym_name = (bfd_vma) -1;
7736 /* Fetch the first word.
7737 Note - when decoding an object file the address extracted
7738 here will always be 0. So we also pass in the sym_name
7739 parameter so that we can find the symbol associated with
7740 the personality routine. */
7741 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7742 & word, & addr, & sym_name))
7748 if ((word & 0x80000000) == 0)
7750 /* Expand prel31 for personality routine. */
7752 const char *procname;
7754 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7755 printf (_(" Personality routine: "));
7757 && addr.section == SHN_UNDEF && addr.offset == 0
7758 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7760 procname = aux->strtab + sym_name;
7761 print_vma (fn, PREFIX_HEX);
7764 fputs (" <", stdout);
7765 fputs (procname, stdout);
7766 fputc ('>', stdout);
7770 procname = arm_print_vma_and_name (aux, fn, addr);
7771 fputc ('\n', stdout);
7773 /* The GCC personality routines use the standard compact
7774 encoding, starting with one byte giving the number of
7776 if (procname != NULL
7777 && (const_strneq (procname, "__gcc_personality_v0")
7778 || const_strneq (procname, "__gxx_personality_v0")
7779 || const_strneq (procname, "__gcj_personality_v0")
7780 || const_strneq (procname, "__gnu_objc_personality_v0")))
7787 printf (_(" [Truncated data]\n"));
7790 more_words = word >> 24;
7800 /* ARM EHABI Section 6.3:
7802 An exception-handling table entry for the compact model looks like:
7806 1 0 index Data for personalityRoutine[index] */
7808 if (elf_header.e_machine == EM_ARM
7809 && (word & 0x70000000))
7810 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7812 per_index = (word >> 24) & 0x7f;
7813 printf (_(" Compact model index: %d\n"), per_index);
7820 else if (per_index < 3)
7822 more_words = (word >> 16) & 0xff;
7828 switch (elf_header.e_machine)
7833 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7834 data_offset, data_sec, data_arm_sec);
7838 warn (_("Unknown ARM compact model index encountered\n"));
7839 printf (_(" [reserved]\n"));
7846 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7847 data_offset, data_sec, data_arm_sec);
7849 else if (per_index < 5)
7851 if (((word >> 17) & 0x7f) == 0x7f)
7852 printf (_(" Restore stack from frame pointer\n"));
7854 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7855 printf (_(" Registers restored: "));
7857 printf (" (compact) ");
7858 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7860 printf (_(" Return register: %s\n"),
7861 tic6x_unwind_regnames[word & 0xf]);
7864 printf (_(" [reserved (%d)]\n"), per_index);
7868 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7869 elf_header.e_machine);
7872 /* Decode the descriptors. Not implemented. */
7876 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7878 struct arm_section exidx_arm_sec, extab_arm_sec;
7879 unsigned int i, exidx_len;
7881 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7882 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7883 exidx_len = exidx_sec->sh_size / 8;
7885 for (i = 0; i < exidx_len; i++)
7887 unsigned int exidx_fn, exidx_entry;
7888 struct absaddr fn_addr, entry_addr;
7891 fputc ('\n', stdout);
7893 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7894 8 * i, & exidx_fn, & fn_addr, NULL)
7895 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7896 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7898 arm_free_section (& exidx_arm_sec);
7899 arm_free_section (& extab_arm_sec);
7903 /* ARM EHABI, Section 5:
7904 An index table entry consists of 2 words.
7905 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7906 if (exidx_fn & 0x80000000)
7907 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7909 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7911 arm_print_vma_and_name (aux, fn, fn_addr);
7912 fputs (": ", stdout);
7914 if (exidx_entry == 1)
7916 print_vma (exidx_entry, PREFIX_HEX);
7917 fputs (" [cantunwind]\n", stdout);
7919 else if (exidx_entry & 0x80000000)
7921 print_vma (exidx_entry, PREFIX_HEX);
7922 fputc ('\n', stdout);
7923 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7927 bfd_vma table, table_offset = 0;
7928 Elf_Internal_Shdr *table_sec;
7930 fputs ("@", stdout);
7931 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7932 print_vma (table, PREFIX_HEX);
7935 /* Locate the matching .ARM.extab. */
7936 if (entry_addr.section != SHN_UNDEF
7937 && entry_addr.section < elf_header.e_shnum)
7939 table_sec = section_headers + entry_addr.section;
7940 table_offset = entry_addr.offset;
7944 table_sec = find_section_by_address (table);
7945 if (table_sec != NULL)
7946 table_offset = table - table_sec->sh_addr;
7948 if (table_sec == NULL)
7950 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7951 (unsigned long) table);
7954 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7961 arm_free_section (&exidx_arm_sec);
7962 arm_free_section (&extab_arm_sec);
7965 /* Used for both ARM and C6X unwinding tables. */
7968 arm_process_unwind (FILE *file)
7970 struct arm_unw_aux_info aux;
7971 Elf_Internal_Shdr *unwsec = NULL;
7972 Elf_Internal_Shdr *strsec;
7973 Elf_Internal_Shdr *sec;
7975 unsigned int sec_type;
7977 switch (elf_header.e_machine)
7980 sec_type = SHT_ARM_EXIDX;
7984 sec_type = SHT_C6000_UNWIND;
7988 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
7989 elf_header.e_machine);
7993 if (string_table == NULL)
7996 memset (& aux, 0, sizeof (aux));
7999 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8001 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8003 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8005 strsec = section_headers + sec->sh_link;
8007 /* PR binutils/17531 file: 011-12666-0.004. */
8008 if (aux.strtab != NULL)
8010 error (_("Multiple string tables found in file.\n"));
8013 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8014 1, strsec->sh_size, _("string table"));
8015 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8017 else if (sec->sh_type == sec_type)
8022 printf (_("\nThere are no unwind sections in this file.\n"));
8024 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8026 if (sec->sh_type == sec_type)
8028 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8029 printable_section_name (sec),
8030 (unsigned long) sec->sh_offset,
8031 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8033 dump_arm_unwind (&aux, sec);
8040 free ((char *) aux.strtab);
8044 process_unwind (FILE * file)
8046 struct unwind_handler
8049 void (* handler)(FILE *);
8052 { EM_ARM, arm_process_unwind },
8053 { EM_IA_64, ia64_process_unwind },
8054 { EM_PARISC, hppa_process_unwind },
8055 { EM_TI_C6000, arm_process_unwind },
8063 for (i = 0; handlers[i].handler != NULL; i++)
8064 if (elf_header.e_machine == handlers[i].machtype)
8066 handlers[i].handler (file);
8070 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8071 get_machine_name (elf_header.e_machine));
8075 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8077 switch (entry->d_tag)
8080 if (entry->d_un.d_val == 0)
8084 static const char * opts[] =
8086 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8087 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8088 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8089 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8095 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8096 if (entry->d_un.d_val & (1 << cnt))
8098 printf ("%s%s", first ? "" : " ", opts[cnt]);
8104 case DT_MIPS_IVERSION:
8105 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8106 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8110 sprintf_vma (buf, entry->d_un.d_ptr);
8111 /* Note: coded this way so that there is a single string for translation. */
8112 printf (_("<corrupt: %s>"), buf);
8116 case DT_MIPS_TIME_STAMP:
8121 time_t atime = entry->d_un.d_val;
8122 tmp = gmtime (&atime);
8123 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8124 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8125 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8126 printf (_("Time Stamp: %s"), timebuf);
8130 case DT_MIPS_RLD_VERSION:
8131 case DT_MIPS_LOCAL_GOTNO:
8132 case DT_MIPS_CONFLICTNO:
8133 case DT_MIPS_LIBLISTNO:
8134 case DT_MIPS_SYMTABNO:
8135 case DT_MIPS_UNREFEXTNO:
8136 case DT_MIPS_HIPAGENO:
8137 case DT_MIPS_DELTA_CLASS_NO:
8138 case DT_MIPS_DELTA_INSTANCE_NO:
8139 case DT_MIPS_DELTA_RELOC_NO:
8140 case DT_MIPS_DELTA_SYM_NO:
8141 case DT_MIPS_DELTA_CLASSSYM_NO:
8142 case DT_MIPS_COMPACT_SIZE:
8143 print_vma (entry->d_un.d_ptr, DEC);
8147 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8153 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8155 switch (entry->d_tag)
8157 case DT_HP_DLD_FLAGS:
8166 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8167 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8168 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8169 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8170 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8171 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8172 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8173 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8174 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8175 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8176 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8177 { DT_HP_GST, "HP_GST" },
8178 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8179 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8180 { DT_HP_NODELETE, "HP_NODELETE" },
8181 { DT_HP_GROUP, "HP_GROUP" },
8182 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8186 bfd_vma val = entry->d_un.d_val;
8188 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8189 if (val & flags[cnt].bit)
8193 fputs (flags[cnt].str, stdout);
8195 val ^= flags[cnt].bit;
8198 if (val != 0 || first)
8202 print_vma (val, HEX);
8208 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8216 /* VMS vs Unix time offset and factor. */
8218 #define VMS_EPOCH_OFFSET 35067168000000000LL
8219 #define VMS_GRANULARITY_FACTOR 10000000
8221 /* Display a VMS time in a human readable format. */
8224 print_vms_time (bfd_int64_t vmstime)
8229 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8230 tm = gmtime (&unxtime);
8231 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8232 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8233 tm->tm_hour, tm->tm_min, tm->tm_sec);
8238 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8240 switch (entry->d_tag)
8242 case DT_IA_64_PLT_RESERVE:
8243 /* First 3 slots reserved. */
8244 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8246 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8249 case DT_IA_64_VMS_LINKTIME:
8251 print_vms_time (entry->d_un.d_val);
8255 case DT_IA_64_VMS_LNKFLAGS:
8256 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8257 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8258 printf (" CALL_DEBUG");
8259 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8260 printf (" NOP0BUFS");
8261 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8262 printf (" P0IMAGE");
8263 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8264 printf (" MKTHREADS");
8265 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8266 printf (" UPCALLS");
8267 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8269 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8270 printf (" INITIALIZE");
8271 if (entry->d_un.d_val & VMS_LF_MAIN)
8273 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8274 printf (" EXE_INIT");
8275 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8276 printf (" TBK_IN_IMG");
8277 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8278 printf (" DBG_IN_IMG");
8279 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8280 printf (" TBK_IN_DSF");
8281 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8282 printf (" DBG_IN_DSF");
8283 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8284 printf (" SIGNATURES");
8285 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8286 printf (" REL_SEG_OFF");
8290 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8297 get_32bit_dynamic_section (FILE * file)
8299 Elf32_External_Dyn * edyn;
8300 Elf32_External_Dyn * ext;
8301 Elf_Internal_Dyn * entry;
8303 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8304 dynamic_size, _("dynamic section"));
8308 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8309 might not have the luxury of section headers. Look for the DT_NULL
8310 terminator to determine the number of entries. */
8311 for (ext = edyn, dynamic_nent = 0;
8312 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8316 if (BYTE_GET (ext->d_tag) == DT_NULL)
8320 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8322 if (dynamic_section == NULL)
8324 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8325 (unsigned long) dynamic_nent);
8330 for (ext = edyn, entry = dynamic_section;
8331 entry < dynamic_section + dynamic_nent;
8334 entry->d_tag = BYTE_GET (ext->d_tag);
8335 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8344 get_64bit_dynamic_section (FILE * file)
8346 Elf64_External_Dyn * edyn;
8347 Elf64_External_Dyn * ext;
8348 Elf_Internal_Dyn * entry;
8350 /* Read in the data. */
8351 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8352 dynamic_size, _("dynamic section"));
8356 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8357 might not have the luxury of section headers. Look for the DT_NULL
8358 terminator to determine the number of entries. */
8359 for (ext = edyn, dynamic_nent = 0;
8360 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8361 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8365 if (BYTE_GET (ext->d_tag) == DT_NULL)
8369 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8371 if (dynamic_section == NULL)
8373 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8374 (unsigned long) dynamic_nent);
8379 /* Convert from external to internal formats. */
8380 for (ext = edyn, entry = dynamic_section;
8381 entry < dynamic_section + dynamic_nent;
8384 entry->d_tag = BYTE_GET (ext->d_tag);
8385 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8394 print_dynamic_flags (bfd_vma flags)
8402 flag = flags & - flags;
8412 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8413 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8414 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8415 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8416 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8417 default: fputs (_("unknown"), stdout); break;
8423 /* Parse and display the contents of the dynamic section. */
8426 process_dynamic_section (FILE * file)
8428 Elf_Internal_Dyn * entry;
8430 if (dynamic_size == 0)
8433 printf (_("\nThere is no dynamic section in this file.\n"));
8440 if (! get_32bit_dynamic_section (file))
8443 else if (! get_64bit_dynamic_section (file))
8446 /* Find the appropriate symbol table. */
8447 if (dynamic_symbols == NULL)
8449 for (entry = dynamic_section;
8450 entry < dynamic_section + dynamic_nent;
8453 Elf_Internal_Shdr section;
8455 if (entry->d_tag != DT_SYMTAB)
8458 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8460 /* Since we do not know how big the symbol table is,
8461 we default to reading in the entire file (!) and
8462 processing that. This is overkill, I know, but it
8464 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8466 if (archive_file_offset != 0)
8467 section.sh_size = archive_file_size - section.sh_offset;
8470 if (fseek (file, 0, SEEK_END))
8471 error (_("Unable to seek to end of file!\n"));
8473 section.sh_size = ftell (file) - section.sh_offset;
8477 section.sh_entsize = sizeof (Elf32_External_Sym);
8479 section.sh_entsize = sizeof (Elf64_External_Sym);
8480 section.sh_name = string_table_length;
8482 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8483 if (num_dynamic_syms < 1)
8485 error (_("Unable to determine the number of symbols to load\n"));
8491 /* Similarly find a string table. */
8492 if (dynamic_strings == NULL)
8494 for (entry = dynamic_section;
8495 entry < dynamic_section + dynamic_nent;
8498 unsigned long offset;
8501 if (entry->d_tag != DT_STRTAB)
8504 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8506 /* Since we do not know how big the string table is,
8507 we default to reading in the entire file (!) and
8508 processing that. This is overkill, I know, but it
8511 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8513 if (archive_file_offset != 0)
8514 str_tab_len = archive_file_size - offset;
8517 if (fseek (file, 0, SEEK_END))
8518 error (_("Unable to seek to end of file\n"));
8519 str_tab_len = ftell (file) - offset;
8522 if (str_tab_len < 1)
8525 (_("Unable to determine the length of the dynamic string table\n"));
8529 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8531 _("dynamic string table"));
8532 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8537 /* And find the syminfo section if available. */
8538 if (dynamic_syminfo == NULL)
8540 unsigned long syminsz = 0;
8542 for (entry = dynamic_section;
8543 entry < dynamic_section + dynamic_nent;
8546 if (entry->d_tag == DT_SYMINENT)
8548 /* Note: these braces are necessary to avoid a syntax
8549 error from the SunOS4 C compiler. */
8550 /* PR binutils/17531: A corrupt file can trigger this test.
8551 So do not use an assert, instead generate an error message. */
8552 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8553 error (_("Bad value (%d) for SYMINENT entry\n"),
8554 (int) entry->d_un.d_val);
8556 else if (entry->d_tag == DT_SYMINSZ)
8557 syminsz = entry->d_un.d_val;
8558 else if (entry->d_tag == DT_SYMINFO)
8559 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8563 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8565 Elf_External_Syminfo * extsyminfo;
8566 Elf_External_Syminfo * extsym;
8567 Elf_Internal_Syminfo * syminfo;
8569 /* There is a syminfo section. Read the data. */
8570 extsyminfo = (Elf_External_Syminfo *)
8571 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8572 _("symbol information"));
8576 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8577 if (dynamic_syminfo == NULL)
8579 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8580 (unsigned long) syminsz);
8584 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8585 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8586 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8587 ++syminfo, ++extsym)
8589 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8590 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8597 if (do_dynamic && dynamic_addr)
8598 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8599 dynamic_addr, (unsigned long) dynamic_nent);
8601 printf (_(" Tag Type Name/Value\n"));
8603 for (entry = dynamic_section;
8604 entry < dynamic_section + dynamic_nent;
8612 print_vma (entry->d_tag, FULL_HEX);
8613 dtype = get_dynamic_type (entry->d_tag);
8614 printf (" (%s)%*s", dtype,
8615 ((is_32bit_elf ? 27 : 19)
8616 - (int) strlen (dtype)),
8620 switch (entry->d_tag)
8624 print_dynamic_flags (entry->d_un.d_val);
8634 switch (entry->d_tag)
8637 printf (_("Auxiliary library"));
8641 printf (_("Filter library"));
8645 printf (_("Configuration file"));
8649 printf (_("Dependency audit library"));
8653 printf (_("Audit library"));
8657 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8658 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8662 print_vma (entry->d_un.d_val, PREFIX_HEX);
8671 printf (_("Flags:"));
8673 if (entry->d_un.d_val == 0)
8674 printf (_(" None\n"));
8677 unsigned long int val = entry->d_un.d_val;
8679 if (val & DTF_1_PARINIT)
8681 printf (" PARINIT");
8682 val ^= DTF_1_PARINIT;
8684 if (val & DTF_1_CONFEXP)
8686 printf (" CONFEXP");
8687 val ^= DTF_1_CONFEXP;
8690 printf (" %lx", val);
8699 printf (_("Flags:"));
8701 if (entry->d_un.d_val == 0)
8702 printf (_(" None\n"));
8705 unsigned long int val = entry->d_un.d_val;
8707 if (val & DF_P1_LAZYLOAD)
8709 printf (" LAZYLOAD");
8710 val ^= DF_P1_LAZYLOAD;
8712 if (val & DF_P1_GROUPPERM)
8714 printf (" GROUPPERM");
8715 val ^= DF_P1_GROUPPERM;
8718 printf (" %lx", val);
8727 printf (_("Flags:"));
8728 if (entry->d_un.d_val == 0)
8729 printf (_(" None\n"));
8732 unsigned long int val = entry->d_un.d_val;
8739 if (val & DF_1_GLOBAL)
8744 if (val & DF_1_GROUP)
8749 if (val & DF_1_NODELETE)
8751 printf (" NODELETE");
8752 val ^= DF_1_NODELETE;
8754 if (val & DF_1_LOADFLTR)
8756 printf (" LOADFLTR");
8757 val ^= DF_1_LOADFLTR;
8759 if (val & DF_1_INITFIRST)
8761 printf (" INITFIRST");
8762 val ^= DF_1_INITFIRST;
8764 if (val & DF_1_NOOPEN)
8769 if (val & DF_1_ORIGIN)
8774 if (val & DF_1_DIRECT)
8779 if (val & DF_1_TRANS)
8784 if (val & DF_1_INTERPOSE)
8786 printf (" INTERPOSE");
8787 val ^= DF_1_INTERPOSE;
8789 if (val & DF_1_NODEFLIB)
8791 printf (" NODEFLIB");
8792 val ^= DF_1_NODEFLIB;
8794 if (val & DF_1_NODUMP)
8799 if (val & DF_1_CONFALT)
8801 printf (" CONFALT");
8802 val ^= DF_1_CONFALT;
8804 if (val & DF_1_ENDFILTEE)
8806 printf (" ENDFILTEE");
8807 val ^= DF_1_ENDFILTEE;
8809 if (val & DF_1_DISPRELDNE)
8811 printf (" DISPRELDNE");
8812 val ^= DF_1_DISPRELDNE;
8814 if (val & DF_1_DISPRELPND)
8816 printf (" DISPRELPND");
8817 val ^= DF_1_DISPRELPND;
8819 if (val & DF_1_NODIRECT)
8821 printf (" NODIRECT");
8822 val ^= DF_1_NODIRECT;
8824 if (val & DF_1_IGNMULDEF)
8826 printf (" IGNMULDEF");
8827 val ^= DF_1_IGNMULDEF;
8829 if (val & DF_1_NOKSYMS)
8831 printf (" NOKSYMS");
8832 val ^= DF_1_NOKSYMS;
8834 if (val & DF_1_NOHDR)
8839 if (val & DF_1_EDITED)
8844 if (val & DF_1_NORELOC)
8846 printf (" NORELOC");
8847 val ^= DF_1_NORELOC;
8849 if (val & DF_1_SYMINTPOSE)
8851 printf (" SYMINTPOSE");
8852 val ^= DF_1_SYMINTPOSE;
8854 if (val & DF_1_GLOBAUDIT)
8856 printf (" GLOBAUDIT");
8857 val ^= DF_1_GLOBAUDIT;
8859 if (val & DF_1_SINGLETON)
8861 printf (" SINGLETON");
8862 val ^= DF_1_SINGLETON;
8865 printf (" %lx", val);
8872 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8874 puts (get_dynamic_type (entry->d_un.d_val));
8894 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8900 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8901 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8907 switch (entry->d_tag)
8910 printf (_("Shared library: [%s]"), name);
8912 if (streq (name, program_interpreter))
8913 printf (_(" program interpreter"));
8917 printf (_("Library soname: [%s]"), name);
8921 printf (_("Library rpath: [%s]"), name);
8925 printf (_("Library runpath: [%s]"), name);
8929 print_vma (entry->d_un.d_val, PREFIX_HEX);
8934 print_vma (entry->d_un.d_val, PREFIX_HEX);
8947 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8951 case DT_INIT_ARRAYSZ:
8952 case DT_FINI_ARRAYSZ:
8953 case DT_GNU_CONFLICTSZ:
8954 case DT_GNU_LIBLISTSZ:
8957 print_vma (entry->d_un.d_val, UNSIGNED);
8958 printf (_(" (bytes)\n"));
8968 print_vma (entry->d_un.d_val, UNSIGNED);
8981 if (entry->d_tag == DT_USED
8982 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8984 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8988 printf (_("Not needed object: [%s]\n"), name);
8993 print_vma (entry->d_un.d_val, PREFIX_HEX);
8999 /* The value of this entry is ignored. */
9004 case DT_GNU_PRELINKED:
9008 time_t atime = entry->d_un.d_val;
9010 tmp = gmtime (&atime);
9011 /* PR 17533 file: 041-1244816-0.004. */
9013 printf (_("<corrupt time val: %lx"),
9014 (unsigned long) atime);
9016 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9017 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9018 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9024 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9027 print_vma (entry->d_un.d_val, PREFIX_HEX);
9033 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9034 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9039 switch (elf_header.e_machine)
9042 case EM_MIPS_RS3_LE:
9043 dynamic_section_mips_val (entry);
9046 dynamic_section_parisc_val (entry);
9049 dynamic_section_ia64_val (entry);
9052 print_vma (entry->d_un.d_val, PREFIX_HEX);
9064 get_ver_flags (unsigned int flags)
9066 static char buff[32];
9073 if (flags & VER_FLG_BASE)
9074 strcat (buff, "BASE ");
9076 if (flags & VER_FLG_WEAK)
9078 if (flags & VER_FLG_BASE)
9079 strcat (buff, "| ");
9081 strcat (buff, "WEAK ");
9084 if (flags & VER_FLG_INFO)
9086 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9087 strcat (buff, "| ");
9089 strcat (buff, "INFO ");
9092 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9093 strcat (buff, _("| <unknown>"));
9098 /* Display the contents of the version sections. */
9101 process_version_sections (FILE * file)
9103 Elf_Internal_Shdr * section;
9110 for (i = 0, section = section_headers;
9111 i < elf_header.e_shnum;
9114 switch (section->sh_type)
9116 case SHT_GNU_verdef:
9118 Elf_External_Verdef * edefs;
9125 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9126 printable_section_name (section),
9129 printf (_(" Addr: 0x"));
9130 printf_vma (section->sh_addr);
9131 printf (_(" Offset: %#08lx Link: %u (%s)"),
9132 (unsigned long) section->sh_offset, section->sh_link,
9133 printable_section_name_from_index (section->sh_link));
9135 edefs = (Elf_External_Verdef *)
9136 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9137 _("version definition section"));
9140 endbuf = (char *) edefs + section->sh_size;
9142 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9145 Elf_External_Verdef * edef;
9146 Elf_Internal_Verdef ent;
9147 Elf_External_Verdaux * eaux;
9148 Elf_Internal_Verdaux aux;
9152 /* Check for very large indicies. */
9153 if (idx > (size_t) (endbuf - (char *) edefs))
9156 vstart = ((char *) edefs) + idx;
9157 if (vstart + sizeof (*edef) > endbuf)
9160 edef = (Elf_External_Verdef *) vstart;
9162 ent.vd_version = BYTE_GET (edef->vd_version);
9163 ent.vd_flags = BYTE_GET (edef->vd_flags);
9164 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9165 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9166 ent.vd_hash = BYTE_GET (edef->vd_hash);
9167 ent.vd_aux = BYTE_GET (edef->vd_aux);
9168 ent.vd_next = BYTE_GET (edef->vd_next);
9170 printf (_(" %#06x: Rev: %d Flags: %s"),
9171 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9173 printf (_(" Index: %d Cnt: %d "),
9174 ent.vd_ndx, ent.vd_cnt);
9176 /* Check for overflow. */
9177 if (ent.vd_aux > (size_t) (endbuf - vstart))
9180 vstart += ent.vd_aux;
9182 eaux = (Elf_External_Verdaux *) vstart;
9184 aux.vda_name = BYTE_GET (eaux->vda_name);
9185 aux.vda_next = BYTE_GET (eaux->vda_next);
9187 if (VALID_DYNAMIC_NAME (aux.vda_name))
9188 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9190 printf (_("Name index: %ld\n"), aux.vda_name);
9192 isum = idx + ent.vd_aux;
9194 for (j = 1; j < ent.vd_cnt; j++)
9196 /* Check for overflow. */
9197 if (aux.vda_next > (size_t) (endbuf - vstart))
9200 isum += aux.vda_next;
9201 vstart += aux.vda_next;
9203 eaux = (Elf_External_Verdaux *) vstart;
9204 if (vstart + sizeof (*eaux) > endbuf)
9207 aux.vda_name = BYTE_GET (eaux->vda_name);
9208 aux.vda_next = BYTE_GET (eaux->vda_next);
9210 if (VALID_DYNAMIC_NAME (aux.vda_name))
9211 printf (_(" %#06x: Parent %d: %s\n"),
9212 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9214 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9215 isum, j, aux.vda_name);
9219 printf (_(" Version def aux past end of section\n"));
9221 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9222 if (idx + ent.vd_next <= idx)
9228 if (cnt < section->sh_info)
9229 printf (_(" Version definition past end of section\n"));
9235 case SHT_GNU_verneed:
9237 Elf_External_Verneed * eneed;
9244 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9245 printable_section_name (section), section->sh_info);
9247 printf (_(" Addr: 0x"));
9248 printf_vma (section->sh_addr);
9249 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9250 (unsigned long) section->sh_offset, section->sh_link,
9251 printable_section_name_from_index (section->sh_link));
9253 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9254 section->sh_offset, 1,
9256 _("Version Needs section"));
9259 endbuf = (char *) eneed + section->sh_size;
9261 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9263 Elf_External_Verneed * entry;
9264 Elf_Internal_Verneed ent;
9269 if (idx > (size_t) (endbuf - (char *) eneed))
9272 vstart = ((char *) eneed) + idx;
9273 if (vstart + sizeof (*entry) > endbuf)
9276 entry = (Elf_External_Verneed *) vstart;
9278 ent.vn_version = BYTE_GET (entry->vn_version);
9279 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9280 ent.vn_file = BYTE_GET (entry->vn_file);
9281 ent.vn_aux = BYTE_GET (entry->vn_aux);
9282 ent.vn_next = BYTE_GET (entry->vn_next);
9284 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9286 if (VALID_DYNAMIC_NAME (ent.vn_file))
9287 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9289 printf (_(" File: %lx"), ent.vn_file);
9291 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9293 /* Check for overflow. */
9294 if (ent.vn_aux > (size_t) (endbuf - vstart))
9297 vstart += ent.vn_aux;
9299 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9301 Elf_External_Vernaux * eaux;
9302 Elf_Internal_Vernaux aux;
9304 if (vstart + sizeof (*eaux) > endbuf)
9306 eaux = (Elf_External_Vernaux *) vstart;
9308 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9309 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9310 aux.vna_other = BYTE_GET (eaux->vna_other);
9311 aux.vna_name = BYTE_GET (eaux->vna_name);
9312 aux.vna_next = BYTE_GET (eaux->vna_next);
9314 if (VALID_DYNAMIC_NAME (aux.vna_name))
9315 printf (_(" %#06x: Name: %s"),
9316 isum, GET_DYNAMIC_NAME (aux.vna_name));
9318 printf (_(" %#06x: Name index: %lx"),
9319 isum, aux.vna_name);
9321 printf (_(" Flags: %s Version: %d\n"),
9322 get_ver_flags (aux.vna_flags), aux.vna_other);
9324 /* Check for overflow. */
9325 if (aux.vna_next > (size_t) (endbuf - vstart))
9328 isum += aux.vna_next;
9329 vstart += aux.vna_next;
9333 warn (_("Missing Version Needs auxillary information\n"));
9335 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9337 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9338 cnt = section->sh_info;
9344 if (cnt < section->sh_info)
9345 warn (_("Missing Version Needs information\n"));
9351 case SHT_GNU_versym:
9353 Elf_Internal_Shdr * link_section;
9356 unsigned char * edata;
9357 unsigned short * data;
9359 Elf_Internal_Sym * symbols;
9360 Elf_Internal_Shdr * string_sec;
9361 unsigned long num_syms;
9364 if (section->sh_link >= elf_header.e_shnum)
9367 link_section = section_headers + section->sh_link;
9368 total = section->sh_size / sizeof (Elf_External_Versym);
9370 if (link_section->sh_link >= elf_header.e_shnum)
9375 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9376 if (symbols == NULL)
9379 string_sec = section_headers + link_section->sh_link;
9381 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9382 string_sec->sh_size,
9383 _("version string table"));
9390 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9391 printable_section_name (section), (unsigned long) total);
9393 printf (_(" Addr: "));
9394 printf_vma (section->sh_addr);
9395 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9396 (unsigned long) section->sh_offset, section->sh_link,
9397 printable_section_name (link_section));
9399 off = offset_from_vma (file,
9400 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9401 total * sizeof (short));
9402 edata = (unsigned char *) get_data (NULL, file, off, total,
9404 _("version symbol data"));
9412 data = (short unsigned int *) cmalloc (total, sizeof (short));
9414 for (cnt = total; cnt --;)
9415 data[cnt] = byte_get (edata + cnt * sizeof (short),
9420 for (cnt = 0; cnt < total; cnt += 4)
9423 int check_def, check_need;
9426 printf (" %03x:", cnt);
9428 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9429 switch (data[cnt + j])
9432 fputs (_(" 0 (*local*) "), stdout);
9436 fputs (_(" 1 (*global*) "), stdout);
9440 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9441 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9443 /* If this index value is greater than the size of the symbols
9444 array, break to avoid an out-of-bounds read. */
9445 if ((unsigned long)(cnt + j) >= num_syms)
9447 warn (_("invalid index into symbol array\n"));
9453 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9454 || section_headers[symbols[cnt + j].st_shndx].sh_type
9457 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9464 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9466 Elf_Internal_Verneed ivn;
9467 unsigned long offset;
9469 offset = offset_from_vma
9470 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9471 sizeof (Elf_External_Verneed));
9475 Elf_Internal_Vernaux ivna;
9476 Elf_External_Verneed evn;
9477 Elf_External_Vernaux evna;
9478 unsigned long a_off;
9480 if (get_data (&evn, file, offset, sizeof (evn), 1,
9481 _("version need")) == NULL)
9484 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9485 ivn.vn_next = BYTE_GET (evn.vn_next);
9487 a_off = offset + ivn.vn_aux;
9491 if (get_data (&evna, file, a_off, sizeof (evna),
9492 1, _("version need aux (2)")) == NULL)
9499 ivna.vna_next = BYTE_GET (evna.vna_next);
9500 ivna.vna_other = BYTE_GET (evna.vna_other);
9503 a_off += ivna.vna_next;
9505 while (ivna.vna_other != data[cnt + j]
9506 && ivna.vna_next != 0);
9508 if (ivna.vna_other == data[cnt + j])
9510 ivna.vna_name = BYTE_GET (evna.vna_name);
9512 if (ivna.vna_name >= string_sec->sh_size)
9513 name = _("*invalid*");
9515 name = strtab + ivna.vna_name;
9516 nn += printf ("(%s%-*s",
9518 12 - (int) strlen (name),
9524 offset += ivn.vn_next;
9526 while (ivn.vn_next);
9529 if (check_def && data[cnt + j] != 0x8001
9530 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9532 Elf_Internal_Verdef ivd;
9533 Elf_External_Verdef evd;
9534 unsigned long offset;
9536 offset = offset_from_vma
9537 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9542 if (get_data (&evd, file, offset, sizeof (evd), 1,
9543 _("version def")) == NULL)
9546 /* PR 17531: file: 046-1082287-0.004. */
9547 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9552 ivd.vd_next = BYTE_GET (evd.vd_next);
9553 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9556 offset += ivd.vd_next;
9558 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9559 && ivd.vd_next != 0);
9561 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9563 Elf_External_Verdaux evda;
9564 Elf_Internal_Verdaux ivda;
9566 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9568 if (get_data (&evda, file,
9569 offset - ivd.vd_next + ivd.vd_aux,
9571 _("version def aux")) == NULL)
9574 ivda.vda_name = BYTE_GET (evda.vda_name);
9576 if (ivda.vda_name >= string_sec->sh_size)
9577 name = _("*invalid*");
9579 name = strtab + ivda.vda_name;
9580 nn += printf ("(%s%-*s",
9582 12 - (int) strlen (name),
9588 printf ("%*c", 18 - nn, ' ');
9606 printf (_("\nNo version information found in this file.\n"));
9612 get_symbol_binding (unsigned int binding)
9614 static char buff[32];
9618 case STB_LOCAL: return "LOCAL";
9619 case STB_GLOBAL: return "GLOBAL";
9620 case STB_WEAK: return "WEAK";
9622 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9623 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9625 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9627 if (binding == STB_GNU_UNIQUE
9628 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9629 /* GNU is still using the default value 0. */
9630 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9632 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9635 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9641 get_symbol_type (unsigned int type)
9643 static char buff[32];
9647 case STT_NOTYPE: return "NOTYPE";
9648 case STT_OBJECT: return "OBJECT";
9649 case STT_FUNC: return "FUNC";
9650 case STT_SECTION: return "SECTION";
9651 case STT_FILE: return "FILE";
9652 case STT_COMMON: return "COMMON";
9653 case STT_TLS: return "TLS";
9654 case STT_RELC: return "RELC";
9655 case STT_SRELC: return "SRELC";
9657 if (type >= STT_LOPROC && type <= STT_HIPROC)
9659 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9660 return "THUMB_FUNC";
9662 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9665 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9666 return "PARISC_MILLI";
9668 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9670 else if (type >= STT_LOOS && type <= STT_HIOS)
9672 if (elf_header.e_machine == EM_PARISC)
9674 if (type == STT_HP_OPAQUE)
9676 if (type == STT_HP_STUB)
9680 if (type == STT_GNU_IFUNC
9681 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9682 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9683 /* GNU is still using the default value 0. */
9684 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9687 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9690 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9696 get_symbol_visibility (unsigned int visibility)
9700 case STV_DEFAULT: return "DEFAULT";
9701 case STV_INTERNAL: return "INTERNAL";
9702 case STV_HIDDEN: return "HIDDEN";
9703 case STV_PROTECTED: return "PROTECTED";
9709 get_mips_symbol_other (unsigned int other)
9721 case STO_MICROMIPS | STO_MIPS_PIC:
9722 return "MICROMIPS, MIPS PIC";
9731 get_ia64_symbol_other (unsigned int other)
9735 static char res[32];
9739 /* Function types is for images and .STB files only. */
9740 switch (elf_header.e_type)
9744 switch (VMS_ST_FUNC_TYPE (other))
9746 case VMS_SFT_CODE_ADDR:
9747 strcat (res, " CA");
9749 case VMS_SFT_SYMV_IDX:
9750 strcat (res, " VEC");
9753 strcat (res, " FD");
9755 case VMS_SFT_RESERVE:
9756 strcat (res, " RSV");
9765 switch (VMS_ST_LINKAGE (other))
9767 case VMS_STL_IGNORE:
9768 strcat (res, " IGN");
9770 case VMS_STL_RESERVE:
9771 strcat (res, " RSV");
9774 strcat (res, " STD");
9777 strcat (res, " LNK");
9792 get_ppc64_symbol_other (unsigned int other)
9794 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9796 static char buf[32];
9797 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9798 PPC64_LOCAL_ENTRY_OFFSET (other));
9805 get_symbol_other (unsigned int other)
9807 const char * result = NULL;
9808 static char buff [32];
9813 switch (elf_header.e_machine)
9816 result = get_mips_symbol_other (other);
9819 result = get_ia64_symbol_other (other);
9822 result = get_ppc64_symbol_other (other);
9831 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9836 get_symbol_index_type (unsigned int type)
9838 static char buff[32];
9842 case SHN_UNDEF: return "UND";
9843 case SHN_ABS: return "ABS";
9844 case SHN_COMMON: return "COM";
9846 if (type == SHN_IA_64_ANSI_COMMON
9847 && elf_header.e_machine == EM_IA_64
9848 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9850 else if ((elf_header.e_machine == EM_X86_64
9851 || elf_header.e_machine == EM_L1OM
9852 || elf_header.e_machine == EM_K1OM)
9853 && type == SHN_X86_64_LCOMMON)
9855 else if ((type == SHN_MIPS_SCOMMON
9856 && elf_header.e_machine == EM_MIPS)
9857 || (type == SHN_TIC6X_SCOMMON
9858 && elf_header.e_machine == EM_TI_C6000))
9860 else if (type == SHN_MIPS_SUNDEFINED
9861 && elf_header.e_machine == EM_MIPS)
9863 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9864 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9865 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9866 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9867 else if (type >= SHN_LORESERVE)
9868 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9869 else if (type >= elf_header.e_shnum)
9870 sprintf (buff, _("bad section index[%3d]"), type);
9872 sprintf (buff, "%3d", type);
9880 get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
9882 unsigned char * e_data;
9885 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9886 attempting to allocate memory when the read is bound to fail. */
9887 if (ent_size * number > current_file_size)
9889 error (_("Invalid number of dynamic entries: %lu\n"),
9890 (unsigned long) number);
9894 e_data = (unsigned char *) cmalloc (number, ent_size);
9897 error (_("Out of memory reading %lu dynamic entries\n"),
9898 (unsigned long) number);
9902 if (fread (e_data, ent_size, number, file) != number)
9904 error (_("Unable to read in %lu bytes of dynamic data\n"),
9905 (unsigned long) (number * ent_size));
9910 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9913 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9914 (unsigned long) number);
9920 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9928 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9930 Elf_Internal_Sym * psym;
9933 n = print_vma (si, DEC_5);
9935 fputs (&" "[n], stdout);
9936 printf (" %3lu: ", hn);
9938 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9940 printf (_("<No info available for dynamic symbol number %lu>\n"),
9941 (unsigned long) si);
9945 psym = dynamic_symbols + si;
9946 print_vma (psym->st_value, LONG_HEX);
9948 print_vma (psym->st_size, DEC_5);
9950 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9951 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9952 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9953 /* Check to see if any other bits in the st_other field are set.
9954 Note - displaying this information disrupts the layout of the
9955 table being generated, but for the moment this case is very
9957 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9958 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9959 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9960 if (VALID_DYNAMIC_NAME (psym->st_name))
9961 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9963 printf (_(" <corrupt: %14ld>"), psym->st_name);
9968 get_symbol_version_string (FILE *file, int is_dynsym,
9970 unsigned long int strtab_size,
9971 unsigned int si, Elf_Internal_Sym *psym,
9972 enum versioned_symbol_info *sym_info,
9973 unsigned short *vna_other)
9975 const char *version_string = NULL;
9978 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9980 unsigned char data[2];
9981 unsigned short vers_data;
9982 unsigned long offset;
9986 offset = offset_from_vma
9987 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9988 sizeof data + si * sizeof (vers_data));
9990 if (get_data (&data, file, offset + si * sizeof (vers_data),
9991 sizeof (data), 1, _("version data")) == NULL)
9994 vers_data = byte_get (data, 2);
9996 is_nobits = (psym->st_shndx < elf_header.e_shnum
9997 && section_headers[psym->st_shndx].sh_type
10000 check_def = (psym->st_shndx != SHN_UNDEF);
10002 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10004 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10005 && (is_nobits || ! check_def))
10007 Elf_External_Verneed evn;
10008 Elf_Internal_Verneed ivn;
10009 Elf_Internal_Vernaux ivna;
10011 /* We must test both. */
10012 offset = offset_from_vma
10013 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10018 unsigned long vna_off;
10020 if (get_data (&evn, file, offset, sizeof (evn), 1,
10021 _("version need")) == NULL)
10024 ivna.vna_other = 0;
10029 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10030 ivn.vn_next = BYTE_GET (evn.vn_next);
10032 vna_off = offset + ivn.vn_aux;
10036 Elf_External_Vernaux evna;
10038 if (get_data (&evna, file, vna_off,
10040 _("version need aux (3)")) == NULL)
10043 ivna.vna_other = 0;
10048 ivna.vna_other = BYTE_GET (evna.vna_other);
10049 ivna.vna_next = BYTE_GET (evna.vna_next);
10050 ivna.vna_name = BYTE_GET (evna.vna_name);
10053 vna_off += ivna.vna_next;
10055 while (ivna.vna_other != vers_data
10056 && ivna.vna_next != 0);
10058 if (ivna.vna_other == vers_data)
10061 offset += ivn.vn_next;
10063 while (ivn.vn_next != 0);
10065 if (ivna.vna_other == vers_data)
10067 *sym_info = symbol_undefined;
10068 *vna_other = ivna.vna_other;
10069 version_string = (ivna.vna_name < strtab_size
10070 ? strtab + ivna.vna_name
10074 else if (! is_nobits)
10075 error (_("bad dynamic symbol\n"));
10082 if (vers_data != 0x8001
10083 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10085 Elf_Internal_Verdef ivd;
10086 Elf_Internal_Verdaux ivda;
10087 Elf_External_Verdaux evda;
10090 off = offset_from_vma
10092 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10093 sizeof (Elf_External_Verdef));
10097 Elf_External_Verdef evd;
10099 if (get_data (&evd, file, off, sizeof (evd),
10100 1, _("version def")) == NULL)
10108 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10109 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10110 ivd.vd_next = BYTE_GET (evd.vd_next);
10113 off += ivd.vd_next;
10115 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10116 && ivd.vd_next != 0);
10118 off -= ivd.vd_next;
10121 if (get_data (&evda, file, off, sizeof (evda),
10122 1, _("version def aux")) == NULL)
10123 return version_string;
10125 ivda.vda_name = BYTE_GET (evda.vda_name);
10127 if (psym->st_name != ivda.vda_name)
10129 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10130 ? symbol_hidden : symbol_public);
10131 version_string = (ivda.vda_name < strtab_size
10132 ? strtab + ivda.vda_name
10139 return version_string;
10142 /* Dump the symbol table. */
10144 process_symbol_table (FILE * file)
10146 Elf_Internal_Shdr * section;
10147 bfd_size_type nbuckets = 0;
10148 bfd_size_type nchains = 0;
10149 bfd_vma * buckets = NULL;
10150 bfd_vma * chains = NULL;
10151 bfd_vma ngnubuckets = 0;
10152 bfd_vma * gnubuckets = NULL;
10153 bfd_vma * gnuchains = NULL;
10154 bfd_vma gnusymidx = 0;
10155 bfd_size_type ngnuchains = 0;
10157 if (!do_syms && !do_dyn_syms && !do_histogram)
10160 if (dynamic_info[DT_HASH]
10162 || (do_using_dynamic
10164 && dynamic_strings != NULL)))
10166 unsigned char nb[8];
10167 unsigned char nc[8];
10168 unsigned int hash_ent_size = 4;
10170 if ((elf_header.e_machine == EM_ALPHA
10171 || elf_header.e_machine == EM_S390
10172 || elf_header.e_machine == EM_S390_OLD)
10173 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10177 (archive_file_offset
10178 + offset_from_vma (file, dynamic_info[DT_HASH],
10179 sizeof nb + sizeof nc)),
10182 error (_("Unable to seek to start of dynamic information\n"));
10186 if (fread (nb, hash_ent_size, 1, file) != 1)
10188 error (_("Failed to read in number of buckets\n"));
10192 if (fread (nc, hash_ent_size, 1, file) != 1)
10194 error (_("Failed to read in number of chains\n"));
10198 nbuckets = byte_get (nb, hash_ent_size);
10199 nchains = byte_get (nc, hash_ent_size);
10201 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10202 chains = get_dynamic_data (file, nchains, hash_ent_size);
10205 if (buckets == NULL || chains == NULL)
10207 if (do_using_dynamic)
10218 if (dynamic_info_DT_GNU_HASH
10220 || (do_using_dynamic
10222 && dynamic_strings != NULL)))
10224 unsigned char nb[16];
10225 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10226 bfd_vma buckets_vma;
10229 (archive_file_offset
10230 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10234 error (_("Unable to seek to start of dynamic information\n"));
10238 if (fread (nb, 16, 1, file) != 1)
10240 error (_("Failed to read in number of buckets\n"));
10244 ngnubuckets = byte_get (nb, 4);
10245 gnusymidx = byte_get (nb + 4, 4);
10246 bitmaskwords = byte_get (nb + 8, 4);
10247 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10249 buckets_vma += bitmaskwords * 4;
10251 buckets_vma += bitmaskwords * 8;
10254 (archive_file_offset
10255 + offset_from_vma (file, buckets_vma, 4)),
10258 error (_("Unable to seek to start of dynamic information\n"));
10262 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10264 if (gnubuckets == NULL)
10267 for (i = 0; i < ngnubuckets; i++)
10268 if (gnubuckets[i] != 0)
10270 if (gnubuckets[i] < gnusymidx)
10273 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10274 maxchain = gnubuckets[i];
10277 if (maxchain == 0xffffffff)
10280 maxchain -= gnusymidx;
10283 (archive_file_offset
10284 + offset_from_vma (file, buckets_vma
10285 + 4 * (ngnubuckets + maxchain), 4)),
10288 error (_("Unable to seek to start of dynamic information\n"));
10294 if (fread (nb, 4, 1, file) != 1)
10296 error (_("Failed to determine last chain length\n"));
10300 if (maxchain + 1 == 0)
10305 while ((byte_get (nb, 4) & 1) == 0);
10308 (archive_file_offset
10309 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10312 error (_("Unable to seek to start of dynamic information\n"));
10316 gnuchains = get_dynamic_data (file, maxchain, 4);
10317 ngnuchains = maxchain;
10320 if (gnuchains == NULL)
10325 if (do_using_dynamic)
10330 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10332 && do_using_dynamic
10333 && dynamic_strings != NULL
10334 && dynamic_symbols != NULL)
10338 if (dynamic_info[DT_HASH])
10342 printf (_("\nSymbol table for image:\n"));
10344 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10346 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10348 for (hn = 0; hn < nbuckets; hn++)
10353 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10354 print_dynamic_symbol (si, hn);
10358 if (dynamic_info_DT_GNU_HASH)
10360 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10362 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10364 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10366 for (hn = 0; hn < ngnubuckets; ++hn)
10367 if (gnubuckets[hn] != 0)
10369 bfd_vma si = gnubuckets[hn];
10370 bfd_vma off = si - gnusymidx;
10374 print_dynamic_symbol (si, hn);
10377 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10381 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10382 && section_headers != NULL)
10386 for (i = 0, section = section_headers;
10387 i < elf_header.e_shnum;
10391 char * strtab = NULL;
10392 unsigned long int strtab_size = 0;
10393 Elf_Internal_Sym * symtab;
10394 Elf_Internal_Sym * psym;
10395 unsigned long num_syms;
10397 if ((section->sh_type != SHT_SYMTAB
10398 && section->sh_type != SHT_DYNSYM)
10400 && section->sh_type == SHT_SYMTAB))
10403 if (section->sh_entsize == 0)
10405 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10406 printable_section_name (section));
10410 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10411 printable_section_name (section),
10412 (unsigned long) (section->sh_size / section->sh_entsize));
10415 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10417 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10419 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10420 if (symtab == NULL)
10423 if (section->sh_link == elf_header.e_shstrndx)
10425 strtab = string_table;
10426 strtab_size = string_table_length;
10428 else if (section->sh_link < elf_header.e_shnum)
10430 Elf_Internal_Shdr * string_sec;
10432 string_sec = section_headers + section->sh_link;
10434 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10435 1, string_sec->sh_size,
10436 _("string table"));
10437 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10440 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10442 const char *version_string;
10443 enum versioned_symbol_info sym_info;
10444 unsigned short vna_other;
10446 printf ("%6d: ", si);
10447 print_vma (psym->st_value, LONG_HEX);
10449 print_vma (psym->st_size, DEC_5);
10450 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10451 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10452 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10453 /* Check to see if any other bits in the st_other field are set.
10454 Note - displaying this information disrupts the layout of the
10455 table being generated, but for the moment this case is very rare. */
10456 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10457 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10458 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10459 print_symbol (25, psym->st_name < strtab_size
10460 ? strtab + psym->st_name : _("<corrupt>"));
10463 = get_symbol_version_string (file,
10464 section->sh_type == SHT_DYNSYM,
10465 strtab, strtab_size, si,
10466 psym, &sym_info, &vna_other);
10467 if (version_string)
10469 if (sym_info == symbol_undefined)
10470 printf ("@%s (%d)", version_string, vna_other);
10472 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10480 if (strtab != string_table)
10486 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10488 if (do_histogram && buckets != NULL)
10490 unsigned long * lengths;
10491 unsigned long * counts;
10494 unsigned long maxlength = 0;
10495 unsigned long nzero_counts = 0;
10496 unsigned long nsyms = 0;
10498 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10499 (unsigned long) nbuckets);
10501 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10502 if (lengths == NULL)
10504 error (_("Out of memory allocating space for histogram buckets\n"));
10508 printf (_(" Length Number %% of total Coverage\n"));
10509 for (hn = 0; hn < nbuckets; ++hn)
10511 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10514 if (maxlength < ++lengths[hn])
10517 /* PR binutils/17531: A corrupt binary could contain broken
10518 histogram data. Do not go into an infinite loop trying
10520 if (chains[si] == si)
10522 error (_("histogram chain links to itself\n"));
10528 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10529 if (counts == NULL)
10532 error (_("Out of memory allocating space for histogram counts\n"));
10536 for (hn = 0; hn < nbuckets; ++hn)
10537 ++counts[lengths[hn]];
10542 printf (" 0 %-10lu (%5.1f%%)\n",
10543 counts[0], (counts[0] * 100.0) / nbuckets);
10544 for (i = 1; i <= maxlength; ++i)
10546 nzero_counts += counts[i] * i;
10547 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10548 i, counts[i], (counts[i] * 100.0) / nbuckets,
10549 (nzero_counts * 100.0) / nsyms);
10557 if (buckets != NULL)
10563 if (do_histogram && gnubuckets != NULL)
10565 unsigned long * lengths;
10566 unsigned long * counts;
10568 unsigned long maxlength = 0;
10569 unsigned long nzero_counts = 0;
10570 unsigned long nsyms = 0;
10572 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10573 (unsigned long) ngnubuckets);
10575 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10576 if (lengths == NULL)
10578 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10582 printf (_(" Length Number %% of total Coverage\n"));
10584 for (hn = 0; hn < ngnubuckets; ++hn)
10585 if (gnubuckets[hn] != 0)
10587 bfd_vma off, length = 1;
10589 for (off = gnubuckets[hn] - gnusymidx;
10590 /* PR 17531 file: 010-77222-0.004. */
10591 off < ngnuchains && (gnuchains[off] & 1) == 0;
10594 lengths[hn] = length;
10595 if (length > maxlength)
10596 maxlength = length;
10600 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10601 if (counts == NULL)
10604 error (_("Out of memory allocating space for gnu histogram counts\n"));
10608 for (hn = 0; hn < ngnubuckets; ++hn)
10609 ++counts[lengths[hn]];
10611 if (ngnubuckets > 0)
10614 printf (" 0 %-10lu (%5.1f%%)\n",
10615 counts[0], (counts[0] * 100.0) / ngnubuckets);
10616 for (j = 1; j <= maxlength; ++j)
10618 nzero_counts += counts[j] * j;
10619 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10620 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10621 (nzero_counts * 100.0) / nsyms);
10635 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10639 if (dynamic_syminfo == NULL
10641 /* No syminfo, this is ok. */
10644 /* There better should be a dynamic symbol section. */
10645 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10649 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10650 dynamic_syminfo_offset, dynamic_syminfo_nent);
10652 printf (_(" Num: Name BoundTo Flags\n"));
10653 for (i = 0; i < dynamic_syminfo_nent; ++i)
10655 unsigned short int flags = dynamic_syminfo[i].si_flags;
10657 printf ("%4d: ", i);
10658 if (i >= num_dynamic_syms)
10659 printf (_("<corrupt index>"));
10660 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10661 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10663 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10666 switch (dynamic_syminfo[i].si_boundto)
10668 case SYMINFO_BT_SELF:
10669 fputs ("SELF ", stdout);
10671 case SYMINFO_BT_PARENT:
10672 fputs ("PARENT ", stdout);
10675 if (dynamic_syminfo[i].si_boundto > 0
10676 && dynamic_syminfo[i].si_boundto < dynamic_nent
10677 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10679 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10683 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10687 if (flags & SYMINFO_FLG_DIRECT)
10688 printf (" DIRECT");
10689 if (flags & SYMINFO_FLG_PASSTHRU)
10690 printf (" PASSTHRU");
10691 if (flags & SYMINFO_FLG_COPY)
10693 if (flags & SYMINFO_FLG_LAZYLOAD)
10694 printf (" LAZYLOAD");
10702 /* Check to see if the given reloc needs to be handled in a target specific
10703 manner. If so then process the reloc and return TRUE otherwise return
10707 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10708 unsigned char * start,
10709 Elf_Internal_Sym * symtab)
10711 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10713 switch (elf_header.e_machine)
10716 case EM_MSP430_OLD:
10718 static Elf_Internal_Sym * saved_sym = NULL;
10720 switch (reloc_type)
10722 case 10: /* R_MSP430_SYM_DIFF */
10723 if (uses_msp430x_relocs ())
10725 case 21: /* R_MSP430X_SYM_DIFF */
10726 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10729 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10730 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10731 goto handle_sym_diff;
10733 case 5: /* R_MSP430_16_BYTE */
10734 case 9: /* R_MSP430_8 */
10735 if (uses_msp430x_relocs ())
10737 goto handle_sym_diff;
10739 case 2: /* R_MSP430_ABS16 */
10740 case 15: /* R_MSP430X_ABS16 */
10741 if (! uses_msp430x_relocs ())
10743 goto handle_sym_diff;
10746 if (saved_sym != NULL)
10750 value = reloc->r_addend
10751 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10752 - saved_sym->st_value);
10754 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10762 if (saved_sym != NULL)
10763 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10770 case EM_CYGNUS_MN10300:
10772 static Elf_Internal_Sym * saved_sym = NULL;
10774 switch (reloc_type)
10776 case 34: /* R_MN10300_ALIGN */
10778 case 33: /* R_MN10300_SYM_DIFF */
10779 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10781 case 1: /* R_MN10300_32 */
10782 case 2: /* R_MN10300_16 */
10783 if (saved_sym != NULL)
10787 value = reloc->r_addend
10788 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10789 - saved_sym->st_value);
10791 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10798 if (saved_sym != NULL)
10799 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10809 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10810 DWARF debug sections. This is a target specific test. Note - we do not
10811 go through the whole including-target-headers-multiple-times route, (as
10812 we have already done with <elf/h8.h>) because this would become very
10813 messy and even then this function would have to contain target specific
10814 information (the names of the relocs instead of their numeric values).
10815 FIXME: This is not the correct way to solve this problem. The proper way
10816 is to have target specific reloc sizing and typing functions created by
10817 the reloc-macros.h header, in the same way that it already creates the
10818 reloc naming functions. */
10821 is_32bit_abs_reloc (unsigned int reloc_type)
10823 switch (elf_header.e_machine)
10827 return reloc_type == 1; /* R_386_32. */
10829 return reloc_type == 1; /* R_68K_32. */
10831 return reloc_type == 1; /* R_860_32. */
10833 return reloc_type == 2; /* R_960_32. */
10835 return reloc_type == 258; /* R_AARCH64_ABS32 */
10837 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10839 return reloc_type == 1; /* R_ARC_32. */
10841 return reloc_type == 2; /* R_ARM_ABS32 */
10844 return reloc_type == 1;
10845 case EM_ADAPTEVA_EPIPHANY:
10846 return reloc_type == 3;
10848 return reloc_type == 0x12; /* R_byte4_data. */
10850 return reloc_type == 3; /* R_CRIS_32. */
10852 return reloc_type == 3; /* R_CR16_NUM32. */
10854 return reloc_type == 15; /* R_CRX_NUM32. */
10855 case EM_CYGNUS_FRV:
10856 return reloc_type == 1;
10857 case EM_CYGNUS_D10V:
10859 return reloc_type == 6; /* R_D10V_32. */
10860 case EM_CYGNUS_D30V:
10862 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10864 return reloc_type == 3; /* R_DLX_RELOC_32. */
10865 case EM_CYGNUS_FR30:
10867 return reloc_type == 3; /* R_FR30_32. */
10871 return reloc_type == 1; /* R_H8_DIR32. */
10873 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10876 return reloc_type == 2; /* R_IP2K_32. */
10878 return reloc_type == 2; /* R_IQ2000_32. */
10879 case EM_LATTICEMICO32:
10880 return reloc_type == 3; /* R_LM32_32. */
10883 return reloc_type == 3; /* R_M32C_32. */
10885 return reloc_type == 34; /* R_M32R_32_RELA. */
10887 return reloc_type == 1; /* R_MCORE_ADDR32. */
10888 case EM_CYGNUS_MEP:
10889 return reloc_type == 4; /* R_MEP_32. */
10891 return reloc_type == 2; /* R_METAG_ADDR32. */
10892 case EM_MICROBLAZE:
10893 return reloc_type == 1; /* R_MICROBLAZE_32. */
10895 return reloc_type == 2; /* R_MIPS_32. */
10897 return reloc_type == 4; /* R_MMIX_32. */
10898 case EM_CYGNUS_MN10200:
10900 return reloc_type == 1; /* R_MN10200_32. */
10901 case EM_CYGNUS_MN10300:
10903 return reloc_type == 1; /* R_MN10300_32. */
10905 return reloc_type == 1; /* R_MOXIE_32. */
10906 case EM_MSP430_OLD:
10908 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10910 return reloc_type == 2; /* R_MT_32. */
10912 return reloc_type == 20; /* R_NDS32_RELA. */
10913 case EM_ALTERA_NIOS2:
10914 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
10916 return reloc_type == 1; /* R_NIOS_32. */
10918 return reloc_type == 1; /* R_OR1K_32. */
10920 return (reloc_type == 1 /* R_PARISC_DIR32. */
10921 || reloc_type == 41); /* R_PARISC_SECREL32. */
10924 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10926 return reloc_type == 1; /* R_PPC64_ADDR32. */
10928 return reloc_type == 1; /* R_PPC_ADDR32. */
10930 return reloc_type == 1; /* R_RL78_DIR32. */
10932 return reloc_type == 1; /* R_RX_DIR32. */
10934 return reloc_type == 1; /* R_I370_ADDR31. */
10937 return reloc_type == 4; /* R_S390_32. */
10939 return reloc_type == 8; /* R_SCORE_ABS32. */
10941 return reloc_type == 1; /* R_SH_DIR32. */
10942 case EM_SPARC32PLUS:
10945 return reloc_type == 3 /* R_SPARC_32. */
10946 || reloc_type == 23; /* R_SPARC_UA32. */
10948 return reloc_type == 6; /* R_SPU_ADDR32 */
10950 return reloc_type == 1; /* R_C6000_ABS32. */
10952 return reloc_type == 2; /* R_TILEGX_32. */
10954 return reloc_type == 1; /* R_TILEPRO_32. */
10955 case EM_CYGNUS_V850:
10957 return reloc_type == 6; /* R_V850_ABS32. */
10959 return reloc_type == 0x33; /* R_V810_WORD. */
10961 return reloc_type == 1; /* R_VAX_32. */
10965 return reloc_type == 10; /* R_X86_64_32. */
10968 return reloc_type == 3; /* R_XC16C_ABS_32. */
10970 return reloc_type == 4; /* R_XGATE_32. */
10972 return reloc_type == 1; /* R_XSTROMY16_32. */
10973 case EM_XTENSA_OLD:
10975 return reloc_type == 1; /* R_XTENSA_32. */
10977 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10978 elf_header.e_machine);
10983 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10984 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10987 is_32bit_pcrel_reloc (unsigned int reloc_type)
10989 switch (elf_header.e_machine)
10993 return reloc_type == 2; /* R_386_PC32. */
10995 return reloc_type == 4; /* R_68K_PC32. */
10997 return reloc_type == 261; /* R_AARCH64_PREL32 */
10998 case EM_ADAPTEVA_EPIPHANY:
10999 return reloc_type == 6;
11001 return reloc_type == 10; /* R_ALPHA_SREL32. */
11003 return reloc_type == 3; /* R_ARM_REL32 */
11004 case EM_MICROBLAZE:
11005 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11007 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11009 return reloc_type == 9; /* R_PARISC_PCREL32. */
11011 return reloc_type == 26; /* R_PPC_REL32. */
11013 return reloc_type == 26; /* R_PPC64_REL32. */
11016 return reloc_type == 5; /* R_390_PC32. */
11018 return reloc_type == 2; /* R_SH_REL32. */
11019 case EM_SPARC32PLUS:
11022 return reloc_type == 6; /* R_SPARC_DISP32. */
11024 return reloc_type == 13; /* R_SPU_REL32. */
11026 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11028 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11032 return reloc_type == 2; /* R_X86_64_PC32. */
11033 case EM_XTENSA_OLD:
11035 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11037 /* Do not abort or issue an error message here. Not all targets use
11038 pc-relative 32-bit relocs in their DWARF debug information and we
11039 have already tested for target coverage in is_32bit_abs_reloc. A
11040 more helpful warning message will be generated by apply_relocations
11041 anyway, so just return. */
11046 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11047 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11050 is_64bit_abs_reloc (unsigned int reloc_type)
11052 switch (elf_header.e_machine)
11055 return reloc_type == 257; /* R_AARCH64_ABS64. */
11057 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11059 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11061 return reloc_type == 80; /* R_PARISC_DIR64. */
11063 return reloc_type == 38; /* R_PPC64_ADDR64. */
11064 case EM_SPARC32PLUS:
11067 return reloc_type == 54; /* R_SPARC_UA64. */
11071 return reloc_type == 1; /* R_X86_64_64. */
11074 return reloc_type == 22; /* R_S390_64. */
11076 return reloc_type == 1; /* R_TILEGX_64. */
11078 return reloc_type == 18; /* R_MIPS_64. */
11084 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11085 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11088 is_64bit_pcrel_reloc (unsigned int reloc_type)
11090 switch (elf_header.e_machine)
11093 return reloc_type == 260; /* R_AARCH64_PREL64. */
11095 return reloc_type == 11; /* R_ALPHA_SREL64. */
11097 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11099 return reloc_type == 72; /* R_PARISC_PCREL64. */
11101 return reloc_type == 44; /* R_PPC64_REL64. */
11102 case EM_SPARC32PLUS:
11105 return reloc_type == 46; /* R_SPARC_DISP64. */
11109 return reloc_type == 24; /* R_X86_64_PC64. */
11112 return reloc_type == 23; /* R_S390_PC64. */
11114 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11120 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11121 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11124 is_24bit_abs_reloc (unsigned int reloc_type)
11126 switch (elf_header.e_machine)
11128 case EM_CYGNUS_MN10200:
11130 return reloc_type == 4; /* R_MN10200_24. */
11136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11137 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11140 is_16bit_abs_reloc (unsigned int reloc_type)
11142 switch (elf_header.e_machine)
11146 return reloc_type == 4; /* R_AVR_16. */
11147 case EM_ADAPTEVA_EPIPHANY:
11148 return reloc_type == 5;
11149 case EM_CYGNUS_D10V:
11151 return reloc_type == 3; /* R_D10V_16. */
11155 return reloc_type == R_H8_DIR16;
11158 return reloc_type == 1; /* R_IP2K_16. */
11161 return reloc_type == 1; /* R_M32C_16 */
11163 if (uses_msp430x_relocs ())
11164 return reloc_type == 2; /* R_MSP430_ABS16. */
11165 case EM_MSP430_OLD:
11166 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11168 return reloc_type == 19; /* R_NDS32_RELA. */
11169 case EM_ALTERA_NIOS2:
11170 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11172 return reloc_type == 9; /* R_NIOS_16. */
11174 return reloc_type == 2; /* R_OR1K_16. */
11176 return reloc_type == 2; /* R_C6000_ABS16. */
11179 return reloc_type == 2; /* R_XC16C_ABS_16. */
11180 case EM_CYGNUS_MN10200:
11182 return reloc_type == 2; /* R_MN10200_16. */
11183 case EM_CYGNUS_MN10300:
11185 return reloc_type == 2; /* R_MN10300_16. */
11187 return reloc_type == 3; /* R_XGATE_16. */
11193 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11194 relocation entries (possibly formerly used for SHT_GROUP sections). */
11197 is_none_reloc (unsigned int reloc_type)
11199 switch (elf_header.e_machine)
11201 case EM_68K: /* R_68K_NONE. */
11202 case EM_386: /* R_386_NONE. */
11203 case EM_SPARC32PLUS:
11205 case EM_SPARC: /* R_SPARC_NONE. */
11206 case EM_MIPS: /* R_MIPS_NONE. */
11207 case EM_PARISC: /* R_PARISC_NONE. */
11208 case EM_ALPHA: /* R_ALPHA_NONE. */
11209 case EM_ADAPTEVA_EPIPHANY:
11210 case EM_PPC: /* R_PPC_NONE. */
11211 case EM_PPC64: /* R_PPC64_NONE. */
11212 case EM_ARM: /* R_ARM_NONE. */
11213 case EM_IA_64: /* R_IA64_NONE. */
11214 case EM_SH: /* R_SH_NONE. */
11216 case EM_S390: /* R_390_NONE. */
11217 case EM_CRIS: /* R_CRIS_NONE. */
11218 case EM_X86_64: /* R_X86_64_NONE. */
11219 case EM_L1OM: /* R_X86_64_NONE. */
11220 case EM_K1OM: /* R_X86_64_NONE. */
11221 case EM_MN10300: /* R_MN10300_NONE. */
11222 case EM_MOXIE: /* R_MOXIE_NONE. */
11223 case EM_M32R: /* R_M32R_NONE. */
11224 case EM_TI_C6000:/* R_C6000_NONE. */
11225 case EM_TILEGX: /* R_TILEGX_NONE. */
11226 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11228 case EM_C166: /* R_XC16X_NONE. */
11229 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11230 case EM_NIOS32: /* R_NIOS_NONE. */
11231 case EM_OR1K: /* R_OR1K_NONE. */
11232 return reloc_type == 0;
11234 return reloc_type == 0 || reloc_type == 256;
11236 return (reloc_type == 0 /* R_XTENSA_NONE. */
11237 || reloc_type == 204 /* R_NDS32_DIFF8. */
11238 || reloc_type == 205 /* R_NDS32_DIFF16. */
11239 || reloc_type == 206 /* R_NDS32_DIFF32. */
11240 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11241 case EM_XTENSA_OLD:
11243 return (reloc_type == 0 /* R_XTENSA_NONE. */
11244 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11245 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11246 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11248 return reloc_type == 3; /* R_METAG_NONE. */
11253 /* Apply relocations to a section.
11254 Note: So far support has been added only for those relocations
11255 which can be found in debug sections.
11256 FIXME: Add support for more relocations ? */
11259 apply_relocations (void * file,
11260 Elf_Internal_Shdr * section,
11261 unsigned char * start)
11263 Elf_Internal_Shdr * relsec;
11264 unsigned char * end = start + section->sh_size;
11266 if (elf_header.e_type != ET_REL)
11269 /* Find the reloc section associated with the section. */
11270 for (relsec = section_headers;
11271 relsec < section_headers + elf_header.e_shnum;
11274 bfd_boolean is_rela;
11275 unsigned long num_relocs;
11276 Elf_Internal_Rela * relocs;
11277 Elf_Internal_Rela * rp;
11278 Elf_Internal_Shdr * symsec;
11279 Elf_Internal_Sym * symtab;
11280 unsigned long num_syms;
11281 Elf_Internal_Sym * sym;
11283 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11284 || relsec->sh_info >= elf_header.e_shnum
11285 || section_headers + relsec->sh_info != section
11286 || relsec->sh_size == 0
11287 || relsec->sh_link >= elf_header.e_shnum)
11290 is_rela = relsec->sh_type == SHT_RELA;
11294 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11295 relsec->sh_size, & relocs, & num_relocs))
11300 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11301 relsec->sh_size, & relocs, & num_relocs))
11305 /* SH uses RELA but uses in place value instead of the addend field. */
11306 if (elf_header.e_machine == EM_SH)
11309 symsec = section_headers + relsec->sh_link;
11310 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11312 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11315 unsigned int reloc_type;
11316 unsigned int reloc_size;
11317 unsigned char * rloc;
11318 unsigned long sym_index;
11320 reloc_type = get_reloc_type (rp->r_info);
11322 if (target_specific_reloc_handling (rp, start, symtab))
11324 else if (is_none_reloc (reloc_type))
11326 else if (is_32bit_abs_reloc (reloc_type)
11327 || is_32bit_pcrel_reloc (reloc_type))
11329 else if (is_64bit_abs_reloc (reloc_type)
11330 || is_64bit_pcrel_reloc (reloc_type))
11332 else if (is_24bit_abs_reloc (reloc_type))
11334 else if (is_16bit_abs_reloc (reloc_type))
11338 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11339 reloc_type, printable_section_name (section));
11343 rloc = start + rp->r_offset;
11344 if ((rloc + reloc_size) > end || (rloc < start))
11346 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11347 (unsigned long) rp->r_offset,
11348 printable_section_name (section));
11352 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11353 if (sym_index >= num_syms)
11355 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11356 sym_index, printable_section_name (section));
11359 sym = symtab + sym_index;
11361 /* If the reloc has a symbol associated with it,
11362 make sure that it is of an appropriate type.
11364 Relocations against symbols without type can happen.
11365 Gcc -feliminate-dwarf2-dups may generate symbols
11366 without type for debug info.
11368 Icc generates relocations against function symbols
11369 instead of local labels.
11371 Relocations against object symbols can happen, eg when
11372 referencing a global array. For an example of this see
11373 the _clz.o binary in libgcc.a. */
11375 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11377 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11378 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11379 (long int)(rp - relocs),
11380 printable_section_name (relsec));
11386 addend += rp->r_addend;
11387 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11388 partial_inplace. */
11390 || (elf_header.e_machine == EM_XTENSA
11391 && reloc_type == 1)
11392 || ((elf_header.e_machine == EM_PJ
11393 || elf_header.e_machine == EM_PJ_OLD)
11394 && reloc_type == 1)
11395 || ((elf_header.e_machine == EM_D30V
11396 || elf_header.e_machine == EM_CYGNUS_D30V)
11397 && reloc_type == 12))
11398 addend += byte_get (rloc, reloc_size);
11400 if (is_32bit_pcrel_reloc (reloc_type)
11401 || is_64bit_pcrel_reloc (reloc_type))
11403 /* On HPPA, all pc-relative relocations are biased by 8. */
11404 if (elf_header.e_machine == EM_PARISC)
11406 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11410 byte_put (rloc, addend + sym->st_value, reloc_size);
11419 #ifdef SUPPORT_DISASSEMBLY
11421 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11423 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11425 /* FIXME: XXX -- to be done --- XXX */
11431 /* Reads in the contents of SECTION from FILE, returning a pointer
11432 to a malloc'ed buffer or NULL if something went wrong. */
11435 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11437 bfd_size_type num_bytes;
11439 num_bytes = section->sh_size;
11441 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11443 printf (_("\nSection '%s' has no data to dump.\n"),
11444 printable_section_name (section));
11448 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11449 _("section contents"));
11454 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11456 Elf_Internal_Shdr * relsec;
11457 bfd_size_type num_bytes;
11461 bfd_boolean some_strings_shown;
11463 start = get_section_contents (section, file);
11467 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11469 /* If the section being dumped has relocations against it the user might
11470 be expecting these relocations to have been applied. Check for this
11471 case and issue a warning message in order to avoid confusion.
11472 FIXME: Maybe we ought to have an option that dumps a section with
11473 relocs applied ? */
11474 for (relsec = section_headers;
11475 relsec < section_headers + elf_header.e_shnum;
11478 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11479 || relsec->sh_info >= elf_header.e_shnum
11480 || section_headers + relsec->sh_info != section
11481 || relsec->sh_size == 0
11482 || relsec->sh_link >= elf_header.e_shnum)
11485 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11489 num_bytes = section->sh_size;
11491 end = start + num_bytes;
11492 some_strings_shown = FALSE;
11496 while (!ISPRINT (* data))
11497 if (++ data >= end)
11502 size_t maxlen = end - data;
11505 /* PR 11128: Use two separate invocations in order to work
11506 around bugs in the Solaris 8 implementation of printf. */
11507 printf (" [%6tx] ", data - start);
11509 printf (" [%6Ix] ", (size_t) (data - start));
11513 print_symbol ((int) maxlen, data);
11515 data += strnlen (data, maxlen);
11519 printf (_("<corrupt>\n"));
11522 some_strings_shown = TRUE;
11526 if (! some_strings_shown)
11527 printf (_(" No strings found in this section."));
11535 dump_section_as_bytes (Elf_Internal_Shdr * section,
11537 bfd_boolean relocate)
11539 Elf_Internal_Shdr * relsec;
11540 bfd_size_type bytes;
11542 unsigned char * data;
11543 unsigned char * start;
11545 start = (unsigned char *) get_section_contents (section, file);
11549 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11553 apply_relocations (file, section, start);
11557 /* If the section being dumped has relocations against it the user might
11558 be expecting these relocations to have been applied. Check for this
11559 case and issue a warning message in order to avoid confusion.
11560 FIXME: Maybe we ought to have an option that dumps a section with
11561 relocs applied ? */
11562 for (relsec = section_headers;
11563 relsec < section_headers + elf_header.e_shnum;
11566 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11567 || relsec->sh_info >= elf_header.e_shnum
11568 || section_headers + relsec->sh_info != section
11569 || relsec->sh_size == 0
11570 || relsec->sh_link >= elf_header.e_shnum)
11573 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11578 addr = section->sh_addr;
11579 bytes = section->sh_size;
11588 lbytes = (bytes > 16 ? 16 : bytes);
11590 printf (" 0x%8.8lx ", (unsigned long) addr);
11592 for (j = 0; j < 16; j++)
11595 printf ("%2.2x", data[j]);
11603 for (j = 0; j < lbytes; j++)
11606 if (k >= ' ' && k < 0x7f)
11624 /* Uncompresses a section that was compressed using zlib, in place. */
11627 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11628 dwarf_size_type *size ATTRIBUTE_UNUSED)
11630 #ifndef HAVE_ZLIB_H
11633 dwarf_size_type compressed_size = *size;
11634 unsigned char * compressed_buffer = *buffer;
11635 dwarf_size_type uncompressed_size;
11636 unsigned char * uncompressed_buffer;
11639 dwarf_size_type header_size = 12;
11641 /* Read the zlib header. In this case, it should be "ZLIB" followed
11642 by the uncompressed section size, 8 bytes in big-endian order. */
11643 if (compressed_size < header_size
11644 || ! streq ((char *) compressed_buffer, "ZLIB"))
11647 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11648 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11649 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11650 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11651 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11652 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11653 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11654 uncompressed_size += compressed_buffer[11];
11656 /* It is possible the section consists of several compressed
11657 buffers concatenated together, so we uncompress in a loop. */
11658 strm.zalloc = NULL;
11660 strm.opaque = NULL;
11661 strm.avail_in = compressed_size - header_size;
11662 strm.next_in = (Bytef *) compressed_buffer + header_size;
11663 strm.avail_out = uncompressed_size;
11664 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11666 rc = inflateInit (& strm);
11667 while (strm.avail_in > 0)
11671 strm.next_out = ((Bytef *) uncompressed_buffer
11672 + (uncompressed_size - strm.avail_out));
11673 rc = inflate (&strm, Z_FINISH);
11674 if (rc != Z_STREAM_END)
11676 rc = inflateReset (& strm);
11678 rc = inflateEnd (& strm);
11680 || strm.avail_out != 0)
11683 free (compressed_buffer);
11684 *buffer = uncompressed_buffer;
11685 *size = uncompressed_size;
11689 free (uncompressed_buffer);
11690 /* Indicate decompression failure. */
11693 #endif /* HAVE_ZLIB_H */
11697 load_specific_debug_section (enum dwarf_section_display_enum debug,
11698 Elf_Internal_Shdr * sec, void * file)
11700 struct dwarf_section * section = &debug_displays [debug].section;
11703 /* If it is already loaded, do nothing. */
11704 if (section->start != NULL)
11707 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11708 section->address = sec->sh_addr;
11709 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11711 sec->sh_size, buf);
11712 if (section->start == NULL)
11716 section->size = sec->sh_size;
11717 if (uncompress_section_contents (§ion->start, §ion->size))
11718 sec->sh_size = section->size;
11721 if (section->start == NULL)
11724 if (debug_displays [debug].relocate)
11725 apply_relocations ((FILE *) file, sec, section->start);
11730 /* If this is not NULL, load_debug_section will only look for sections
11731 within the list of sections given here. */
11732 unsigned int *section_subset = NULL;
11735 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11737 struct dwarf_section * section = &debug_displays [debug].section;
11738 Elf_Internal_Shdr * sec;
11740 /* Locate the debug section. */
11741 sec = find_section_in_set (section->uncompressed_name, section_subset);
11743 section->name = section->uncompressed_name;
11746 sec = find_section_in_set (section->compressed_name, section_subset);
11748 section->name = section->compressed_name;
11753 /* If we're loading from a subset of sections, and we've loaded
11754 a section matching this name before, it's likely that it's a
11756 if (section_subset != NULL)
11757 free_debug_section (debug);
11759 return load_specific_debug_section (debug, sec, (FILE *) file);
11763 free_debug_section (enum dwarf_section_display_enum debug)
11765 struct dwarf_section * section = &debug_displays [debug].section;
11767 if (section->start == NULL)
11770 free ((char *) section->start);
11771 section->start = NULL;
11772 section->address = 0;
11777 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11779 char * name = SECTION_NAME (section);
11780 const char * print_name = printable_section_name (section);
11781 bfd_size_type length;
11785 length = section->sh_size;
11788 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
11791 if (section->sh_type == SHT_NOBITS)
11793 /* There is no point in dumping the contents of a debugging section
11794 which has the NOBITS type - the bits in the file will be random.
11795 This can happen when a file containing a .eh_frame section is
11796 stripped with the --only-keep-debug command line option. */
11797 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11802 if (const_strneq (name, ".gnu.linkonce.wi."))
11803 name = ".debug_info";
11805 /* See if we know how to display the contents of this section. */
11806 for (i = 0; i < max; i++)
11807 if (streq (debug_displays[i].section.uncompressed_name, name)
11808 || (i == line && const_strneq (name, ".debug_line."))
11809 || streq (debug_displays[i].section.compressed_name, name))
11811 struct dwarf_section * sec = &debug_displays [i].section;
11812 int secondary = (section != find_section (name));
11815 free_debug_section ((enum dwarf_section_display_enum) i);
11817 if (i == line && const_strneq (name, ".debug_line."))
11819 else if (streq (sec->uncompressed_name, name))
11820 sec->name = sec->uncompressed_name;
11822 sec->name = sec->compressed_name;
11823 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11826 /* If this debug section is part of a CU/TU set in a .dwp file,
11827 restrict load_debug_section to the sections in that set. */
11828 section_subset = find_cu_tu_set (file, shndx);
11830 result &= debug_displays[i].display (sec, file);
11832 section_subset = NULL;
11834 if (secondary || (i != info && i != abbrev))
11835 free_debug_section ((enum dwarf_section_display_enum) i);
11843 printf (_("Unrecognized debug section: %s\n"), print_name);
11850 /* Set DUMP_SECTS for all sections where dumps were requested
11851 based on section name. */
11854 initialise_dumps_byname (void)
11856 struct dump_list_entry * cur;
11858 for (cur = dump_sects_byname; cur; cur = cur->next)
11863 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11864 if (streq (SECTION_NAME (section_headers + i), cur->name))
11866 request_dump_bynumber (i, cur->type);
11871 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11877 process_section_contents (FILE * file)
11879 Elf_Internal_Shdr * section;
11885 initialise_dumps_byname ();
11887 for (i = 0, section = section_headers;
11888 i < elf_header.e_shnum && i < num_dump_sects;
11891 #ifdef SUPPORT_DISASSEMBLY
11892 if (dump_sects[i] & DISASS_DUMP)
11893 disassemble_section (section, file);
11895 if (dump_sects[i] & HEX_DUMP)
11896 dump_section_as_bytes (section, file, FALSE);
11898 if (dump_sects[i] & RELOC_DUMP)
11899 dump_section_as_bytes (section, file, TRUE);
11901 if (dump_sects[i] & STRING_DUMP)
11902 dump_section_as_strings (section, file);
11904 if (dump_sects[i] & DEBUG_DUMP)
11905 display_debug_section (i, section, file);
11908 /* Check to see if the user requested a
11909 dump of a section that does not exist. */
11910 while (i++ < num_dump_sects)
11912 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11916 process_mips_fpe_exception (int mask)
11921 if (mask & OEX_FPU_INEX)
11922 fputs ("INEX", stdout), first = 0;
11923 if (mask & OEX_FPU_UFLO)
11924 printf ("%sUFLO", first ? "" : "|"), first = 0;
11925 if (mask & OEX_FPU_OFLO)
11926 printf ("%sOFLO", first ? "" : "|"), first = 0;
11927 if (mask & OEX_FPU_DIV0)
11928 printf ("%sDIV0", first ? "" : "|"), first = 0;
11929 if (mask & OEX_FPU_INVAL)
11930 printf ("%sINVAL", first ? "" : "|");
11933 fputs ("0", stdout);
11936 /* Display's the value of TAG at location P. If TAG is
11937 greater than 0 it is assumed to be an unknown tag, and
11938 a message is printed to this effect. Otherwise it is
11939 assumed that a message has already been printed.
11941 If the bottom bit of TAG is set it assumed to have a
11942 string value, otherwise it is assumed to have an integer
11945 Returns an updated P pointing to the first unread byte
11946 beyond the end of TAG's value.
11948 Reads at or beyond END will not be made. */
11950 static unsigned char *
11951 display_tag_value (int tag,
11953 const unsigned char * const end)
11958 printf (" Tag_unknown_%d: ", tag);
11962 warn (_("<corrupt tag>\n"));
11966 /* PR 17531 file: 027-19978-0.004. */
11967 size_t maxlen = (end - p) - 1;
11972 print_symbol ((int) maxlen, (const char *) p);
11973 p += strnlen ((char *) p, maxlen) + 1;
11977 printf (_("<corrupt string tag>"));
11978 p = (unsigned char *) end;
11986 val = read_uleb128 (p, &len, end);
11988 printf ("%ld (0x%lx)\n", val, val);
11995 /* ARM EABI attributes section. */
12000 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12002 const char ** table;
12003 } arm_attr_public_tag;
12005 static const char * arm_attr_tag_CPU_arch[] =
12006 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12007 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12008 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12009 static const char * arm_attr_tag_THUMB_ISA_use[] =
12010 {"No", "Thumb-1", "Thumb-2"};
12011 static const char * arm_attr_tag_FP_arch[] =
12012 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12013 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12014 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12015 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12016 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12017 static const char * arm_attr_tag_PCS_config[] =
12018 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12019 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12020 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12021 {"V6", "SB", "TLS", "Unused"};
12022 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12023 {"Absolute", "PC-relative", "SB-relative", "None"};
12024 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12025 {"Absolute", "PC-relative", "None"};
12026 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12027 {"None", "direct", "GOT-indirect"};
12028 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12029 {"None", "??? 1", "2", "??? 3", "4"};
12030 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12031 static const char * arm_attr_tag_ABI_FP_denormal[] =
12032 {"Unused", "Needed", "Sign only"};
12033 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12034 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12035 static const char * arm_attr_tag_ABI_FP_number_model[] =
12036 {"Unused", "Finite", "RTABI", "IEEE 754"};
12037 static const char * arm_attr_tag_ABI_enum_size[] =
12038 {"Unused", "small", "int", "forced to int"};
12039 static const char * arm_attr_tag_ABI_HardFP_use[] =
12040 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12041 static const char * arm_attr_tag_ABI_VFP_args[] =
12042 {"AAPCS", "VFP registers", "custom"};
12043 static const char * arm_attr_tag_ABI_WMMX_args[] =
12044 {"AAPCS", "WMMX registers", "custom"};
12045 static const char * arm_attr_tag_ABI_optimization_goals[] =
12046 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12047 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12048 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12049 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12050 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12051 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12052 static const char * arm_attr_tag_FP_HP_extension[] =
12053 {"Not Allowed", "Allowed"};
12054 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12055 {"None", "IEEE 754", "Alternative Format"};
12056 static const char * arm_attr_tag_MPextension_use[] =
12057 {"Not Allowed", "Allowed"};
12058 static const char * arm_attr_tag_DIV_use[] =
12059 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12060 "Allowed in v7-A with integer division extension"};
12061 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12062 static const char * arm_attr_tag_Virtualization_use[] =
12063 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12064 "TrustZone and Virtualization Extensions"};
12065 static const char * arm_attr_tag_MPextension_use_legacy[] =
12066 {"Not Allowed", "Allowed"};
12068 #define LOOKUP(id, name) \
12069 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12070 static arm_attr_public_tag arm_attr_public_tags[] =
12072 {4, "CPU_raw_name", 1, NULL},
12073 {5, "CPU_name", 1, NULL},
12074 LOOKUP(6, CPU_arch),
12075 {7, "CPU_arch_profile", 0, NULL},
12076 LOOKUP(8, ARM_ISA_use),
12077 LOOKUP(9, THUMB_ISA_use),
12078 LOOKUP(10, FP_arch),
12079 LOOKUP(11, WMMX_arch),
12080 LOOKUP(12, Advanced_SIMD_arch),
12081 LOOKUP(13, PCS_config),
12082 LOOKUP(14, ABI_PCS_R9_use),
12083 LOOKUP(15, ABI_PCS_RW_data),
12084 LOOKUP(16, ABI_PCS_RO_data),
12085 LOOKUP(17, ABI_PCS_GOT_use),
12086 LOOKUP(18, ABI_PCS_wchar_t),
12087 LOOKUP(19, ABI_FP_rounding),
12088 LOOKUP(20, ABI_FP_denormal),
12089 LOOKUP(21, ABI_FP_exceptions),
12090 LOOKUP(22, ABI_FP_user_exceptions),
12091 LOOKUP(23, ABI_FP_number_model),
12092 {24, "ABI_align_needed", 0, NULL},
12093 {25, "ABI_align_preserved", 0, NULL},
12094 LOOKUP(26, ABI_enum_size),
12095 LOOKUP(27, ABI_HardFP_use),
12096 LOOKUP(28, ABI_VFP_args),
12097 LOOKUP(29, ABI_WMMX_args),
12098 LOOKUP(30, ABI_optimization_goals),
12099 LOOKUP(31, ABI_FP_optimization_goals),
12100 {32, "compatibility", 0, NULL},
12101 LOOKUP(34, CPU_unaligned_access),
12102 LOOKUP(36, FP_HP_extension),
12103 LOOKUP(38, ABI_FP_16bit_format),
12104 LOOKUP(42, MPextension_use),
12105 LOOKUP(44, DIV_use),
12106 {64, "nodefaults", 0, NULL},
12107 {65, "also_compatible_with", 0, NULL},
12108 LOOKUP(66, T2EE_use),
12109 {67, "conformance", 1, NULL},
12110 LOOKUP(68, Virtualization_use),
12111 LOOKUP(70, MPextension_use_legacy)
12115 static unsigned char *
12116 display_arm_attribute (unsigned char * p,
12117 const unsigned char * const end)
12122 arm_attr_public_tag * attr;
12126 tag = read_uleb128 (p, &len, end);
12129 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12131 if (arm_attr_public_tags[i].tag == tag)
12133 attr = &arm_attr_public_tags[i];
12140 printf (" Tag_%s: ", attr->name);
12141 switch (attr->type)
12146 case 7: /* Tag_CPU_arch_profile. */
12147 val = read_uleb128 (p, &len, end);
12151 case 0: printf (_("None\n")); break;
12152 case 'A': printf (_("Application\n")); break;
12153 case 'R': printf (_("Realtime\n")); break;
12154 case 'M': printf (_("Microcontroller\n")); break;
12155 case 'S': printf (_("Application or Realtime\n")); break;
12156 default: printf ("??? (%d)\n", val); break;
12160 case 24: /* Tag_align_needed. */
12161 val = read_uleb128 (p, &len, end);
12165 case 0: printf (_("None\n")); break;
12166 case 1: printf (_("8-byte\n")); break;
12167 case 2: printf (_("4-byte\n")); break;
12168 case 3: printf ("??? 3\n"); break;
12171 printf (_("8-byte and up to %d-byte extended\n"),
12174 printf ("??? (%d)\n", val);
12179 case 25: /* Tag_align_preserved. */
12180 val = read_uleb128 (p, &len, end);
12184 case 0: printf (_("None\n")); break;
12185 case 1: printf (_("8-byte, except leaf SP\n")); break;
12186 case 2: printf (_("8-byte\n")); break;
12187 case 3: printf ("??? 3\n"); break;
12190 printf (_("8-byte and up to %d-byte extended\n"),
12193 printf ("??? (%d)\n", val);
12198 case 32: /* Tag_compatibility. */
12200 val = read_uleb128 (p, &len, end);
12202 printf (_("flag = %d, vendor = "), val);
12205 size_t maxlen = (end - p) - 1;
12207 print_symbol ((int) maxlen, (const char *) p);
12208 p += strnlen ((char *) p, maxlen) + 1;
12212 printf (_("<corrupt>"));
12213 p = (unsigned char *) end;
12219 case 64: /* Tag_nodefaults. */
12220 /* PR 17531: file: 001-505008-0.01. */
12223 printf (_("True\n"));
12226 case 65: /* Tag_also_compatible_with. */
12227 val = read_uleb128 (p, &len, end);
12229 if (val == 6 /* Tag_CPU_arch. */)
12231 val = read_uleb128 (p, &len, end);
12233 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12234 printf ("??? (%d)\n", val);
12236 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12240 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12250 return display_tag_value (-1, p, end);
12252 return display_tag_value (0, p, end);
12255 assert (attr->type & 0x80);
12256 val = read_uleb128 (p, &len, end);
12258 type = attr->type & 0x7f;
12260 printf ("??? (%d)\n", val);
12262 printf ("%s\n", attr->table[val]);
12267 return display_tag_value (tag, p, end);
12270 static unsigned char *
12271 display_gnu_attribute (unsigned char * p,
12272 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12273 const unsigned char * const end)
12279 tag = read_uleb128 (p, &len, end);
12282 /* Tag_compatibility is the only generic GNU attribute defined at
12286 val = read_uleb128 (p, &len, end);
12289 printf (_("flag = %d, vendor = "), val);
12292 printf (_("<corrupt>\n"));
12293 warn (_("corrupt vendor attribute\n"));
12299 size_t maxlen = (end - p) - 1;
12301 print_symbol ((int) maxlen, (const char *) p);
12302 p += strnlen ((char *) p, maxlen) + 1;
12306 printf (_("<corrupt>"));
12307 p = (unsigned char *) end;
12314 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12315 return display_proc_gnu_attribute (p, tag, end);
12317 return display_tag_value (tag, p, end);
12320 static unsigned char *
12321 display_power_gnu_attribute (unsigned char * p,
12323 const unsigned char * const end)
12328 if (tag == Tag_GNU_Power_ABI_FP)
12330 val = read_uleb128 (p, &len, end);
12332 printf (" Tag_GNU_Power_ABI_FP: ");
12337 printf (_("Hard or soft float\n"));
12340 printf (_("Hard float\n"));
12343 printf (_("Soft float\n"));
12346 printf (_("Single-precision hard float\n"));
12349 printf ("??? (%d)\n", val);
12355 if (tag == Tag_GNU_Power_ABI_Vector)
12357 val = read_uleb128 (p, &len, end);
12359 printf (" Tag_GNU_Power_ABI_Vector: ");
12363 printf (_("Any\n"));
12366 printf (_("Generic\n"));
12369 printf ("AltiVec\n");
12375 printf ("??? (%d)\n", val);
12381 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12385 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12389 val = read_uleb128 (p, &len, end);
12391 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12395 printf (_("Any\n"));
12398 printf ("r3/r4\n");
12401 printf (_("Memory\n"));
12404 printf ("??? (%d)\n", val);
12410 return display_tag_value (tag & 1, p, end);
12414 display_sparc_hwcaps (int mask)
12420 if (mask & ELF_SPARC_HWCAP_MUL32)
12421 fputs ("mul32", stdout), first = 0;
12422 if (mask & ELF_SPARC_HWCAP_DIV32)
12423 printf ("%sdiv32", first ? "" : "|"), first = 0;
12424 if (mask & ELF_SPARC_HWCAP_FSMULD)
12425 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12426 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12427 printf ("%sv8plus", first ? "" : "|"), first = 0;
12428 if (mask & ELF_SPARC_HWCAP_POPC)
12429 printf ("%spopc", first ? "" : "|"), first = 0;
12430 if (mask & ELF_SPARC_HWCAP_VIS)
12431 printf ("%svis", first ? "" : "|"), first = 0;
12432 if (mask & ELF_SPARC_HWCAP_VIS2)
12433 printf ("%svis2", first ? "" : "|"), first = 0;
12434 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12435 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12436 if (mask & ELF_SPARC_HWCAP_FMAF)
12437 printf ("%sfmaf", first ? "" : "|"), first = 0;
12438 if (mask & ELF_SPARC_HWCAP_VIS3)
12439 printf ("%svis3", first ? "" : "|"), first = 0;
12440 if (mask & ELF_SPARC_HWCAP_HPC)
12441 printf ("%shpc", first ? "" : "|"), first = 0;
12442 if (mask & ELF_SPARC_HWCAP_RANDOM)
12443 printf ("%srandom", first ? "" : "|"), first = 0;
12444 if (mask & ELF_SPARC_HWCAP_TRANS)
12445 printf ("%strans", first ? "" : "|"), first = 0;
12446 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12447 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12448 if (mask & ELF_SPARC_HWCAP_IMA)
12449 printf ("%sima", first ? "" : "|"), first = 0;
12450 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12451 printf ("%scspare", first ? "" : "|"), first = 0;
12454 fputc ('0', stdout);
12455 fputc ('\n', stdout);
12459 display_sparc_hwcaps2 (int mask)
12465 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12466 fputs ("fjathplus", stdout), first = 0;
12467 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12468 printf ("%svis3b", first ? "" : "|"), first = 0;
12469 if (mask & ELF_SPARC_HWCAP2_ADP)
12470 printf ("%sadp", first ? "" : "|"), first = 0;
12471 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12472 printf ("%ssparc5", first ? "" : "|"), first = 0;
12473 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12474 printf ("%smwait", first ? "" : "|"), first = 0;
12475 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12476 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12477 if (mask & ELF_SPARC_HWCAP2_XMONT)
12478 printf ("%sxmont2", first ? "" : "|"), first = 0;
12479 if (mask & ELF_SPARC_HWCAP2_NSEC)
12480 printf ("%snsec", first ? "" : "|"), first = 0;
12481 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12482 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12483 if (mask & ELF_SPARC_HWCAP2_FJDES)
12484 printf ("%sfjdes", first ? "" : "|"), first = 0;
12485 if (mask & ELF_SPARC_HWCAP2_FJAES)
12486 printf ("%sfjaes", first ? "" : "|"), first = 0;
12489 fputc ('0', stdout);
12490 fputc ('\n', stdout);
12493 static unsigned char *
12494 display_sparc_gnu_attribute (unsigned char * p,
12496 const unsigned char * const end)
12501 if (tag == Tag_GNU_Sparc_HWCAPS)
12503 val = read_uleb128 (p, &len, end);
12505 printf (" Tag_GNU_Sparc_HWCAPS: ");
12506 display_sparc_hwcaps (val);
12509 if (tag == Tag_GNU_Sparc_HWCAPS2)
12511 val = read_uleb128 (p, &len, end);
12513 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12514 display_sparc_hwcaps2 (val);
12518 return display_tag_value (tag, p, end);
12522 print_mips_fp_abi_value (int val)
12526 case Val_GNU_MIPS_ABI_FP_ANY:
12527 printf (_("Hard or soft float\n"));
12529 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12530 printf (_("Hard float (double precision)\n"));
12532 case Val_GNU_MIPS_ABI_FP_SINGLE:
12533 printf (_("Hard float (single precision)\n"));
12535 case Val_GNU_MIPS_ABI_FP_SOFT:
12536 printf (_("Soft float\n"));
12538 case Val_GNU_MIPS_ABI_FP_OLD_64:
12539 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12541 case Val_GNU_MIPS_ABI_FP_XX:
12542 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12544 case Val_GNU_MIPS_ABI_FP_64:
12545 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12547 case Val_GNU_MIPS_ABI_FP_64A:
12548 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12551 printf ("??? (%d)\n", val);
12556 static unsigned char *
12557 display_mips_gnu_attribute (unsigned char * p,
12559 const unsigned char * const end)
12561 if (tag == Tag_GNU_MIPS_ABI_FP)
12566 val = read_uleb128 (p, &len, end);
12568 printf (" Tag_GNU_MIPS_ABI_FP: ");
12570 print_mips_fp_abi_value (val);
12575 if (tag == Tag_GNU_MIPS_ABI_MSA)
12580 val = read_uleb128 (p, &len, end);
12582 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12586 case Val_GNU_MIPS_ABI_MSA_ANY:
12587 printf (_("Any MSA or not\n"));
12589 case Val_GNU_MIPS_ABI_MSA_128:
12590 printf (_("128-bit MSA\n"));
12593 printf ("??? (%d)\n", val);
12599 return display_tag_value (tag & 1, p, end);
12602 static unsigned char *
12603 display_tic6x_attribute (unsigned char * p,
12604 const unsigned char * const end)
12610 tag = read_uleb128 (p, &len, end);
12616 val = read_uleb128 (p, &len, end);
12618 printf (" Tag_ISA: ");
12622 case C6XABI_Tag_ISA_none:
12623 printf (_("None\n"));
12625 case C6XABI_Tag_ISA_C62X:
12628 case C6XABI_Tag_ISA_C67X:
12631 case C6XABI_Tag_ISA_C67XP:
12632 printf ("C67x+\n");
12634 case C6XABI_Tag_ISA_C64X:
12637 case C6XABI_Tag_ISA_C64XP:
12638 printf ("C64x+\n");
12640 case C6XABI_Tag_ISA_C674X:
12641 printf ("C674x\n");
12644 printf ("??? (%d)\n", val);
12649 case Tag_ABI_wchar_t:
12650 val = read_uleb128 (p, &len, end);
12652 printf (" Tag_ABI_wchar_t: ");
12656 printf (_("Not used\n"));
12659 printf (_("2 bytes\n"));
12662 printf (_("4 bytes\n"));
12665 printf ("??? (%d)\n", val);
12670 case Tag_ABI_stack_align_needed:
12671 val = read_uleb128 (p, &len, end);
12673 printf (" Tag_ABI_stack_align_needed: ");
12677 printf (_("8-byte\n"));
12680 printf (_("16-byte\n"));
12683 printf ("??? (%d)\n", val);
12688 case Tag_ABI_stack_align_preserved:
12689 val = read_uleb128 (p, &len, end);
12691 printf (" Tag_ABI_stack_align_preserved: ");
12695 printf (_("8-byte\n"));
12698 printf (_("16-byte\n"));
12701 printf ("??? (%d)\n", val);
12707 val = read_uleb128 (p, &len, end);
12709 printf (" Tag_ABI_DSBT: ");
12713 printf (_("DSBT addressing not used\n"));
12716 printf (_("DSBT addressing used\n"));
12719 printf ("??? (%d)\n", val);
12725 val = read_uleb128 (p, &len, end);
12727 printf (" Tag_ABI_PID: ");
12731 printf (_("Data addressing position-dependent\n"));
12734 printf (_("Data addressing position-independent, GOT near DP\n"));
12737 printf (_("Data addressing position-independent, GOT far from DP\n"));
12740 printf ("??? (%d)\n", val);
12746 val = read_uleb128 (p, &len, end);
12748 printf (" Tag_ABI_PIC: ");
12752 printf (_("Code addressing position-dependent\n"));
12755 printf (_("Code addressing position-independent\n"));
12758 printf ("??? (%d)\n", val);
12763 case Tag_ABI_array_object_alignment:
12764 val = read_uleb128 (p, &len, end);
12766 printf (" Tag_ABI_array_object_alignment: ");
12770 printf (_("8-byte\n"));
12773 printf (_("4-byte\n"));
12776 printf (_("16-byte\n"));
12779 printf ("??? (%d)\n", val);
12784 case Tag_ABI_array_object_align_expected:
12785 val = read_uleb128 (p, &len, end);
12787 printf (" Tag_ABI_array_object_align_expected: ");
12791 printf (_("8-byte\n"));
12794 printf (_("4-byte\n"));
12797 printf (_("16-byte\n"));
12800 printf ("??? (%d)\n", val);
12805 case Tag_ABI_compatibility:
12807 val = read_uleb128 (p, &len, end);
12809 printf (" Tag_ABI_compatibility: ");
12810 printf (_("flag = %d, vendor = "), val);
12813 size_t maxlen = (end - p) - 1;
12815 print_symbol ((int) maxlen, (const char *) p);
12816 p += strnlen ((char *) p, maxlen) + 1;
12820 printf (_("<corrupt>"));
12821 p = (unsigned char *) end;
12827 case Tag_ABI_conformance:
12829 printf (" Tag_ABI_conformance: \"");
12832 size_t maxlen = (end - p) - 1;
12834 print_symbol ((int) maxlen, (const char *) p);
12835 p += strnlen ((char *) p, maxlen) + 1;
12839 printf (_("<corrupt>"));
12840 p = (unsigned char *) end;
12847 return display_tag_value (tag, p, end);
12851 display_raw_attribute (unsigned char * p, unsigned char * end)
12853 unsigned long addr = 0;
12854 size_t bytes = end - p;
12861 int lbytes = (bytes > 16 ? 16 : bytes);
12863 printf (" 0x%8.8lx ", addr);
12865 for (j = 0; j < 16; j++)
12868 printf ("%2.2x", p[j]);
12876 for (j = 0; j < lbytes; j++)
12879 if (k >= ' ' && k < 0x7f)
12895 static unsigned char *
12896 display_msp430x_attribute (unsigned char * p,
12897 const unsigned char * const end)
12903 tag = read_uleb128 (p, & len, end);
12908 case OFBA_MSPABI_Tag_ISA:
12909 val = read_uleb128 (p, &len, end);
12911 printf (" Tag_ISA: ");
12914 case 0: printf (_("None\n")); break;
12915 case 1: printf (_("MSP430\n")); break;
12916 case 2: printf (_("MSP430X\n")); break;
12917 default: printf ("??? (%d)\n", val); break;
12921 case OFBA_MSPABI_Tag_Code_Model:
12922 val = read_uleb128 (p, &len, end);
12924 printf (" Tag_Code_Model: ");
12927 case 0: printf (_("None\n")); break;
12928 case 1: printf (_("Small\n")); break;
12929 case 2: printf (_("Large\n")); break;
12930 default: printf ("??? (%d)\n", val); break;
12934 case OFBA_MSPABI_Tag_Data_Model:
12935 val = read_uleb128 (p, &len, end);
12937 printf (" Tag_Data_Model: ");
12940 case 0: printf (_("None\n")); break;
12941 case 1: printf (_("Small\n")); break;
12942 case 2: printf (_("Large\n")); break;
12943 case 3: printf (_("Restricted Large\n")); break;
12944 default: printf ("??? (%d)\n", val); break;
12949 printf (_(" <unknown tag %d>: "), tag);
12956 size_t maxlen = (end - p) - 1;
12958 print_symbol ((int) maxlen, (const char *) p);
12959 p += strnlen ((char *) p, maxlen) + 1;
12963 printf (_("<corrupt>"));
12964 p = (unsigned char *) end;
12970 val = read_uleb128 (p, &len, end);
12972 printf ("%d (0x%x)\n", val, val);
12982 process_attributes (FILE * file,
12983 const char * public_name,
12984 unsigned int proc_type,
12985 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12986 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12988 Elf_Internal_Shdr * sect;
12991 /* Find the section header so that we get the size. */
12992 for (i = 0, sect = section_headers;
12993 i < elf_header.e_shnum;
12996 unsigned char * contents;
12999 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13002 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13003 sect->sh_size, _("attributes"));
13004 if (contents == NULL)
13010 bfd_vma section_len;
13012 section_len = sect->sh_size - 1;
13015 while (section_len > 0)
13018 unsigned int namelen;
13019 bfd_boolean public_section;
13020 bfd_boolean gnu_section;
13022 if (section_len <= 4)
13024 error (_("Tag section ends prematurely\n"));
13027 attr_len = byte_get (p, 4);
13030 if (attr_len > section_len)
13032 error (_("Bad attribute length (%u > %u)\n"),
13033 (unsigned) attr_len, (unsigned) section_len);
13034 attr_len = section_len;
13036 /* PR 17531: file: 001-101425-0.004 */
13037 else if (attr_len < 5)
13039 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13043 section_len -= attr_len;
13046 namelen = strnlen ((char *) p, attr_len) + 1;
13047 if (namelen == 0 || namelen >= attr_len)
13049 error (_("Corrupt attribute section name\n"));
13053 printf (_("Attribute Section: "));
13054 print_symbol (INT_MAX, (const char *) p);
13057 if (public_name && streq ((char *) p, public_name))
13058 public_section = TRUE;
13060 public_section = FALSE;
13062 if (streq ((char *) p, "gnu"))
13063 gnu_section = TRUE;
13065 gnu_section = FALSE;
13068 attr_len -= namelen;
13070 while (attr_len > 0 && p < contents + sect->sh_size)
13075 unsigned char * end;
13077 /* PR binutils/17531: Safe handling of corrupt files. */
13080 error (_("Unused bytes at end of section\n"));
13086 size = byte_get (p, 4);
13087 if (size > attr_len)
13089 error (_("Bad subsection length (%u > %u)\n"),
13090 (unsigned) size, (unsigned) attr_len);
13093 /* PR binutils/17531: Safe handling of corrupt files. */
13096 error (_("Bad subsection length (%u < 6)\n"),
13103 end = p + size - 1;
13104 assert (end <= contents + sect->sh_size);
13110 printf (_("File Attributes\n"));
13113 printf (_("Section Attributes:"));
13116 printf (_("Symbol Attributes:"));
13122 val = read_uleb128 (p, &j, end);
13126 printf (" %d", val);
13131 printf (_("Unknown tag: %d\n"), tag);
13132 public_section = FALSE;
13136 if (public_section && display_pub_attribute != NULL)
13139 p = display_pub_attribute (p, end);
13142 else if (gnu_section && display_proc_gnu_attribute != NULL)
13145 p = display_gnu_attribute (p,
13146 display_proc_gnu_attribute,
13152 printf (_(" Unknown attribute:\n"));
13153 display_raw_attribute (p, end);
13162 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13170 process_arm_specific (FILE * file)
13172 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13173 display_arm_attribute, NULL);
13177 process_power_specific (FILE * file)
13179 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13180 display_power_gnu_attribute);
13184 process_sparc_specific (FILE * file)
13186 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13187 display_sparc_gnu_attribute);
13191 process_tic6x_specific (FILE * file)
13193 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13194 display_tic6x_attribute, NULL);
13198 process_msp430x_specific (FILE * file)
13200 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13201 display_msp430x_attribute, NULL);
13204 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13205 Print the Address, Access and Initial fields of an entry at VMA ADDR
13206 and return the VMA of the next entry. */
13209 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13212 print_vma (addr, LONG_HEX);
13214 if (addr < pltgot + 0xfff0)
13215 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13217 printf ("%10s", "");
13220 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13225 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13226 print_vma (entry, LONG_HEX);
13228 return addr + (is_32bit_elf ? 4 : 8);
13231 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13232 PLTGOT. Print the Address and Initial fields of an entry at VMA
13233 ADDR and return the VMA of the next entry. */
13236 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13239 print_vma (addr, LONG_HEX);
13242 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13247 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13248 print_vma (entry, LONG_HEX);
13250 return addr + (is_32bit_elf ? 4 : 8);
13254 print_mips_ases (unsigned int mask)
13256 if (mask & AFL_ASE_DSP)
13257 fputs ("\n\tDSP ASE", stdout);
13258 if (mask & AFL_ASE_DSPR2)
13259 fputs ("\n\tDSP R2 ASE", stdout);
13260 if (mask & AFL_ASE_EVA)
13261 fputs ("\n\tEnhanced VA Scheme", stdout);
13262 if (mask & AFL_ASE_MCU)
13263 fputs ("\n\tMCU (MicroController) ASE", stdout);
13264 if (mask & AFL_ASE_MDMX)
13265 fputs ("\n\tMDMX ASE", stdout);
13266 if (mask & AFL_ASE_MIPS3D)
13267 fputs ("\n\tMIPS-3D ASE", stdout);
13268 if (mask & AFL_ASE_MT)
13269 fputs ("\n\tMT ASE", stdout);
13270 if (mask & AFL_ASE_SMARTMIPS)
13271 fputs ("\n\tSmartMIPS ASE", stdout);
13272 if (mask & AFL_ASE_VIRT)
13273 fputs ("\n\tVZ ASE", stdout);
13274 if (mask & AFL_ASE_MSA)
13275 fputs ("\n\tMSA ASE", stdout);
13276 if (mask & AFL_ASE_MIPS16)
13277 fputs ("\n\tMIPS16 ASE", stdout);
13278 if (mask & AFL_ASE_MICROMIPS)
13279 fputs ("\n\tMICROMIPS ASE", stdout);
13280 if (mask & AFL_ASE_XPA)
13281 fputs ("\n\tXPA ASE", stdout);
13283 fprintf (stdout, "\n\t%s", _("None"));
13284 else if ((mask & ~AFL_ASE_MASK) != 0)
13285 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13289 print_mips_isa_ext (unsigned int isa_ext)
13294 fputs (_("None"), stdout);
13297 fputs ("RMI XLR", stdout);
13299 case AFL_EXT_OCTEON3:
13300 fputs ("Cavium Networks Octeon3", stdout);
13302 case AFL_EXT_OCTEON2:
13303 fputs ("Cavium Networks Octeon2", stdout);
13305 case AFL_EXT_OCTEONP:
13306 fputs ("Cavium Networks OcteonP", stdout);
13308 case AFL_EXT_LOONGSON_3A:
13309 fputs ("Loongson 3A", stdout);
13311 case AFL_EXT_OCTEON:
13312 fputs ("Cavium Networks Octeon", stdout);
13315 fputs ("Toshiba R5900", stdout);
13318 fputs ("MIPS R4650", stdout);
13321 fputs ("LSI R4010", stdout);
13324 fputs ("NEC VR4100", stdout);
13327 fputs ("Toshiba R3900", stdout);
13329 case AFL_EXT_10000:
13330 fputs ("MIPS R10000", stdout);
13333 fputs ("Broadcom SB-1", stdout);
13336 fputs ("NEC VR4111/VR4181", stdout);
13339 fputs ("NEC VR4120", stdout);
13342 fputs ("NEC VR5400", stdout);
13345 fputs ("NEC VR5500", stdout);
13347 case AFL_EXT_LOONGSON_2E:
13348 fputs ("ST Microelectronics Loongson 2E", stdout);
13350 case AFL_EXT_LOONGSON_2F:
13351 fputs ("ST Microelectronics Loongson 2F", stdout);
13354 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13359 get_mips_reg_size (int reg_size)
13361 return (reg_size == AFL_REG_NONE) ? 0
13362 : (reg_size == AFL_REG_32) ? 32
13363 : (reg_size == AFL_REG_64) ? 64
13364 : (reg_size == AFL_REG_128) ? 128
13369 process_mips_specific (FILE * file)
13371 Elf_Internal_Dyn * entry;
13372 Elf_Internal_Shdr *sect = NULL;
13373 size_t liblist_offset = 0;
13374 size_t liblistno = 0;
13375 size_t conflictsno = 0;
13376 size_t options_offset = 0;
13377 size_t conflicts_offset = 0;
13378 size_t pltrelsz = 0;
13380 bfd_vma pltgot = 0;
13381 bfd_vma mips_pltgot = 0;
13382 bfd_vma jmprel = 0;
13383 bfd_vma local_gotno = 0;
13384 bfd_vma gotsym = 0;
13385 bfd_vma symtabno = 0;
13387 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13388 display_mips_gnu_attribute);
13390 sect = find_section (".MIPS.abiflags");
13394 Elf_External_ABIFlags_v0 *abiflags_ext;
13395 Elf_Internal_ABIFlags_v0 abiflags_in;
13397 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13398 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13401 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13402 sect->sh_size, _("MIPS ABI Flags section"));
13405 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13406 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13407 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13408 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13409 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13410 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13411 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13412 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13413 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13414 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13415 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13417 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13418 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13419 if (abiflags_in.isa_rev > 1)
13420 printf ("r%d", abiflags_in.isa_rev);
13421 printf ("\nGPR size: %d",
13422 get_mips_reg_size (abiflags_in.gpr_size));
13423 printf ("\nCPR1 size: %d",
13424 get_mips_reg_size (abiflags_in.cpr1_size));
13425 printf ("\nCPR2 size: %d",
13426 get_mips_reg_size (abiflags_in.cpr2_size));
13427 fputs ("\nFP ABI: ", stdout);
13428 print_mips_fp_abi_value (abiflags_in.fp_abi);
13429 fputs ("ISA Extension: ", stdout);
13430 print_mips_isa_ext (abiflags_in.isa_ext);
13431 fputs ("\nASEs:", stdout);
13432 print_mips_ases (abiflags_in.ases);
13433 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13434 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13435 fputc ('\n', stdout);
13436 free (abiflags_ext);
13441 /* We have a lot of special sections. Thanks SGI! */
13442 if (dynamic_section == NULL)
13443 /* No information available. */
13446 for (entry = dynamic_section;
13447 /* PR 17531 file: 012-50589-0.004. */
13448 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13450 switch (entry->d_tag)
13452 case DT_MIPS_LIBLIST:
13454 = offset_from_vma (file, entry->d_un.d_val,
13455 liblistno * sizeof (Elf32_External_Lib));
13457 case DT_MIPS_LIBLISTNO:
13458 liblistno = entry->d_un.d_val;
13460 case DT_MIPS_OPTIONS:
13461 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13463 case DT_MIPS_CONFLICT:
13465 = offset_from_vma (file, entry->d_un.d_val,
13466 conflictsno * sizeof (Elf32_External_Conflict));
13468 case DT_MIPS_CONFLICTNO:
13469 conflictsno = entry->d_un.d_val;
13472 pltgot = entry->d_un.d_ptr;
13474 case DT_MIPS_LOCAL_GOTNO:
13475 local_gotno = entry->d_un.d_val;
13477 case DT_MIPS_GOTSYM:
13478 gotsym = entry->d_un.d_val;
13480 case DT_MIPS_SYMTABNO:
13481 symtabno = entry->d_un.d_val;
13483 case DT_MIPS_PLTGOT:
13484 mips_pltgot = entry->d_un.d_ptr;
13487 pltrel = entry->d_un.d_val;
13490 pltrelsz = entry->d_un.d_val;
13493 jmprel = entry->d_un.d_ptr;
13499 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13501 Elf32_External_Lib * elib;
13504 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13506 sizeof (Elf32_External_Lib),
13507 _("liblist section data"));
13510 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13511 (unsigned long) liblistno);
13512 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13515 for (cnt = 0; cnt < liblistno; ++cnt)
13522 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13523 atime = BYTE_GET (elib[cnt].l_time_stamp);
13524 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13525 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13526 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13528 tmp = gmtime (&atime);
13529 snprintf (timebuf, sizeof (timebuf),
13530 "%04u-%02u-%02uT%02u:%02u:%02u",
13531 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13532 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13534 printf ("%3lu: ", (unsigned long) cnt);
13535 if (VALID_DYNAMIC_NAME (liblist.l_name))
13536 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13538 printf (_("<corrupt: %9ld>"), liblist.l_name);
13539 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13540 liblist.l_version);
13542 if (liblist.l_flags == 0)
13546 static const struct
13553 { " EXACT_MATCH", LL_EXACT_MATCH },
13554 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13555 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13556 { " EXPORTS", LL_EXPORTS },
13557 { " DELAY_LOAD", LL_DELAY_LOAD },
13558 { " DELTA", LL_DELTA }
13560 int flags = liblist.l_flags;
13563 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13564 if ((flags & l_flags_vals[fcnt].bit) != 0)
13566 fputs (l_flags_vals[fcnt].name, stdout);
13567 flags ^= l_flags_vals[fcnt].bit;
13570 printf (" %#x", (unsigned int) flags);
13580 if (options_offset != 0)
13582 Elf_External_Options * eopt;
13583 Elf_Internal_Options * iopt;
13584 Elf_Internal_Options * option;
13587 sect = section_headers;
13589 /* Find the section header so that we get the size. */
13590 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13591 /* PR 17533 file: 012-277276-0.004. */
13594 error (_("No MIPS_OPTIONS header found\n"));
13598 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13599 sect->sh_size, _("options"));
13602 iopt = (Elf_Internal_Options *)
13603 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13606 error (_("Out of memory allocatinf space for MIPS options\n"));
13613 while (offset < sect->sh_size)
13615 Elf_External_Options * eoption;
13617 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13619 option->kind = BYTE_GET (eoption->kind);
13620 option->size = BYTE_GET (eoption->size);
13621 option->section = BYTE_GET (eoption->section);
13622 option->info = BYTE_GET (eoption->info);
13624 offset += option->size;
13630 printf (_("\nSection '%s' contains %d entries:\n"),
13631 printable_section_name (sect), cnt);
13639 switch (option->kind)
13642 /* This shouldn't happen. */
13643 printf (" NULL %d %lx", option->section, option->info);
13646 printf (" REGINFO ");
13647 if (elf_header.e_machine == EM_MIPS)
13650 Elf32_External_RegInfo * ereg;
13651 Elf32_RegInfo reginfo;
13653 ereg = (Elf32_External_RegInfo *) (option + 1);
13654 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13655 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13656 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13657 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13658 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13659 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13661 printf ("GPR %08lx GP 0x%lx\n",
13662 reginfo.ri_gprmask,
13663 (unsigned long) reginfo.ri_gp_value);
13664 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13665 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13666 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13671 Elf64_External_RegInfo * ereg;
13672 Elf64_Internal_RegInfo reginfo;
13674 ereg = (Elf64_External_RegInfo *) (option + 1);
13675 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13676 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13677 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13678 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13679 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13680 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13682 printf ("GPR %08lx GP 0x",
13683 reginfo.ri_gprmask);
13684 printf_vma (reginfo.ri_gp_value);
13687 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13688 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13689 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13693 case ODK_EXCEPTIONS:
13694 fputs (" EXCEPTIONS fpe_min(", stdout);
13695 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13696 fputs (") fpe_max(", stdout);
13697 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13698 fputs (")", stdout);
13700 if (option->info & OEX_PAGE0)
13701 fputs (" PAGE0", stdout);
13702 if (option->info & OEX_SMM)
13703 fputs (" SMM", stdout);
13704 if (option->info & OEX_FPDBUG)
13705 fputs (" FPDBUG", stdout);
13706 if (option->info & OEX_DISMISS)
13707 fputs (" DISMISS", stdout);
13710 fputs (" PAD ", stdout);
13711 if (option->info & OPAD_PREFIX)
13712 fputs (" PREFIX", stdout);
13713 if (option->info & OPAD_POSTFIX)
13714 fputs (" POSTFIX", stdout);
13715 if (option->info & OPAD_SYMBOL)
13716 fputs (" SYMBOL", stdout);
13719 fputs (" HWPATCH ", stdout);
13720 if (option->info & OHW_R4KEOP)
13721 fputs (" R4KEOP", stdout);
13722 if (option->info & OHW_R8KPFETCH)
13723 fputs (" R8KPFETCH", stdout);
13724 if (option->info & OHW_R5KEOP)
13725 fputs (" R5KEOP", stdout);
13726 if (option->info & OHW_R5KCVTL)
13727 fputs (" R5KCVTL", stdout);
13730 fputs (" FILL ", stdout);
13731 /* XXX Print content of info word? */
13734 fputs (" TAGS ", stdout);
13735 /* XXX Print content of info word? */
13738 fputs (" HWAND ", stdout);
13739 if (option->info & OHWA0_R4KEOP_CHECKED)
13740 fputs (" R4KEOP_CHECKED", stdout);
13741 if (option->info & OHWA0_R4KEOP_CLEAN)
13742 fputs (" R4KEOP_CLEAN", stdout);
13745 fputs (" HWOR ", 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 printf (" GP_GROUP %#06lx self-contained %#06lx",
13753 option->info & OGP_GROUP,
13754 (option->info & OGP_SELF) >> 16);
13757 printf (" IDENT %#06lx self-contained %#06lx",
13758 option->info & OGP_GROUP,
13759 (option->info & OGP_SELF) >> 16);
13762 /* This shouldn't happen. */
13763 printf (" %3d ??? %d %lx",
13764 option->kind, option->section, option->info);
13768 len = sizeof (* eopt);
13769 while (len < option->size)
13770 if (((char *) option)[len] >= ' '
13771 && ((char *) option)[len] < 0x7f)
13772 printf ("%c", ((char *) option)[len++]);
13774 printf ("\\%03o", ((char *) option)[len++]);
13776 fputs ("\n", stdout);
13784 if (conflicts_offset != 0 && conflictsno != 0)
13786 Elf32_Conflict * iconf;
13789 if (dynamic_symbols == NULL)
13791 error (_("conflict list found without a dynamic symbol table\n"));
13795 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13798 error (_("Out of memory allocating space for dynamic conflicts\n"));
13804 Elf32_External_Conflict * econf32;
13806 econf32 = (Elf32_External_Conflict *)
13807 get_data (NULL, file, conflicts_offset, conflictsno,
13808 sizeof (* econf32), _("conflict"));
13812 for (cnt = 0; cnt < conflictsno; ++cnt)
13813 iconf[cnt] = BYTE_GET (econf32[cnt]);
13819 Elf64_External_Conflict * econf64;
13821 econf64 = (Elf64_External_Conflict *)
13822 get_data (NULL, file, conflicts_offset, conflictsno,
13823 sizeof (* econf64), _("conflict"));
13827 for (cnt = 0; cnt < conflictsno; ++cnt)
13828 iconf[cnt] = BYTE_GET (econf64[cnt]);
13833 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13834 (unsigned long) conflictsno);
13835 puts (_(" Num: Index Value Name"));
13837 for (cnt = 0; cnt < conflictsno; ++cnt)
13839 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
13841 if (iconf[cnt] >= num_dynamic_syms)
13842 printf (_("<corrupt symbol index>"));
13845 Elf_Internal_Sym * psym;
13847 psym = & dynamic_symbols[iconf[cnt]];
13848 print_vma (psym->st_value, FULL_HEX);
13850 if (VALID_DYNAMIC_NAME (psym->st_name))
13851 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13853 printf (_("<corrupt: %14ld>"), psym->st_name);
13861 if (pltgot != 0 && local_gotno != 0)
13863 bfd_vma ent, local_end, global_end;
13865 unsigned char * data;
13869 addr_size = (is_32bit_elf ? 4 : 8);
13870 local_end = pltgot + local_gotno * addr_size;
13872 /* PR binutils/17533 file: 012-111227-0.004 */
13873 if (symtabno < gotsym)
13875 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13876 (long) gotsym, (long) symtabno);
13880 global_end = local_end + (symtabno - gotsym) * addr_size;
13881 assert (global_end >= local_end);
13882 offset = offset_from_vma (file, pltgot, global_end - pltgot);
13883 data = (unsigned char *) get_data (NULL, file, offset,
13884 global_end - pltgot, 1,
13885 _("Global Offset Table data"));
13889 printf (_("\nPrimary GOT:\n"));
13890 printf (_(" Canonical gp value: "));
13891 print_vma (pltgot + 0x7ff0, LONG_HEX);
13894 printf (_(" Reserved entries:\n"));
13895 printf (_(" %*s %10s %*s Purpose\n"),
13896 addr_size * 2, _("Address"), _("Access"),
13897 addr_size * 2, _("Initial"));
13898 ent = print_mips_got_entry (data, pltgot, ent);
13899 printf (_(" Lazy resolver\n"));
13901 && (byte_get (data + ent - pltgot, addr_size)
13902 >> (addr_size * 8 - 1)) != 0)
13904 ent = print_mips_got_entry (data, pltgot, ent);
13905 printf (_(" Module pointer (GNU extension)\n"));
13909 if (ent < local_end)
13911 printf (_(" Local entries:\n"));
13912 printf (" %*s %10s %*s\n",
13913 addr_size * 2, _("Address"), _("Access"),
13914 addr_size * 2, _("Initial"));
13915 while (ent < local_end)
13917 ent = print_mips_got_entry (data, pltgot, ent);
13923 if (gotsym < symtabno)
13927 printf (_(" Global entries:\n"));
13928 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13929 addr_size * 2, _("Address"),
13931 addr_size * 2, _("Initial"),
13932 addr_size * 2, _("Sym.Val."),
13934 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13935 _("Ndx"), _("Name"));
13937 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13939 for (i = gotsym; i < symtabno; i++)
13941 ent = print_mips_got_entry (data, pltgot, ent);
13944 if (dynamic_symbols == NULL)
13945 printf (_("<no dynamic symbols>"));
13946 else if (i < num_dynamic_syms)
13948 Elf_Internal_Sym * psym = dynamic_symbols + i;
13950 print_vma (psym->st_value, LONG_HEX);
13951 printf (" %-7s %3s ",
13952 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13953 get_symbol_index_type (psym->st_shndx));
13955 if (VALID_DYNAMIC_NAME (psym->st_name))
13956 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13958 printf (_("<corrupt: %14ld>"), psym->st_name);
13961 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13962 (unsigned long) i);
13973 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13976 size_t offset, rel_offset;
13977 unsigned long count, i;
13978 unsigned char * data;
13979 int addr_size, sym_width;
13980 Elf_Internal_Rela * rels;
13982 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13983 if (pltrel == DT_RELA)
13985 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13990 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13995 addr_size = (is_32bit_elf ? 4 : 8);
13996 end = mips_pltgot + (2 + count) * addr_size;
13998 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13999 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14000 1, _("Procedure Linkage Table data"));
14004 printf ("\nPLT GOT:\n\n");
14005 printf (_(" Reserved entries:\n"));
14006 printf (_(" %*s %*s Purpose\n"),
14007 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14008 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14009 printf (_(" PLT lazy resolver\n"));
14010 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14011 printf (_(" Module pointer\n"));
14014 printf (_(" Entries:\n"));
14015 printf (" %*s %*s %*s %-7s %3s %s\n",
14016 addr_size * 2, _("Address"),
14017 addr_size * 2, _("Initial"),
14018 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14019 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14020 for (i = 0; i < count; i++)
14022 unsigned long idx = get_reloc_symindex (rels[i].r_info);
14024 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14027 if (idx >= num_dynamic_syms)
14028 printf (_("<corrupt symbol index: %lu>"), idx);
14031 Elf_Internal_Sym * psym = dynamic_symbols + idx;
14033 print_vma (psym->st_value, LONG_HEX);
14034 printf (" %-7s %3s ",
14035 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14036 get_symbol_index_type (psym->st_shndx));
14037 if (VALID_DYNAMIC_NAME (psym->st_name))
14038 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14040 printf (_("<corrupt: %14ld>"), psym->st_name);
14055 process_nds32_specific (FILE * file)
14057 Elf_Internal_Shdr *sect = NULL;
14059 sect = find_section (".nds32_e_flags");
14062 unsigned int *flag;
14064 printf ("\nNDS32 elf flags section:\n");
14065 flag = get_data (NULL, file, sect->sh_offset, 1,
14066 sect->sh_size, _("NDS32 elf flags section"));
14068 switch ((*flag) & 0x3)
14071 printf ("(VEC_SIZE):\tNo entry.\n");
14074 printf ("(VEC_SIZE):\t4 bytes\n");
14077 printf ("(VEC_SIZE):\t16 bytes\n");
14080 printf ("(VEC_SIZE):\treserved\n");
14089 process_gnu_liblist (FILE * file)
14091 Elf_Internal_Shdr * section;
14092 Elf_Internal_Shdr * string_sec;
14093 Elf32_External_Lib * elib;
14095 size_t strtab_size;
14102 for (i = 0, section = section_headers;
14103 i < elf_header.e_shnum;
14106 switch (section->sh_type)
14108 case SHT_GNU_LIBLIST:
14109 if (section->sh_link >= elf_header.e_shnum)
14112 elib = (Elf32_External_Lib *)
14113 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14114 _("liblist section data"));
14118 string_sec = section_headers + section->sh_link;
14120 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14121 string_sec->sh_size,
14122 _("liblist string table"));
14124 || section->sh_entsize != sizeof (Elf32_External_Lib))
14130 strtab_size = string_sec->sh_size;
14132 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14133 printable_section_name (section),
14134 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14136 puts (_(" Library Time Stamp Checksum Version Flags"));
14138 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14146 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14147 atime = BYTE_GET (elib[cnt].l_time_stamp);
14148 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14149 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14150 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14152 tmp = gmtime (&atime);
14153 snprintf (timebuf, sizeof (timebuf),
14154 "%04u-%02u-%02uT%02u:%02u:%02u",
14155 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14156 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14158 printf ("%3lu: ", (unsigned long) cnt);
14160 printf ("%-20s", liblist.l_name < strtab_size
14161 ? strtab + liblist.l_name : _("<corrupt>"));
14163 printf ("%-20.20s", liblist.l_name < strtab_size
14164 ? strtab + liblist.l_name : _("<corrupt>"));
14165 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14166 liblist.l_version, liblist.l_flags);
14177 static const char *
14178 get_note_type (unsigned e_type)
14180 static char buff[64];
14182 if (elf_header.e_type == ET_CORE)
14186 return _("NT_AUXV (auxiliary vector)");
14188 return _("NT_PRSTATUS (prstatus structure)");
14190 return _("NT_FPREGSET (floating point registers)");
14192 return _("NT_PRPSINFO (prpsinfo structure)");
14193 case NT_TASKSTRUCT:
14194 return _("NT_TASKSTRUCT (task structure)");
14196 return _("NT_PRXFPREG (user_xfpregs structure)");
14198 return _("NT_PPC_VMX (ppc Altivec registers)");
14200 return _("NT_PPC_VSX (ppc VSX registers)");
14202 return _("NT_386_TLS (x86 TLS information)");
14203 case NT_386_IOPERM:
14204 return _("NT_386_IOPERM (x86 I/O permissions)");
14205 case NT_X86_XSTATE:
14206 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14207 case NT_S390_HIGH_GPRS:
14208 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14209 case NT_S390_TIMER:
14210 return _("NT_S390_TIMER (s390 timer register)");
14211 case NT_S390_TODCMP:
14212 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14213 case NT_S390_TODPREG:
14214 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14216 return _("NT_S390_CTRS (s390 control registers)");
14217 case NT_S390_PREFIX:
14218 return _("NT_S390_PREFIX (s390 prefix register)");
14219 case NT_S390_LAST_BREAK:
14220 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14221 case NT_S390_SYSTEM_CALL:
14222 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14224 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14226 return _("NT_ARM_VFP (arm VFP registers)");
14228 return _("NT_ARM_TLS (AArch TLS registers)");
14229 case NT_ARM_HW_BREAK:
14230 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14231 case NT_ARM_HW_WATCH:
14232 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14234 return _("NT_PSTATUS (pstatus structure)");
14236 return _("NT_FPREGS (floating point registers)");
14238 return _("NT_PSINFO (psinfo structure)");
14240 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14242 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14243 case NT_WIN32PSTATUS:
14244 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14246 return _("NT_SIGINFO (siginfo_t data)");
14248 return _("NT_FILE (mapped files)");
14256 return _("NT_VERSION (version)");
14258 return _("NT_ARCH (architecture)");
14263 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14268 print_core_note (Elf_Internal_Note *pnote)
14270 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14271 bfd_vma count, page_size;
14272 unsigned char *descdata, *filenames, *descend;
14274 if (pnote->type != NT_FILE)
14280 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14281 /* Still "successful". */
14286 if (pnote->descsz < 2 * addr_size)
14288 printf (_(" Malformed note - too short for header\n"));
14292 descdata = (unsigned char *) pnote->descdata;
14293 descend = descdata + pnote->descsz;
14295 if (descdata[pnote->descsz - 1] != '\0')
14297 printf (_(" Malformed note - does not end with \\0\n"));
14301 count = byte_get (descdata, addr_size);
14302 descdata += addr_size;
14304 page_size = byte_get (descdata, addr_size);
14305 descdata += addr_size;
14307 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14309 printf (_(" Malformed note - too short for supplied file count\n"));
14313 printf (_(" Page size: "));
14314 print_vma (page_size, DEC);
14317 printf (_(" %*s%*s%*s\n"),
14318 (int) (2 + 2 * addr_size), _("Start"),
14319 (int) (4 + 2 * addr_size), _("End"),
14320 (int) (4 + 2 * addr_size), _("Page Offset"));
14321 filenames = descdata + count * 3 * addr_size;
14322 while (--count > 0)
14324 bfd_vma start, end, file_ofs;
14326 if (filenames == descend)
14328 printf (_(" Malformed note - filenames end too early\n"));
14332 start = byte_get (descdata, addr_size);
14333 descdata += addr_size;
14334 end = byte_get (descdata, addr_size);
14335 descdata += addr_size;
14336 file_ofs = byte_get (descdata, addr_size);
14337 descdata += addr_size;
14340 print_vma (start, FULL_HEX);
14342 print_vma (end, FULL_HEX);
14344 print_vma (file_ofs, FULL_HEX);
14345 printf ("\n %s\n", filenames);
14347 filenames += 1 + strlen ((char *) filenames);
14353 static const char *
14354 get_gnu_elf_note_type (unsigned e_type)
14356 static char buff[64];
14360 case NT_GNU_ABI_TAG:
14361 return _("NT_GNU_ABI_TAG (ABI version tag)");
14363 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14364 case NT_GNU_BUILD_ID:
14365 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14366 case NT_GNU_GOLD_VERSION:
14367 return _("NT_GNU_GOLD_VERSION (gold version)");
14372 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14377 print_gnu_note (Elf_Internal_Note *pnote)
14379 switch (pnote->type)
14381 case NT_GNU_BUILD_ID:
14385 printf (_(" Build ID: "));
14386 for (i = 0; i < pnote->descsz; ++i)
14387 printf ("%02x", pnote->descdata[i] & 0xff);
14392 case NT_GNU_ABI_TAG:
14394 unsigned long os, major, minor, subminor;
14395 const char *osname;
14397 /* PR 17531: file: 030-599401-0.004. */
14398 if (pnote->descsz < 16)
14400 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14404 os = byte_get ((unsigned char *) pnote->descdata, 4);
14405 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14406 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14407 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14411 case GNU_ABI_TAG_LINUX:
14414 case GNU_ABI_TAG_HURD:
14417 case GNU_ABI_TAG_SOLARIS:
14418 osname = "Solaris";
14420 case GNU_ABI_TAG_FREEBSD:
14421 osname = "FreeBSD";
14423 case GNU_ABI_TAG_NETBSD:
14427 osname = "Unknown";
14431 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14432 major, minor, subminor);
14436 case NT_GNU_GOLD_VERSION:
14440 printf (_(" Version: "));
14441 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14442 printf ("%c", pnote->descdata[i]);
14451 static const char *
14452 get_netbsd_elfcore_note_type (unsigned e_type)
14454 static char buff[64];
14456 if (e_type == NT_NETBSDCORE_PROCINFO)
14458 /* NetBSD core "procinfo" structure. */
14459 return _("NetBSD procinfo structure");
14462 /* As of Jan 2002 there are no other machine-independent notes
14463 defined for NetBSD core files. If the note type is less
14464 than the start of the machine-dependent note types, we don't
14467 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14469 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14473 switch (elf_header.e_machine)
14475 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14476 and PT_GETFPREGS == mach+2. */
14481 case EM_SPARC32PLUS:
14485 case NT_NETBSDCORE_FIRSTMACH + 0:
14486 return _("PT_GETREGS (reg structure)");
14487 case NT_NETBSDCORE_FIRSTMACH + 2:
14488 return _("PT_GETFPREGS (fpreg structure)");
14494 /* On all other arch's, PT_GETREGS == mach+1 and
14495 PT_GETFPREGS == mach+3. */
14499 case NT_NETBSDCORE_FIRSTMACH + 1:
14500 return _("PT_GETREGS (reg structure)");
14501 case NT_NETBSDCORE_FIRSTMACH + 3:
14502 return _("PT_GETFPREGS (fpreg structure)");
14508 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14509 e_type - NT_NETBSDCORE_FIRSTMACH);
14513 static const char *
14514 get_stapsdt_note_type (unsigned e_type)
14516 static char buff[64];
14521 return _("NT_STAPSDT (SystemTap probe descriptors)");
14527 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14532 print_stapsdt_note (Elf_Internal_Note *pnote)
14534 int addr_size = is_32bit_elf ? 4 : 8;
14535 char *data = pnote->descdata;
14536 char *data_end = pnote->descdata + pnote->descsz;
14537 bfd_vma pc, base_addr, semaphore;
14538 char *provider, *probe, *arg_fmt;
14540 pc = byte_get ((unsigned char *) data, addr_size);
14542 base_addr = byte_get ((unsigned char *) data, addr_size);
14544 semaphore = byte_get ((unsigned char *) data, addr_size);
14548 data += strlen (data) + 1;
14550 data += strlen (data) + 1;
14552 data += strlen (data) + 1;
14554 printf (_(" Provider: %s\n"), provider);
14555 printf (_(" Name: %s\n"), probe);
14556 printf (_(" Location: "));
14557 print_vma (pc, FULL_HEX);
14558 printf (_(", Base: "));
14559 print_vma (base_addr, FULL_HEX);
14560 printf (_(", Semaphore: "));
14561 print_vma (semaphore, FULL_HEX);
14563 printf (_(" Arguments: %s\n"), arg_fmt);
14565 return data == data_end;
14568 static const char *
14569 get_ia64_vms_note_type (unsigned e_type)
14571 static char buff[64];
14576 return _("NT_VMS_MHD (module header)");
14578 return _("NT_VMS_LNM (language name)");
14580 return _("NT_VMS_SRC (source files)");
14582 return "NT_VMS_TITLE";
14584 return _("NT_VMS_EIDC (consistency check)");
14585 case NT_VMS_FPMODE:
14586 return _("NT_VMS_FPMODE (FP mode)");
14587 case NT_VMS_LINKTIME:
14588 return "NT_VMS_LINKTIME";
14589 case NT_VMS_IMGNAM:
14590 return _("NT_VMS_IMGNAM (image name)");
14592 return _("NT_VMS_IMGID (image id)");
14593 case NT_VMS_LINKID:
14594 return _("NT_VMS_LINKID (link id)");
14595 case NT_VMS_IMGBID:
14596 return _("NT_VMS_IMGBID (build id)");
14597 case NT_VMS_GSTNAM:
14598 return _("NT_VMS_GSTNAM (sym table name)");
14599 case NT_VMS_ORIG_DYN:
14600 return "NT_VMS_ORIG_DYN";
14601 case NT_VMS_PATCHTIME:
14602 return "NT_VMS_PATCHTIME";
14604 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14610 print_ia64_vms_note (Elf_Internal_Note * pnote)
14612 switch (pnote->type)
14615 if (pnote->descsz > 36)
14617 size_t l = strlen (pnote->descdata + 34);
14618 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14619 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14620 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14621 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14624 printf (_(" Invalid size\n"));
14627 printf (_(" Language: %s\n"), pnote->descdata);
14630 case NT_VMS_FPMODE:
14631 printf (_(" Floating Point mode: "));
14632 printf ("0x%016" BFD_VMA_FMT "x\n",
14633 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14635 case NT_VMS_LINKTIME:
14636 printf (_(" Link time: "));
14638 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14641 case NT_VMS_PATCHTIME:
14642 printf (_(" Patch time: "));
14644 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14647 case NT_VMS_ORIG_DYN:
14648 printf (_(" Major id: %u, minor id: %u\n"),
14649 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14650 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14651 printf (_(" Last modified : "));
14653 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14654 printf (_("\n Link flags : "));
14655 printf ("0x%016" BFD_VMA_FMT "x\n",
14656 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14657 printf (_(" Header flags: 0x%08x\n"),
14658 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14659 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14662 case NT_VMS_IMGNAM:
14663 printf (_(" Image name: %s\n"), pnote->descdata);
14665 case NT_VMS_GSTNAM:
14666 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14669 printf (_(" Image id: %s\n"), pnote->descdata);
14671 case NT_VMS_LINKID:
14672 printf (_(" Linker id: %s\n"), pnote->descdata);
14680 /* Note that by the ELF standard, the name field is already null byte
14681 terminated, and namesz includes the terminating null byte.
14682 I.E. the value of namesz for the name "FSF" is 4.
14684 If the value of namesz is zero, there is no name present. */
14686 process_note (Elf_Internal_Note * pnote)
14688 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14691 if (pnote->namesz == 0)
14692 /* If there is no note name, then use the default set of
14693 note type strings. */
14694 nt = get_note_type (pnote->type);
14696 else if (const_strneq (pnote->namedata, "GNU"))
14697 /* GNU-specific object file notes. */
14698 nt = get_gnu_elf_note_type (pnote->type);
14700 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14701 /* NetBSD-specific core file notes. */
14702 nt = get_netbsd_elfcore_note_type (pnote->type);
14704 else if (strneq (pnote->namedata, "SPU/", 4))
14706 /* SPU-specific core file notes. */
14707 nt = pnote->namedata + 4;
14711 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14712 /* VMS/ia64-specific file notes. */
14713 nt = get_ia64_vms_note_type (pnote->type);
14715 else if (const_strneq (pnote->namedata, "stapsdt"))
14716 nt = get_stapsdt_note_type (pnote->type);
14719 /* Don't recognize this note name; just use the default set of
14720 note type strings. */
14721 nt = get_note_type (pnote->type);
14723 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14725 if (const_strneq (pnote->namedata, "IPF/VMS"))
14726 return print_ia64_vms_note (pnote);
14727 else if (const_strneq (pnote->namedata, "GNU"))
14728 return print_gnu_note (pnote);
14729 else if (const_strneq (pnote->namedata, "stapsdt"))
14730 return print_stapsdt_note (pnote);
14731 else if (const_strneq (pnote->namedata, "CORE"))
14732 return print_core_note (pnote);
14739 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14741 Elf_External_Note * pnotes;
14742 Elf_External_Note * external;
14748 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14750 if (pnotes == NULL)
14755 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14756 (unsigned long) offset, (unsigned long) length);
14757 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14759 while ((char *) external < (char *) pnotes + length)
14761 Elf_Internal_Note inote;
14764 char * temp = NULL;
14765 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14767 if (!is_ia64_vms ())
14769 /* PR binutils/15191
14770 Make sure that there is enough data to read. */
14771 min_notesz = offsetof (Elf_External_Note, name);
14772 if (data_remaining < min_notesz)
14774 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14775 (int) data_remaining);
14778 inote.type = BYTE_GET (external->type);
14779 inote.namesz = BYTE_GET (external->namesz);
14780 inote.namedata = external->name;
14781 inote.descsz = BYTE_GET (external->descsz);
14782 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14783 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14784 next = inote.descdata + align_power (inote.descsz, 2);
14788 Elf64_External_VMS_Note *vms_external;
14790 /* PR binutils/15191
14791 Make sure that there is enough data to read. */
14792 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14793 if (data_remaining < min_notesz)
14795 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14796 (int) data_remaining);
14800 vms_external = (Elf64_External_VMS_Note *) external;
14801 inote.type = BYTE_GET (vms_external->type);
14802 inote.namesz = BYTE_GET (vms_external->namesz);
14803 inote.namedata = vms_external->name;
14804 inote.descsz = BYTE_GET (vms_external->descsz);
14805 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14806 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14807 next = inote.descdata + align_power (inote.descsz, 3);
14810 if (inote.descdata < (char *) external + min_notesz
14811 || next < (char *) external + min_notesz
14812 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14813 || inote.namedata + inote.namesz < inote.namedata
14814 || inote.descdata + inote.descsz < inote.descdata
14815 || data_remaining < (size_t)(next - (char *) external))
14817 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14818 (unsigned long) ((char *) external - (char *) pnotes));
14819 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14820 inote.type, inote.namesz, inote.descsz);
14824 external = (Elf_External_Note *) next;
14826 /* Verify that name is null terminated. It appears that at least
14827 one version of Linux (RedHat 6.0) generates corefiles that don't
14828 comply with the ELF spec by failing to include the null byte in
14830 if (inote.namedata[inote.namesz - 1] != '\0')
14832 temp = (char *) malloc (inote.namesz + 1);
14835 error (_("Out of memory allocating space for inote name\n"));
14840 strncpy (temp, inote.namedata, inote.namesz);
14841 temp[inote.namesz] = 0;
14843 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14844 inote.namedata = temp;
14847 res &= process_note (& inote);
14862 process_corefile_note_segments (FILE * file)
14864 Elf_Internal_Phdr * segment;
14868 if (! get_program_headers (file))
14871 for (i = 0, segment = program_headers;
14872 i < elf_header.e_phnum;
14875 if (segment->p_type == PT_NOTE)
14876 res &= process_corefile_note_segment (file,
14877 (bfd_vma) segment->p_offset,
14878 (bfd_vma) segment->p_filesz);
14885 process_note_sections (FILE * file)
14887 Elf_Internal_Shdr * section;
14892 for (i = 0, section = section_headers;
14893 i < elf_header.e_shnum && section != NULL;
14895 if (section->sh_type == SHT_NOTE)
14897 res &= process_corefile_note_segment (file,
14898 (bfd_vma) section->sh_offset,
14899 (bfd_vma) section->sh_size);
14904 /* Try processing NOTE segments instead. */
14905 return process_corefile_note_segments (file);
14911 process_notes (FILE * file)
14913 /* If we have not been asked to display the notes then do nothing. */
14917 if (elf_header.e_type != ET_CORE)
14918 return process_note_sections (file);
14920 /* No program headers means no NOTE segment. */
14921 if (elf_header.e_phnum > 0)
14922 return process_corefile_note_segments (file);
14924 printf (_("No note segments present in the core file.\n"));
14929 process_arch_specific (FILE * file)
14934 switch (elf_header.e_machine)
14937 return process_arm_specific (file);
14939 case EM_MIPS_RS3_LE:
14940 return process_mips_specific (file);
14943 return process_nds32_specific (file);
14946 return process_power_specific (file);
14949 case EM_SPARC32PLUS:
14951 return process_sparc_specific (file);
14954 return process_tic6x_specific (file);
14957 return process_msp430x_specific (file);
14965 get_file_header (FILE * file)
14967 /* Read in the identity array. */
14968 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14971 /* Determine how to read the rest of the header. */
14972 switch (elf_header.e_ident[EI_DATA])
14974 default: /* fall through */
14975 case ELFDATANONE: /* fall through */
14977 byte_get = byte_get_little_endian;
14978 byte_put = byte_put_little_endian;
14981 byte_get = byte_get_big_endian;
14982 byte_put = byte_put_big_endian;
14986 /* For now we only support 32 bit and 64 bit ELF files. */
14987 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14989 /* Read in the rest of the header. */
14992 Elf32_External_Ehdr ehdr32;
14994 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14997 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14998 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14999 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15000 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15001 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15002 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15003 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15004 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15005 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15006 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15007 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15008 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15009 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15013 Elf64_External_Ehdr ehdr64;
15015 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15016 we will not be able to cope with the 64bit data found in
15017 64 ELF files. Detect this now and abort before we start
15018 overwriting things. */
15019 if (sizeof (bfd_vma) < 8)
15021 error (_("This instance of readelf has been built without support for a\n\
15022 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15026 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15029 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15030 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15031 elf_header.e_version = BYTE_GET (ehdr64.e_version);
15032 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15033 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15034 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
15035 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15036 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15037 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15038 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15039 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15040 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15041 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15044 if (elf_header.e_shoff)
15046 /* There may be some extensions in the first section header. Don't
15047 bomb if we can't read it. */
15049 get_32bit_section_headers (file, TRUE);
15051 get_64bit_section_headers (file, TRUE);
15057 /* Process one ELF object file according to the command line options.
15058 This file may actually be stored in an archive. The file is
15059 positioned at the start of the ELF object. */
15062 process_object (char * file_name, FILE * file)
15066 if (! get_file_header (file))
15068 error (_("%s: Failed to read file header\n"), file_name);
15072 /* Initialise per file variables. */
15073 for (i = ARRAY_SIZE (version_info); i--;)
15074 version_info[i] = 0;
15076 for (i = ARRAY_SIZE (dynamic_info); i--;)
15077 dynamic_info[i] = 0;
15078 dynamic_info_DT_GNU_HASH = 0;
15080 /* Process the file. */
15082 printf (_("\nFile: %s\n"), file_name);
15084 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15085 Note we do this even if cmdline_dump_sects is empty because we
15086 must make sure that the dump_sets array is zeroed out before each
15087 object file is processed. */
15088 if (num_dump_sects > num_cmdline_dump_sects)
15089 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15091 if (num_cmdline_dump_sects > 0)
15093 if (num_dump_sects == 0)
15094 /* A sneaky way of allocating the dump_sects array. */
15095 request_dump_bynumber (num_cmdline_dump_sects, 0);
15097 assert (num_dump_sects >= num_cmdline_dump_sects);
15098 memcpy (dump_sects, cmdline_dump_sects,
15099 num_cmdline_dump_sects * sizeof (* dump_sects));
15102 if (! process_file_header ())
15105 if (! process_section_headers (file))
15107 /* Without loaded section headers we cannot process lots of
15109 do_unwind = do_version = do_dump = do_arch = 0;
15111 if (! do_using_dynamic)
15112 do_syms = do_dyn_syms = do_reloc = 0;
15115 if (! process_section_groups (file))
15117 /* Without loaded section groups we cannot process unwind. */
15121 if (process_program_headers (file))
15122 process_dynamic_section (file);
15124 process_relocs (file);
15126 process_unwind (file);
15128 process_symbol_table (file);
15130 process_syminfo (file);
15132 process_version_sections (file);
15134 process_section_contents (file);
15136 process_notes (file);
15138 process_gnu_liblist (file);
15140 process_arch_specific (file);
15142 if (program_headers)
15144 free (program_headers);
15145 program_headers = NULL;
15148 if (section_headers)
15150 free (section_headers);
15151 section_headers = NULL;
15156 free (string_table);
15157 string_table = NULL;
15158 string_table_length = 0;
15161 if (dynamic_strings)
15163 free (dynamic_strings);
15164 dynamic_strings = NULL;
15165 dynamic_strings_length = 0;
15168 if (dynamic_symbols)
15170 free (dynamic_symbols);
15171 dynamic_symbols = NULL;
15172 num_dynamic_syms = 0;
15175 if (dynamic_syminfo)
15177 free (dynamic_syminfo);
15178 dynamic_syminfo = NULL;
15181 if (dynamic_section)
15183 free (dynamic_section);
15184 dynamic_section = NULL;
15187 if (section_headers_groups)
15189 free (section_headers_groups);
15190 section_headers_groups = NULL;
15193 if (section_groups)
15195 struct group_list * g;
15196 struct group_list * next;
15198 for (i = 0; i < group_count; i++)
15200 for (g = section_groups [i].root; g != NULL; g = next)
15207 free (section_groups);
15208 section_groups = NULL;
15211 free_debug_memory ();
15216 /* Process an ELF archive.
15217 On entry the file is positioned just after the ARMAG string. */
15220 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15222 struct archive_info arch;
15223 struct archive_info nested_arch;
15229 /* The ARCH structure is used to hold information about this archive. */
15230 arch.file_name = NULL;
15232 arch.index_array = NULL;
15233 arch.sym_table = NULL;
15234 arch.longnames = NULL;
15236 /* The NESTED_ARCH structure is used as a single-item cache of information
15237 about a nested archive (when members of a thin archive reside within
15238 another regular archive file). */
15239 nested_arch.file_name = NULL;
15240 nested_arch.file = NULL;
15241 nested_arch.index_array = NULL;
15242 nested_arch.sym_table = NULL;
15243 nested_arch.longnames = NULL;
15245 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15251 if (do_archive_index)
15253 if (arch.sym_table == NULL)
15254 error (_("%s: unable to dump the index as none was found\n"), file_name);
15258 unsigned long current_pos;
15260 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
15261 file_name, (long) arch.index_num, arch.sym_size);
15262 current_pos = ftell (file);
15264 for (i = l = 0; i < arch.index_num; i++)
15266 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15268 char * member_name;
15270 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15272 if (member_name != NULL)
15274 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15276 if (qualified_name != NULL)
15278 printf (_("Contents of binary %s at offset "), qualified_name);
15279 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15281 free (qualified_name);
15286 if (l >= arch.sym_size)
15288 error (_("%s: end of the symbol table reached before the end of the index\n"),
15292 printf ("\t%s\n", arch.sym_table + l);
15293 l += strlen (arch.sym_table + l) + 1;
15296 if (arch.uses_64bit_indicies)
15301 if (l < arch.sym_size)
15302 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15303 file_name, arch.sym_size - l);
15305 if (fseek (file, current_pos, SEEK_SET) != 0)
15307 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15313 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15314 && !do_segments && !do_header && !do_dump && !do_version
15315 && !do_histogram && !do_debugging && !do_arch && !do_notes
15316 && !do_section_groups && !do_dyn_syms)
15318 ret = 0; /* Archive index only. */
15329 char * qualified_name;
15331 /* Read the next archive header. */
15332 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15334 error (_("%s: failed to seek to next archive header\n"), file_name);
15337 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15338 if (got != sizeof arch.arhdr)
15342 error (_("%s: failed to read archive header\n"), file_name);
15346 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15348 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15353 arch.next_arhdr_offset += sizeof arch.arhdr;
15355 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15356 if (archive_file_size & 01)
15357 ++archive_file_size;
15359 name = get_archive_member_name (&arch, &nested_arch);
15362 error (_("%s: bad archive file name\n"), file_name);
15366 namelen = strlen (name);
15368 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15369 if (qualified_name == NULL)
15371 error (_("%s: bad archive file name\n"), file_name);
15376 if (is_thin_archive && arch.nested_member_origin == 0)
15378 /* This is a proxy for an external member of a thin archive. */
15379 FILE * member_file;
15380 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15381 if (member_file_name == NULL)
15387 member_file = fopen (member_file_name, "rb");
15388 if (member_file == NULL)
15390 error (_("Input file '%s' is not readable.\n"), member_file_name);
15391 free (member_file_name);
15396 archive_file_offset = arch.nested_member_origin;
15398 ret |= process_object (qualified_name, member_file);
15400 fclose (member_file);
15401 free (member_file_name);
15403 else if (is_thin_archive)
15405 /* PR 15140: Allow for corrupt thin archives. */
15406 if (nested_arch.file == NULL)
15408 error (_("%s: contains corrupt thin archive: %s\n"),
15414 /* This is a proxy for a member of a nested archive. */
15415 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15417 /* The nested archive file will have been opened and setup by
15418 get_archive_member_name. */
15419 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15421 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15426 ret |= process_object (qualified_name, nested_arch.file);
15430 archive_file_offset = arch.next_arhdr_offset;
15431 arch.next_arhdr_offset += archive_file_size;
15433 ret |= process_object (qualified_name, file);
15436 if (dump_sects != NULL)
15440 num_dump_sects = 0;
15443 free (qualified_name);
15447 if (nested_arch.file != NULL)
15448 fclose (nested_arch.file);
15449 release_archive (&nested_arch);
15450 release_archive (&arch);
15456 process_file (char * file_name)
15459 struct stat statbuf;
15460 char armag[SARMAG];
15463 if (stat (file_name, &statbuf) < 0)
15465 if (errno == ENOENT)
15466 error (_("'%s': No such file\n"), file_name);
15468 error (_("Could not locate '%s'. System error message: %s\n"),
15469 file_name, strerror (errno));
15473 if (! S_ISREG (statbuf.st_mode))
15475 error (_("'%s' is not an ordinary file\n"), file_name);
15479 file = fopen (file_name, "rb");
15482 error (_("Input file '%s' is not readable.\n"), file_name);
15486 if (fread (armag, SARMAG, 1, file) != 1)
15488 error (_("%s: Failed to read file's magic number\n"), file_name);
15493 current_file_size = (bfd_size_type) statbuf.st_size;
15495 if (memcmp (armag, ARMAG, SARMAG) == 0)
15496 ret = process_archive (file_name, file, FALSE);
15497 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15498 ret = process_archive (file_name, file, TRUE);
15501 if (do_archive_index)
15502 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15506 archive_file_size = archive_file_offset = 0;
15507 ret = process_object (file_name, file);
15512 current_file_size = 0;
15516 #ifdef SUPPORT_DISASSEMBLY
15517 /* Needed by the i386 disassembler. For extra credit, someone could
15518 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15522 print_address (unsigned int addr, FILE * outfile)
15524 fprintf (outfile,"0x%8.8x", addr);
15527 /* Needed by the i386 disassembler. */
15529 db_task_printsym (unsigned int addr)
15531 print_address (addr, stderr);
15536 main (int argc, char ** argv)
15540 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15541 setlocale (LC_MESSAGES, "");
15543 #if defined (HAVE_SETLOCALE)
15544 setlocale (LC_CTYPE, "");
15546 bindtextdomain (PACKAGE, LOCALEDIR);
15547 textdomain (PACKAGE);
15549 expandargv (&argc, &argv);
15551 parse_args (argc, argv);
15553 if (num_dump_sects > 0)
15555 /* Make a copy of the dump_sects array. */
15556 cmdline_dump_sects = (dump_type *)
15557 malloc (num_dump_sects * sizeof (* dump_sects));
15558 if (cmdline_dump_sects == NULL)
15559 error (_("Out of memory allocating dump request table.\n"));
15562 memcpy (cmdline_dump_sects, dump_sects,
15563 num_dump_sects * sizeof (* dump_sects));
15564 num_cmdline_dump_sects = num_dump_sects;
15568 if (optind < (argc - 1))
15572 while (optind < argc)
15573 err |= process_file (argv[optind++]);
15575 if (dump_sects != NULL)
15577 if (cmdline_dump_sects != NULL)
15578 free (cmdline_dump_sects);