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 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 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
318 using malloc and fill that. In either case return the pointer to the start of
319 the retrieved data or NULL if something went wrong. If something does go wrong
320 emit an error message using REASON as part of the context. */
323 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
328 if (size == 0 || nmemb == 0)
331 if (fseek (file, archive_file_offset + offset, SEEK_SET))
334 error (_("Unable to seek to 0x%lx for %s\n"),
335 (unsigned long) archive_file_offset + offset, reason);
339 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
340 attempting to allocate memory when the read is bound to fail. */
341 if (offset + archive_file_offset + size * nmemb > current_file_size)
344 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
345 (unsigned long) (size * nmemb), reason);
352 /* Check for overflow. */
353 if (nmemb < (~(size_t) 0 - 1) / size)
354 /* + 1 so that we can '\0' terminate invalid string table sections. */
355 mvar = malloc (size * nmemb + 1);
360 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
361 (unsigned long)(size * nmemb), reason);
365 ((char *) mvar)[size * nmemb] = '\0';
368 if (fread (mvar, size, nmemb, file) != nmemb)
371 error (_("Unable to read in 0x%lx bytes of %s\n"),
372 (unsigned long)(size * nmemb), reason);
381 /* Print a VMA value. */
384 print_vma (bfd_vma vma, print_mode mode)
397 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
404 return printf ("%5" BFD_VMA_FMT "d", vma);
412 return nc + printf ("%" BFD_VMA_FMT "x", vma);
415 return printf ("%" BFD_VMA_FMT "d", vma);
418 return printf ("%" BFD_VMA_FMT "u", vma);
423 /* Display a symbol on stdout. Handles the display of control characters and
424 multibye characters (assuming the host environment supports them).
426 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
428 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
429 padding as necessary.
431 Returns the number of emitted characters. */
434 print_symbol (int width, const char *symbol)
436 bfd_boolean extra_padding = FALSE;
438 #ifdef HAVE_MBSTATE_T
445 /* Keep the width positive. This also helps. */
447 extra_padding = TRUE;
452 /* Set the remaining width to a very large value.
453 This simplifies the code below. */
454 width_remaining = INT_MAX;
456 width_remaining = width;
458 #ifdef HAVE_MBSTATE_T
459 /* Initialise the multibyte conversion state. */
460 memset (& state, 0, sizeof (state));
463 while (width_remaining)
466 const char c = *symbol++;
471 /* Do not print control characters directly as they can affect terminal
472 settings. Such characters usually appear in the names generated
473 by the assembler for local labels. */
476 if (width_remaining < 2)
479 printf ("^%c", c + 0x40);
480 width_remaining -= 2;
483 else if (ISPRINT (c))
491 #ifdef HAVE_MBSTATE_T
494 /* Let printf do the hard work of displaying multibyte characters. */
495 printf ("%.1s", symbol - 1);
499 #ifdef HAVE_MBSTATE_T
500 /* Try to find out how many bytes made up the character that was
501 just printed. Advance the symbol pointer past the bytes that
503 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
507 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
512 if (extra_padding && num_printed < width)
514 /* Fill in the remaining spaces. */
515 printf ("%-*s", width - num_printed, " ");
522 /* Returns a pointer to a static buffer containing a printable version of
523 the given section's name. Like print_symbol, except that it does not try
524 to print multibyte characters, it just interprets them as hex values. */
527 printable_section_name (Elf_Internal_Shdr * sec)
529 #define MAX_PRINT_SEC_NAME_LEN 128
530 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
531 const char * name = SECTION_NAME (sec);
532 char * buf = sec_name_buf;
534 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
536 while ((c = * name ++) != 0)
547 else if (ISPRINT (c))
554 static char hex[17] = "0123456789ABCDEF";
559 * buf ++ = hex[(c & 0xf0) >> 4];
560 * buf ++ = hex[c & 0x0f];
574 printable_section_name_from_index (unsigned long ndx)
576 if (ndx >= elf_header.e_shnum)
577 return _("<corrupt>");
579 return printable_section_name (section_headers + ndx);
582 /* Return a pointer to section NAME, or NULL if no such section exists. */
584 static Elf_Internal_Shdr *
585 find_section (const char * name)
589 for (i = 0; i < elf_header.e_shnum; i++)
590 if (streq (SECTION_NAME (section_headers + i), name))
591 return section_headers + i;
596 /* Return a pointer to a section containing ADDR, or NULL if no such
599 static Elf_Internal_Shdr *
600 find_section_by_address (bfd_vma addr)
604 for (i = 0; i < elf_header.e_shnum; i++)
606 Elf_Internal_Shdr *sec = section_headers + i;
607 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
614 static Elf_Internal_Shdr *
615 find_section_by_type (unsigned int type)
619 for (i = 0; i < elf_header.e_shnum; i++)
621 Elf_Internal_Shdr *sec = section_headers + i;
622 if (sec->sh_type == type)
629 /* Return a pointer to section NAME, or NULL if no such section exists,
630 restricted to the list of sections given in SET. */
632 static Elf_Internal_Shdr *
633 find_section_in_set (const char * name, unsigned int * set)
639 while ((i = *set++) > 0)
640 if (streq (SECTION_NAME (section_headers + i), name))
641 return section_headers + i;
644 return find_section (name);
647 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
650 static inline unsigned long
651 read_uleb128 (unsigned char *data,
652 unsigned int *length_return,
653 const unsigned char * const end)
655 return read_leb128 (data, length_return, FALSE, end);
658 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
659 This OS has so many departures from the ELF standard that we test it at
665 return elf_header.e_machine == EM_IA_64
666 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
669 /* Guess the relocation size commonly used by the specific machines. */
672 guess_is_rela (unsigned int e_machine)
676 /* Targets that use REL relocations. */
691 /* Targets that use RELA relocations. */
695 case EM_ADAPTEVA_EPIPHANY:
697 case EM_ALTERA_NIOS2:
716 case EM_LATTICEMICO32:
725 case EM_CYGNUS_MN10200:
727 case EM_CYGNUS_MN10300:
760 case EM_MICROBLAZE_OLD:
781 warn (_("Don't know about relocations on this machine architecture\n"));
787 slurp_rela_relocs (FILE * file,
788 unsigned long rel_offset,
789 unsigned long rel_size,
790 Elf_Internal_Rela ** relasp,
791 unsigned long * nrelasp)
793 Elf_Internal_Rela * relas;
799 Elf32_External_Rela * erelas;
801 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
802 rel_size, _("32-bit relocation data"));
806 nrelas = rel_size / sizeof (Elf32_External_Rela);
808 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
809 sizeof (Elf_Internal_Rela));
814 error (_("out of memory parsing relocs\n"));
818 for (i = 0; i < nrelas; i++)
820 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
821 relas[i].r_info = BYTE_GET (erelas[i].r_info);
822 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
829 Elf64_External_Rela * erelas;
831 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
832 rel_size, _("64-bit relocation data"));
836 nrelas = rel_size / sizeof (Elf64_External_Rela);
838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
844 error (_("out of memory parsing relocs\n"));
848 for (i = 0; i < nrelas; i++)
850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
854 /* The #ifdef BFD64 below is to prevent a compile time
855 warning. We know that if we do not have a 64 bit data
856 type that we will never execute this code anyway. */
858 if (elf_header.e_machine == EM_MIPS
859 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
861 /* In little-endian objects, r_info isn't really a
862 64-bit little-endian value: it has a 32-bit
863 little-endian symbol index followed by four
864 individual byte fields. Reorder INFO
866 bfd_vma inf = relas[i].r_info;
867 inf = (((inf & 0xffffffff) << 32)
868 | ((inf >> 56) & 0xff)
869 | ((inf >> 40) & 0xff00)
870 | ((inf >> 24) & 0xff0000)
871 | ((inf >> 8) & 0xff000000));
872 relas[i].r_info = inf;
885 slurp_rel_relocs (FILE * file,
886 unsigned long rel_offset,
887 unsigned long rel_size,
888 Elf_Internal_Rela ** relsp,
889 unsigned long * nrelsp)
891 Elf_Internal_Rela * rels;
897 Elf32_External_Rel * erels;
899 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
900 rel_size, _("32-bit relocation data"));
904 nrels = rel_size / sizeof (Elf32_External_Rel);
906 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
911 error (_("out of memory parsing relocs\n"));
915 for (i = 0; i < nrels; i++)
917 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
918 rels[i].r_info = BYTE_GET (erels[i].r_info);
919 rels[i].r_addend = 0;
926 Elf64_External_Rel * erels;
928 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
929 rel_size, _("64-bit relocation data"));
933 nrels = rel_size / sizeof (Elf64_External_Rel);
935 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
940 error (_("out of memory parsing relocs\n"));
944 for (i = 0; i < nrels; i++)
946 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
947 rels[i].r_info = BYTE_GET (erels[i].r_info);
948 rels[i].r_addend = 0;
950 /* The #ifdef BFD64 below is to prevent a compile time
951 warning. We know that if we do not have a 64 bit data
952 type that we will never execute this code anyway. */
954 if (elf_header.e_machine == EM_MIPS
955 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
957 /* In little-endian objects, r_info isn't really a
958 64-bit little-endian value: it has a 32-bit
959 little-endian symbol index followed by four
960 individual byte fields. Reorder INFO
962 bfd_vma inf = rels[i].r_info;
963 inf = (((inf & 0xffffffff) << 32)
964 | ((inf >> 56) & 0xff)
965 | ((inf >> 40) & 0xff00)
966 | ((inf >> 24) & 0xff0000)
967 | ((inf >> 8) & 0xff000000));
968 rels[i].r_info = inf;
980 /* Returns the reloc type extracted from the reloc info field. */
983 get_reloc_type (bfd_vma reloc_info)
986 return ELF32_R_TYPE (reloc_info);
988 switch (elf_header.e_machine)
991 /* Note: We assume that reloc_info has already been adjusted for us. */
992 return ELF64_MIPS_R_TYPE (reloc_info);
995 return ELF64_R_TYPE_ID (reloc_info);
998 return ELF64_R_TYPE (reloc_info);
1002 /* Return the symbol index extracted from the reloc info field. */
1005 get_reloc_symindex (bfd_vma reloc_info)
1007 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1010 static inline bfd_boolean
1011 uses_msp430x_relocs (void)
1014 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1015 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1016 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1017 /* TI compiler uses ELFOSABI_NONE. */
1018 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1021 /* Display the contents of the relocation data found at the specified
1025 dump_relocations (FILE * file,
1026 unsigned long rel_offset,
1027 unsigned long rel_size,
1028 Elf_Internal_Sym * symtab,
1029 unsigned long nsyms,
1031 unsigned long strtablen,
1036 Elf_Internal_Rela * rels;
1038 if (is_rela == UNKNOWN)
1039 is_rela = guess_is_rela (elf_header.e_machine);
1043 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1048 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1057 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1059 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1064 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1066 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1074 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1076 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1081 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1083 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1087 for (i = 0; i < rel_size; i++)
1092 bfd_vma symtab_index;
1095 offset = rels[i].r_offset;
1096 inf = rels[i].r_info;
1098 type = get_reloc_type (inf);
1099 symtab_index = get_reloc_symindex (inf);
1103 printf ("%8.8lx %8.8lx ",
1104 (unsigned long) offset & 0xffffffff,
1105 (unsigned long) inf & 0xffffffff);
1109 #if BFD_HOST_64BIT_LONG
1111 ? "%16.16lx %16.16lx "
1112 : "%12.12lx %12.12lx ",
1114 #elif BFD_HOST_64BIT_LONG_LONG
1117 ? "%16.16llx %16.16llx "
1118 : "%12.12llx %12.12llx ",
1122 ? "%16.16I64x %16.16I64x "
1123 : "%12.12I64x %12.12I64x ",
1128 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1129 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1130 _bfd_int64_high (offset),
1131 _bfd_int64_low (offset),
1132 _bfd_int64_high (inf),
1133 _bfd_int64_low (inf));
1137 switch (elf_header.e_machine)
1144 rtype = elf_aarch64_reloc_type (type);
1148 case EM_CYGNUS_M32R:
1149 rtype = elf_m32r_reloc_type (type);
1154 rtype = elf_i386_reloc_type (type);
1159 rtype = elf_m68hc11_reloc_type (type);
1163 rtype = elf_m68k_reloc_type (type);
1167 rtype = elf_i960_reloc_type (type);
1172 rtype = elf_avr_reloc_type (type);
1175 case EM_OLD_SPARCV9:
1176 case EM_SPARC32PLUS:
1179 rtype = elf_sparc_reloc_type (type);
1183 rtype = elf_spu_reloc_type (type);
1187 rtype = v800_reloc_type (type);
1190 case EM_CYGNUS_V850:
1191 rtype = v850_reloc_type (type);
1195 case EM_CYGNUS_D10V:
1196 rtype = elf_d10v_reloc_type (type);
1200 case EM_CYGNUS_D30V:
1201 rtype = elf_d30v_reloc_type (type);
1205 rtype = elf_dlx_reloc_type (type);
1209 rtype = elf_sh_reloc_type (type);
1213 case EM_CYGNUS_MN10300:
1214 rtype = elf_mn10300_reloc_type (type);
1218 case EM_CYGNUS_MN10200:
1219 rtype = elf_mn10200_reloc_type (type);
1223 case EM_CYGNUS_FR30:
1224 rtype = elf_fr30_reloc_type (type);
1228 rtype = elf_frv_reloc_type (type);
1232 rtype = elf_mcore_reloc_type (type);
1236 rtype = elf_mmix_reloc_type (type);
1240 rtype = elf_moxie_reloc_type (type);
1244 if (uses_msp430x_relocs ())
1246 rtype = elf_msp430x_reloc_type (type);
1250 rtype = elf_msp430_reloc_type (type);
1254 rtype = elf_nds32_reloc_type (type);
1258 rtype = elf_ppc_reloc_type (type);
1262 rtype = elf_ppc64_reloc_type (type);
1266 case EM_MIPS_RS3_LE:
1267 rtype = elf_mips_reloc_type (type);
1271 rtype = elf_alpha_reloc_type (type);
1275 rtype = elf_arm_reloc_type (type);
1279 rtype = elf_arc_reloc_type (type);
1283 rtype = elf_hppa_reloc_type (type);
1289 rtype = elf_h8_reloc_type (type);
1293 rtype = elf_or1k_reloc_type (type);
1298 rtype = elf_pj_reloc_type (type);
1301 rtype = elf_ia64_reloc_type (type);
1305 rtype = elf_cris_reloc_type (type);
1309 rtype = elf_i860_reloc_type (type);
1315 rtype = elf_x86_64_reloc_type (type);
1319 rtype = i370_reloc_type (type);
1324 rtype = elf_s390_reloc_type (type);
1328 rtype = elf_score_reloc_type (type);
1332 rtype = elf_xstormy16_reloc_type (type);
1336 rtype = elf_crx_reloc_type (type);
1340 rtype = elf_vax_reloc_type (type);
1343 case EM_ADAPTEVA_EPIPHANY:
1344 rtype = elf_epiphany_reloc_type (type);
1349 rtype = elf_ip2k_reloc_type (type);
1353 rtype = elf_iq2000_reloc_type (type);
1358 rtype = elf_xtensa_reloc_type (type);
1361 case EM_LATTICEMICO32:
1362 rtype = elf_lm32_reloc_type (type);
1367 rtype = elf_m32c_reloc_type (type);
1371 rtype = elf_mt_reloc_type (type);
1375 rtype = elf_bfin_reloc_type (type);
1379 rtype = elf_mep_reloc_type (type);
1383 rtype = elf_cr16_reloc_type (type);
1387 case EM_MICROBLAZE_OLD:
1388 rtype = elf_microblaze_reloc_type (type);
1392 rtype = elf_rl78_reloc_type (type);
1396 rtype = elf_rx_reloc_type (type);
1400 rtype = elf_metag_reloc_type (type);
1405 rtype = elf_xc16x_reloc_type (type);
1409 rtype = elf_tic6x_reloc_type (type);
1413 rtype = elf_tilegx_reloc_type (type);
1417 rtype = elf_tilepro_reloc_type (type);
1421 rtype = elf_xgate_reloc_type (type);
1424 case EM_ALTERA_NIOS2:
1425 rtype = elf_nios2_reloc_type (type);
1430 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1432 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1434 if (elf_header.e_machine == EM_ALPHA
1436 && streq (rtype, "R_ALPHA_LITUSE")
1439 switch (rels[i].r_addend)
1441 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1442 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1443 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1444 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1445 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1446 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1447 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1448 default: rtype = NULL;
1451 printf (" (%s)", rtype);
1455 printf (_("<unknown addend: %lx>"),
1456 (unsigned long) rels[i].r_addend);
1459 else if (symtab_index)
1461 if (symtab == NULL || symtab_index >= nsyms)
1462 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1465 Elf_Internal_Sym * psym;
1466 const char * version_string;
1467 enum versioned_symbol_info sym_info;
1468 unsigned short vna_other;
1470 psym = symtab + symtab_index;
1473 = get_symbol_version_string (file, is_dynsym,
1482 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1486 unsigned int width = is_32bit_elf ? 8 : 14;
1488 /* Relocations against GNU_IFUNC symbols do not use the value
1489 of the symbol as the address to relocate against. Instead
1490 they invoke the function named by the symbol and use its
1491 result as the address for relocation.
1493 To indicate this to the user, do not display the value of
1494 the symbol in the "Symbols's Value" field. Instead show
1495 its name followed by () as a hint that the symbol is
1499 || psym->st_name == 0
1500 || psym->st_name >= strtablen)
1503 name = strtab + psym->st_name;
1505 len = print_symbol (width, name);
1507 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1509 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1513 print_vma (psym->st_value, LONG_HEX);
1515 printf (is_32bit_elf ? " " : " ");
1518 if (psym->st_name == 0)
1520 const char * sec_name = "<null>";
1523 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1525 if (psym->st_shndx < elf_header.e_shnum)
1526 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1527 else if (psym->st_shndx == SHN_ABS)
1529 else if (psym->st_shndx == SHN_COMMON)
1530 sec_name = "COMMON";
1531 else if ((elf_header.e_machine == EM_MIPS
1532 && psym->st_shndx == SHN_MIPS_SCOMMON)
1533 || (elf_header.e_machine == EM_TI_C6000
1534 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1535 sec_name = "SCOMMON";
1536 else if (elf_header.e_machine == EM_MIPS
1537 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1538 sec_name = "SUNDEF";
1539 else if ((elf_header.e_machine == EM_X86_64
1540 || elf_header.e_machine == EM_L1OM
1541 || elf_header.e_machine == EM_K1OM)
1542 && psym->st_shndx == SHN_X86_64_LCOMMON)
1543 sec_name = "LARGE_COMMON";
1544 else if (elf_header.e_machine == EM_IA_64
1545 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1546 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1547 sec_name = "ANSI_COM";
1548 else if (is_ia64_vms ()
1549 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1550 sec_name = "VMS_SYMVEC";
1553 sprintf (name_buf, "<section 0x%x>",
1554 (unsigned int) psym->st_shndx);
1555 sec_name = name_buf;
1558 print_symbol (22, sec_name);
1560 else if (strtab == NULL)
1561 printf (_("<string table index: %3ld>"), psym->st_name);
1562 else if (psym->st_name >= strtablen)
1563 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1566 print_symbol (22, strtab + psym->st_name);
1568 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1574 bfd_signed_vma off = rels[i].r_addend;
1577 printf (" - %" BFD_VMA_FMT "x", - off);
1579 printf (" + %" BFD_VMA_FMT "x", off);
1585 bfd_signed_vma off = rels[i].r_addend;
1587 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1589 printf ("-%" BFD_VMA_FMT "x", - off);
1591 printf ("%" BFD_VMA_FMT "x", off);
1594 if (elf_header.e_machine == EM_SPARCV9
1596 && streq (rtype, "R_SPARC_OLO10"))
1597 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1602 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1604 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1605 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1606 const char * rtype2 = elf_mips_reloc_type (type2);
1607 const char * rtype3 = elf_mips_reloc_type (type3);
1609 printf (" Type2: ");
1612 printf (_("unrecognized: %-7lx"),
1613 (unsigned long) type2 & 0xffffffff);
1615 printf ("%-17.17s", rtype2);
1617 printf ("\n Type3: ");
1620 printf (_("unrecognized: %-7lx"),
1621 (unsigned long) type3 & 0xffffffff);
1623 printf ("%-17.17s", rtype3);
1634 get_mips_dynamic_type (unsigned long type)
1638 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1639 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1640 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1641 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1642 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1643 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1644 case DT_MIPS_MSYM: return "MIPS_MSYM";
1645 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1646 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1647 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1648 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1649 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1650 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1651 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1652 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1653 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1654 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1655 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1656 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1657 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1658 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1659 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1660 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1661 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1662 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1663 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1664 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1665 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1666 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1667 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1668 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1669 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1670 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1671 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1672 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1673 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1674 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1675 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1676 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1677 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1678 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1679 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1680 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1681 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1682 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1689 get_sparc64_dynamic_type (unsigned long type)
1693 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1700 get_ppc_dynamic_type (unsigned long type)
1704 case DT_PPC_GOT: return "PPC_GOT";
1705 case DT_PPC_OPT: return "PPC_OPT";
1712 get_ppc64_dynamic_type (unsigned long type)
1716 case DT_PPC64_GLINK: return "PPC64_GLINK";
1717 case DT_PPC64_OPD: return "PPC64_OPD";
1718 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1719 case DT_PPC64_OPT: return "PPC64_OPT";
1726 get_parisc_dynamic_type (unsigned long type)
1730 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1731 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1732 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1733 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1734 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1735 case DT_HP_PREINIT: return "HP_PREINIT";
1736 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1737 case DT_HP_NEEDED: return "HP_NEEDED";
1738 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1739 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1740 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1741 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1742 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1743 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1744 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1745 case DT_HP_FILTERED: return "HP_FILTERED";
1746 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1747 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1748 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1749 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1750 case DT_PLT: return "PLT";
1751 case DT_PLT_SIZE: return "PLT_SIZE";
1752 case DT_DLT: return "DLT";
1753 case DT_DLT_SIZE: return "DLT_SIZE";
1760 get_ia64_dynamic_type (unsigned long type)
1764 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1765 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1766 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1767 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1768 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1769 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1770 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1771 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1772 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1773 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1774 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1775 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1776 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1777 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1778 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1779 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1780 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1781 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1782 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1783 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1784 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1785 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1786 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1787 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1788 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1789 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1790 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1791 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1792 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1793 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1794 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1801 get_alpha_dynamic_type (unsigned long type)
1805 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1812 get_score_dynamic_type (unsigned long type)
1816 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1817 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1818 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1819 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1820 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1821 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1828 get_tic6x_dynamic_type (unsigned long type)
1832 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1833 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1834 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1835 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1836 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1837 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1844 get_nios2_dynamic_type (unsigned long type)
1848 case DT_NIOS2_GP: return "NIOS2_GP";
1855 get_dynamic_type (unsigned long type)
1857 static char buff[64];
1861 case DT_NULL: return "NULL";
1862 case DT_NEEDED: return "NEEDED";
1863 case DT_PLTRELSZ: return "PLTRELSZ";
1864 case DT_PLTGOT: return "PLTGOT";
1865 case DT_HASH: return "HASH";
1866 case DT_STRTAB: return "STRTAB";
1867 case DT_SYMTAB: return "SYMTAB";
1868 case DT_RELA: return "RELA";
1869 case DT_RELASZ: return "RELASZ";
1870 case DT_RELAENT: return "RELAENT";
1871 case DT_STRSZ: return "STRSZ";
1872 case DT_SYMENT: return "SYMENT";
1873 case DT_INIT: return "INIT";
1874 case DT_FINI: return "FINI";
1875 case DT_SONAME: return "SONAME";
1876 case DT_RPATH: return "RPATH";
1877 case DT_SYMBOLIC: return "SYMBOLIC";
1878 case DT_REL: return "REL";
1879 case DT_RELSZ: return "RELSZ";
1880 case DT_RELENT: return "RELENT";
1881 case DT_PLTREL: return "PLTREL";
1882 case DT_DEBUG: return "DEBUG";
1883 case DT_TEXTREL: return "TEXTREL";
1884 case DT_JMPREL: return "JMPREL";
1885 case DT_BIND_NOW: return "BIND_NOW";
1886 case DT_INIT_ARRAY: return "INIT_ARRAY";
1887 case DT_FINI_ARRAY: return "FINI_ARRAY";
1888 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1889 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1890 case DT_RUNPATH: return "RUNPATH";
1891 case DT_FLAGS: return "FLAGS";
1893 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1894 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1896 case DT_CHECKSUM: return "CHECKSUM";
1897 case DT_PLTPADSZ: return "PLTPADSZ";
1898 case DT_MOVEENT: return "MOVEENT";
1899 case DT_MOVESZ: return "MOVESZ";
1900 case DT_FEATURE: return "FEATURE";
1901 case DT_POSFLAG_1: return "POSFLAG_1";
1902 case DT_SYMINSZ: return "SYMINSZ";
1903 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1905 case DT_ADDRRNGLO: return "ADDRRNGLO";
1906 case DT_CONFIG: return "CONFIG";
1907 case DT_DEPAUDIT: return "DEPAUDIT";
1908 case DT_AUDIT: return "AUDIT";
1909 case DT_PLTPAD: return "PLTPAD";
1910 case DT_MOVETAB: return "MOVETAB";
1911 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1913 case DT_VERSYM: return "VERSYM";
1915 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1916 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1917 case DT_RELACOUNT: return "RELACOUNT";
1918 case DT_RELCOUNT: return "RELCOUNT";
1919 case DT_FLAGS_1: return "FLAGS_1";
1920 case DT_VERDEF: return "VERDEF";
1921 case DT_VERDEFNUM: return "VERDEFNUM";
1922 case DT_VERNEED: return "VERNEED";
1923 case DT_VERNEEDNUM: return "VERNEEDNUM";
1925 case DT_AUXILIARY: return "AUXILIARY";
1926 case DT_USED: return "USED";
1927 case DT_FILTER: return "FILTER";
1929 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1930 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1931 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1932 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1933 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1934 case DT_GNU_HASH: return "GNU_HASH";
1937 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1939 const char * result;
1941 switch (elf_header.e_machine)
1944 case EM_MIPS_RS3_LE:
1945 result = get_mips_dynamic_type (type);
1948 result = get_sparc64_dynamic_type (type);
1951 result = get_ppc_dynamic_type (type);
1954 result = get_ppc64_dynamic_type (type);
1957 result = get_ia64_dynamic_type (type);
1960 result = get_alpha_dynamic_type (type);
1963 result = get_score_dynamic_type (type);
1966 result = get_tic6x_dynamic_type (type);
1968 case EM_ALTERA_NIOS2:
1969 result = get_nios2_dynamic_type (type);
1979 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1981 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1982 || (elf_header.e_machine == EM_PARISC
1983 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1985 const char * result;
1987 switch (elf_header.e_machine)
1990 result = get_parisc_dynamic_type (type);
1993 result = get_ia64_dynamic_type (type);
2003 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2007 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2014 get_file_type (unsigned e_type)
2016 static char buff[32];
2020 case ET_NONE: return _("NONE (None)");
2021 case ET_REL: return _("REL (Relocatable file)");
2022 case ET_EXEC: return _("EXEC (Executable file)");
2023 case ET_DYN: return _("DYN (Shared object file)");
2024 case ET_CORE: return _("CORE (Core file)");
2027 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2028 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2029 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2030 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2032 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2038 get_machine_name (unsigned e_machine)
2040 static char buff[64]; /* XXX */
2044 case EM_NONE: return _("None");
2045 case EM_AARCH64: return "AArch64";
2046 case EM_M32: return "WE32100";
2047 case EM_SPARC: return "Sparc";
2048 case EM_SPU: return "SPU";
2049 case EM_386: return "Intel 80386";
2050 case EM_68K: return "MC68000";
2051 case EM_88K: return "MC88000";
2052 case EM_486: return "Intel 80486";
2053 case EM_860: return "Intel 80860";
2054 case EM_MIPS: return "MIPS R3000";
2055 case EM_S370: return "IBM System/370";
2056 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2057 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2058 case EM_PARISC: return "HPPA";
2059 case EM_PPC_OLD: return "Power PC (old)";
2060 case EM_SPARC32PLUS: return "Sparc v8+" ;
2061 case EM_960: return "Intel 90860";
2062 case EM_PPC: return "PowerPC";
2063 case EM_PPC64: return "PowerPC64";
2064 case EM_FR20: return "Fujitsu FR20";
2065 case EM_RH32: return "TRW RH32";
2066 case EM_MCORE: return "MCORE";
2067 case EM_ARM: return "ARM";
2068 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2069 case EM_SH: return "Renesas / SuperH SH";
2070 case EM_SPARCV9: return "Sparc v9";
2071 case EM_TRICORE: return "Siemens Tricore";
2072 case EM_ARC: return "ARC";
2073 case EM_H8_300: return "Renesas H8/300";
2074 case EM_H8_300H: return "Renesas H8/300H";
2075 case EM_H8S: return "Renesas H8S";
2076 case EM_H8_500: return "Renesas H8/500";
2077 case EM_IA_64: return "Intel IA-64";
2078 case EM_MIPS_X: return "Stanford MIPS-X";
2079 case EM_COLDFIRE: return "Motorola Coldfire";
2080 case EM_ALPHA: return "Alpha";
2081 case EM_CYGNUS_D10V:
2082 case EM_D10V: return "d10v";
2083 case EM_CYGNUS_D30V:
2084 case EM_D30V: return "d30v";
2085 case EM_CYGNUS_M32R:
2086 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2087 case EM_CYGNUS_V850:
2088 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2089 case EM_V850: return "Renesas V850";
2090 case EM_CYGNUS_MN10300:
2091 case EM_MN10300: return "mn10300";
2092 case EM_CYGNUS_MN10200:
2093 case EM_MN10200: return "mn10200";
2094 case EM_MOXIE: return "Moxie";
2095 case EM_CYGNUS_FR30:
2096 case EM_FR30: return "Fujitsu FR30";
2097 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2099 case EM_PJ: return "picoJava";
2100 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2101 case EM_PCP: return "Siemens PCP";
2102 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2103 case EM_NDR1: return "Denso NDR1 microprocesspr";
2104 case EM_STARCORE: return "Motorola Star*Core processor";
2105 case EM_ME16: return "Toyota ME16 processor";
2106 case EM_ST100: return "STMicroelectronics ST100 processor";
2107 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2108 case EM_PDSP: return "Sony DSP processor";
2109 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2110 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2111 case EM_FX66: return "Siemens FX66 microcontroller";
2112 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2113 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2114 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2115 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2116 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2117 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2118 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2119 case EM_SVX: return "Silicon Graphics SVx";
2120 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2121 case EM_VAX: return "Digital VAX";
2123 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2124 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2125 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2126 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2127 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2128 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2129 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2130 case EM_PRISM: return "Vitesse Prism";
2131 case EM_X86_64: return "Advanced Micro Devices X86-64";
2132 case EM_L1OM: return "Intel L1OM";
2133 case EM_K1OM: return "Intel K1OM";
2135 case EM_S390: return "IBM S/390";
2136 case EM_SCORE: return "SUNPLUS S+Core";
2137 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2138 case EM_OR1K: return "OpenRISC 1000";
2139 case EM_ARC_A5: return "ARC International ARCompact processor";
2140 case EM_CRX: return "National Semiconductor CRX microprocessor";
2141 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2142 case EM_DLX: return "OpenDLX";
2144 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2145 case EM_IQ2000: return "Vitesse IQ2000";
2147 case EM_XTENSA: return "Tensilica Xtensa Processor";
2148 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2149 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2150 case EM_NS32K: return "National Semiconductor 32000 series";
2151 case EM_TPC: return "Tenor Network TPC processor";
2152 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2153 case EM_MAX: return "MAX Processor";
2154 case EM_CR: return "National Semiconductor CompactRISC";
2155 case EM_F2MC16: return "Fujitsu F2MC16";
2156 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2157 case EM_LATTICEMICO32: return "Lattice Mico32";
2159 case EM_M32C: return "Renesas M32c";
2160 case EM_MT: return "Morpho Techologies MT processor";
2161 case EM_BLACKFIN: return "Analog Devices Blackfin";
2162 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2163 case EM_SEP: return "Sharp embedded microprocessor";
2164 case EM_ARCA: return "Arca RISC microprocessor";
2165 case EM_UNICORE: return "Unicore";
2166 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2167 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2168 case EM_NIOS32: return "Altera Nios";
2169 case EM_ALTERA_NIOS2: return "Altera Nios II";
2171 case EM_XC16X: return "Infineon Technologies xc16x";
2172 case EM_M16C: return "Renesas M16C series microprocessors";
2173 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2174 case EM_CE: return "Freescale Communication Engine RISC core";
2175 case EM_TSK3000: return "Altium TSK3000 core";
2176 case EM_RS08: return "Freescale RS08 embedded processor";
2177 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2178 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2179 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2180 case EM_SE_C17: return "Seiko Epson C17 family";
2181 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2182 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2183 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2184 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2185 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2186 case EM_R32C: return "Renesas R32C series microprocessors";
2187 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2188 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2189 case EM_8051: return "Intel 8051 and variants";
2190 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2191 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2192 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2193 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2194 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2195 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2196 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2197 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2200 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2201 case EM_RL78: return "Renesas RL78";
2202 case EM_RX: return "Renesas RX";
2203 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2204 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2205 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2206 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2207 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2208 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2209 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2210 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2211 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2212 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2213 case EM_CUDA: return "NVIDIA CUDA architecture";
2214 case EM_XGATE: return "Motorola XGATE embedded processor";
2216 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2222 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2227 eabi = EF_ARM_EABI_VERSION (e_flags);
2228 e_flags &= ~ EF_ARM_EABIMASK;
2230 /* Handle "generic" ARM flags. */
2231 if (e_flags & EF_ARM_RELEXEC)
2233 strcat (buf, ", relocatable executable");
2234 e_flags &= ~ EF_ARM_RELEXEC;
2237 if (e_flags & EF_ARM_HASENTRY)
2239 strcat (buf, ", has entry point");
2240 e_flags &= ~ EF_ARM_HASENTRY;
2243 /* Now handle EABI specific flags. */
2247 strcat (buf, ", <unrecognized EABI>");
2252 case EF_ARM_EABI_VER1:
2253 strcat (buf, ", Version1 EABI");
2258 /* Process flags one bit at a time. */
2259 flag = e_flags & - e_flags;
2264 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2265 strcat (buf, ", sorted symbol tables");
2275 case EF_ARM_EABI_VER2:
2276 strcat (buf, ", Version2 EABI");
2281 /* Process flags one bit at a time. */
2282 flag = e_flags & - e_flags;
2287 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2288 strcat (buf, ", sorted symbol tables");
2291 case EF_ARM_DYNSYMSUSESEGIDX:
2292 strcat (buf, ", dynamic symbols use segment index");
2295 case EF_ARM_MAPSYMSFIRST:
2296 strcat (buf, ", mapping symbols precede others");
2306 case EF_ARM_EABI_VER3:
2307 strcat (buf, ", Version3 EABI");
2310 case EF_ARM_EABI_VER4:
2311 strcat (buf, ", Version4 EABI");
2316 /* Process flags one bit at a time. */
2317 flag = e_flags & - e_flags;
2323 strcat (buf, ", BE8");
2327 strcat (buf, ", LE8");
2338 case EF_ARM_EABI_VER5:
2339 strcat (buf, ", Version5 EABI");
2344 /* Process flags one bit at a time. */
2345 flag = e_flags & - e_flags;
2351 strcat (buf, ", BE8");
2355 strcat (buf, ", LE8");
2358 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2359 strcat (buf, ", soft-float ABI");
2362 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2363 strcat (buf, ", hard-float ABI");
2373 case EF_ARM_EABI_UNKNOWN:
2374 strcat (buf, ", GNU EABI");
2379 /* Process flags one bit at a time. */
2380 flag = e_flags & - e_flags;
2385 case EF_ARM_INTERWORK:
2386 strcat (buf, ", interworking enabled");
2389 case EF_ARM_APCS_26:
2390 strcat (buf, ", uses APCS/26");
2393 case EF_ARM_APCS_FLOAT:
2394 strcat (buf, ", uses APCS/float");
2398 strcat (buf, ", position independent");
2402 strcat (buf, ", 8 bit structure alignment");
2405 case EF_ARM_NEW_ABI:
2406 strcat (buf, ", uses new ABI");
2409 case EF_ARM_OLD_ABI:
2410 strcat (buf, ", uses old ABI");
2413 case EF_ARM_SOFT_FLOAT:
2414 strcat (buf, ", software FP");
2417 case EF_ARM_VFP_FLOAT:
2418 strcat (buf, ", VFP");
2421 case EF_ARM_MAVERICK_FLOAT:
2422 strcat (buf, ", Maverick FP");
2433 strcat (buf,_(", <unknown>"));
2437 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2446 static const char *ABI_STRINGS[] =
2448 "ABI v0", /* use r5 as return register; only used in N1213HC */
2449 "ABI v1", /* use r0 as return register */
2450 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2451 "ABI v2fp", /* for FPU */
2455 static const char *VER_STRINGS[] =
2457 "Andes ELF V1.3 or older",
2461 static const char *ARCH_STRINGS[] =
2470 abi = EF_NDS_ABI & e_flags;
2471 arch = EF_NDS_ARCH & e_flags;
2472 config = EF_NDS_INST & e_flags;
2473 version = EF_NDS32_ELF_VERSION & e_flags;
2475 memset (buf, 0, size);
2482 case E_NDS_ABI_V2FP:
2483 case E_NDS_ABI_AABI:
2484 case E_NDS_ABI_V2FP_PLUS:
2485 /* In case there are holes in the array. */
2486 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2490 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2496 case E_NDS32_ELF_VER_1_2:
2497 case E_NDS32_ELF_VER_1_3:
2498 case E_NDS32_ELF_VER_1_4:
2499 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2503 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2507 if (E_NDS_ABI_V0 == abi)
2509 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2510 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2511 if (arch == E_NDS_ARCH_STAR_V1_0)
2512 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2518 case E_NDS_ARCH_STAR_V1_0:
2519 case E_NDS_ARCH_STAR_V2_0:
2520 case E_NDS_ARCH_STAR_V3_0:
2521 case E_NDS_ARCH_STAR_V3_M:
2522 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2526 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2527 /* ARCH version determines how the e_flags are interpreted.
2528 If it is unknown, we cannot proceed. */
2532 /* Newer ABI; Now handle architecture specific flags. */
2533 if (arch == E_NDS_ARCH_STAR_V1_0)
2535 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2536 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2538 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2539 r += snprintf (buf + r, size -r, ", MAC");
2541 if (config & E_NDS32_HAS_DIV_INST)
2542 r += snprintf (buf + r, size -r, ", DIV");
2544 if (config & E_NDS32_HAS_16BIT_INST)
2545 r += snprintf (buf + r, size -r, ", 16b");
2549 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2551 if (version <= E_NDS32_ELF_VER_1_3)
2552 r += snprintf (buf + r, size -r, ", [B8]");
2554 r += snprintf (buf + r, size -r, ", EX9");
2557 if (config & E_NDS32_HAS_MAC_DX_INST)
2558 r += snprintf (buf + r, size -r, ", MAC_DX");
2560 if (config & E_NDS32_HAS_DIV_DX_INST)
2561 r += snprintf (buf + r, size -r, ", DIV_DX");
2563 if (config & E_NDS32_HAS_16BIT_INST)
2565 if (version <= E_NDS32_ELF_VER_1_3)
2566 r += snprintf (buf + r, size -r, ", 16b");
2568 r += snprintf (buf + r, size -r, ", IFC");
2572 if (config & E_NDS32_HAS_EXT_INST)
2573 r += snprintf (buf + r, size -r, ", PERF1");
2575 if (config & E_NDS32_HAS_EXT2_INST)
2576 r += snprintf (buf + r, size -r, ", PERF2");
2578 if (config & E_NDS32_HAS_FPU_INST)
2581 r += snprintf (buf + r, size -r, ", FPU_SP");
2584 if (config & E_NDS32_HAS_FPU_DP_INST)
2587 r += snprintf (buf + r, size -r, ", FPU_DP");
2590 if (config & E_NDS32_HAS_FPU_MAC_INST)
2593 r += snprintf (buf + r, size -r, ", FPU_MAC");
2598 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2600 case E_NDS32_FPU_REG_8SP_4DP:
2601 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2603 case E_NDS32_FPU_REG_16SP_8DP:
2604 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2606 case E_NDS32_FPU_REG_32SP_16DP:
2607 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2609 case E_NDS32_FPU_REG_32SP_32DP:
2610 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2615 if (config & E_NDS32_HAS_AUDIO_INST)
2616 r += snprintf (buf + r, size -r, ", AUDIO");
2618 if (config & E_NDS32_HAS_STRING_INST)
2619 r += snprintf (buf + r, size -r, ", STR");
2621 if (config & E_NDS32_HAS_REDUCED_REGS)
2622 r += snprintf (buf + r, size -r, ", 16REG");
2624 if (config & E_NDS32_HAS_VIDEO_INST)
2626 if (version <= E_NDS32_ELF_VER_1_3)
2627 r += snprintf (buf + r, size -r, ", VIDEO");
2629 r += snprintf (buf + r, size -r, ", SATURATION");
2632 if (config & E_NDS32_HAS_ENCRIPT_INST)
2633 r += snprintf (buf + r, size -r, ", ENCRP");
2635 if (config & E_NDS32_HAS_L2C_INST)
2636 r += snprintf (buf + r, size -r, ", L2C");
2640 get_machine_flags (unsigned e_flags, unsigned e_machine)
2642 static char buf[1024];
2654 decode_ARM_machine_flags (e_flags, buf);
2658 if (e_flags & EF_BFIN_PIC)
2659 strcat (buf, ", PIC");
2661 if (e_flags & EF_BFIN_FDPIC)
2662 strcat (buf, ", FDPIC");
2664 if (e_flags & EF_BFIN_CODE_IN_L1)
2665 strcat (buf, ", code in L1");
2667 if (e_flags & EF_BFIN_DATA_IN_L1)
2668 strcat (buf, ", data in L1");
2673 switch (e_flags & EF_FRV_CPU_MASK)
2675 case EF_FRV_CPU_GENERIC:
2679 strcat (buf, ", fr???");
2682 case EF_FRV_CPU_FR300:
2683 strcat (buf, ", fr300");
2686 case EF_FRV_CPU_FR400:
2687 strcat (buf, ", fr400");
2689 case EF_FRV_CPU_FR405:
2690 strcat (buf, ", fr405");
2693 case EF_FRV_CPU_FR450:
2694 strcat (buf, ", fr450");
2697 case EF_FRV_CPU_FR500:
2698 strcat (buf, ", fr500");
2700 case EF_FRV_CPU_FR550:
2701 strcat (buf, ", fr550");
2704 case EF_FRV_CPU_SIMPLE:
2705 strcat (buf, ", simple");
2707 case EF_FRV_CPU_TOMCAT:
2708 strcat (buf, ", tomcat");
2714 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2715 strcat (buf, ", m68000");
2716 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2717 strcat (buf, ", cpu32");
2718 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2719 strcat (buf, ", fido_a");
2722 char const * isa = _("unknown");
2723 char const * mac = _("unknown mac");
2724 char const * additional = NULL;
2726 switch (e_flags & EF_M68K_CF_ISA_MASK)
2728 case EF_M68K_CF_ISA_A_NODIV:
2730 additional = ", nodiv";
2732 case EF_M68K_CF_ISA_A:
2735 case EF_M68K_CF_ISA_A_PLUS:
2738 case EF_M68K_CF_ISA_B_NOUSP:
2740 additional = ", nousp";
2742 case EF_M68K_CF_ISA_B:
2745 case EF_M68K_CF_ISA_C:
2748 case EF_M68K_CF_ISA_C_NODIV:
2750 additional = ", nodiv";
2753 strcat (buf, ", cf, isa ");
2756 strcat (buf, additional);
2757 if (e_flags & EF_M68K_CF_FLOAT)
2758 strcat (buf, ", float");
2759 switch (e_flags & EF_M68K_CF_MAC_MASK)
2764 case EF_M68K_CF_MAC:
2767 case EF_M68K_CF_EMAC:
2770 case EF_M68K_CF_EMAC_B:
2783 if (e_flags & EF_PPC_EMB)
2784 strcat (buf, ", emb");
2786 if (e_flags & EF_PPC_RELOCATABLE)
2787 strcat (buf, _(", relocatable"));
2789 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2790 strcat (buf, _(", relocatable-lib"));
2794 if (e_flags & EF_PPC64_ABI)
2796 char abi[] = ", abiv0";
2798 abi[6] += e_flags & EF_PPC64_ABI;
2804 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2805 strcat (buf, ", RH850 ABI");
2807 if (e_flags & EF_V800_850E3)
2808 strcat (buf, ", V3 architecture");
2810 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2811 strcat (buf, ", FPU not used");
2813 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2814 strcat (buf, ", regmode: COMMON");
2816 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2817 strcat (buf, ", r4 not used");
2819 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2820 strcat (buf, ", r30 not used");
2822 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2823 strcat (buf, ", r5 not used");
2825 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2826 strcat (buf, ", r2 not used");
2828 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2830 switch (e_flags & - e_flags)
2832 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2833 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2834 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2835 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2836 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2837 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2838 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2839 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2840 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2841 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2842 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2843 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2844 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2845 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2846 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2847 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2854 case EM_CYGNUS_V850:
2855 switch (e_flags & EF_V850_ARCH)
2857 case E_V850E3V5_ARCH:
2858 strcat (buf, ", v850e3v5");
2860 case E_V850E2V3_ARCH:
2861 strcat (buf, ", v850e2v3");
2864 strcat (buf, ", v850e2");
2867 strcat (buf, ", v850e1");
2870 strcat (buf, ", v850e");
2873 strcat (buf, ", v850");
2876 strcat (buf, _(", unknown v850 architecture variant"));
2882 case EM_CYGNUS_M32R:
2883 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2884 strcat (buf, ", m32r");
2888 case EM_MIPS_RS3_LE:
2889 if (e_flags & EF_MIPS_NOREORDER)
2890 strcat (buf, ", noreorder");
2892 if (e_flags & EF_MIPS_PIC)
2893 strcat (buf, ", pic");
2895 if (e_flags & EF_MIPS_CPIC)
2896 strcat (buf, ", cpic");
2898 if (e_flags & EF_MIPS_UCODE)
2899 strcat (buf, ", ugen_reserved");
2901 if (e_flags & EF_MIPS_ABI2)
2902 strcat (buf, ", abi2");
2904 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2905 strcat (buf, ", odk first");
2907 if (e_flags & EF_MIPS_32BITMODE)
2908 strcat (buf, ", 32bitmode");
2910 if (e_flags & EF_MIPS_NAN2008)
2911 strcat (buf, ", nan2008");
2913 if (e_flags & EF_MIPS_FP64)
2914 strcat (buf, ", fp64");
2916 switch ((e_flags & EF_MIPS_MACH))
2918 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2919 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2920 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2921 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2922 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2923 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2924 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2925 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2926 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2927 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2928 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2929 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2930 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2931 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2932 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2933 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2934 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2936 /* We simply ignore the field in this case to avoid confusion:
2937 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2940 default: strcat (buf, _(", unknown CPU")); break;
2943 switch ((e_flags & EF_MIPS_ABI))
2945 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2946 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2947 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2948 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2950 /* We simply ignore the field in this case to avoid confusion:
2951 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2952 This means it is likely to be an o32 file, but not for
2955 default: strcat (buf, _(", unknown ABI")); break;
2958 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2959 strcat (buf, ", mdmx");
2961 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2962 strcat (buf, ", mips16");
2964 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2965 strcat (buf, ", micromips");
2967 switch ((e_flags & EF_MIPS_ARCH))
2969 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2970 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2971 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2972 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2973 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2974 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2975 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2976 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
2977 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2978 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2979 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
2980 default: strcat (buf, _(", unknown ISA")); break;
2985 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2989 switch ((e_flags & EF_SH_MACH_MASK))
2991 case EF_SH1: strcat (buf, ", sh1"); break;
2992 case EF_SH2: strcat (buf, ", sh2"); break;
2993 case EF_SH3: strcat (buf, ", sh3"); break;
2994 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2995 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2996 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2997 case EF_SH3E: strcat (buf, ", sh3e"); break;
2998 case EF_SH4: strcat (buf, ", sh4"); break;
2999 case EF_SH5: strcat (buf, ", sh5"); break;
3000 case EF_SH2E: strcat (buf, ", sh2e"); break;
3001 case EF_SH4A: strcat (buf, ", sh4a"); break;
3002 case EF_SH2A: strcat (buf, ", sh2a"); break;
3003 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3004 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3005 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3006 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3007 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3008 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3009 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3010 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3011 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3012 default: strcat (buf, _(", unknown ISA")); break;
3015 if (e_flags & EF_SH_PIC)
3016 strcat (buf, ", pic");
3018 if (e_flags & EF_SH_FDPIC)
3019 strcat (buf, ", fdpic");
3023 if (e_flags & EF_OR1K_NODELAY)
3024 strcat (buf, ", no delay");
3028 if (e_flags & EF_SPARC_32PLUS)
3029 strcat (buf, ", v8+");
3031 if (e_flags & EF_SPARC_SUN_US1)
3032 strcat (buf, ", ultrasparcI");
3034 if (e_flags & EF_SPARC_SUN_US3)
3035 strcat (buf, ", ultrasparcIII");
3037 if (e_flags & EF_SPARC_HAL_R1)
3038 strcat (buf, ", halr1");
3040 if (e_flags & EF_SPARC_LEDATA)
3041 strcat (buf, ", ledata");
3043 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3044 strcat (buf, ", tso");
3046 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3047 strcat (buf, ", pso");
3049 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3050 strcat (buf, ", rmo");
3054 switch (e_flags & EF_PARISC_ARCH)
3056 case EFA_PARISC_1_0:
3057 strcpy (buf, ", PA-RISC 1.0");
3059 case EFA_PARISC_1_1:
3060 strcpy (buf, ", PA-RISC 1.1");
3062 case EFA_PARISC_2_0:
3063 strcpy (buf, ", PA-RISC 2.0");
3068 if (e_flags & EF_PARISC_TRAPNIL)
3069 strcat (buf, ", trapnil");
3070 if (e_flags & EF_PARISC_EXT)
3071 strcat (buf, ", ext");
3072 if (e_flags & EF_PARISC_LSB)
3073 strcat (buf, ", lsb");
3074 if (e_flags & EF_PARISC_WIDE)
3075 strcat (buf, ", wide");
3076 if (e_flags & EF_PARISC_NO_KABP)
3077 strcat (buf, ", no kabp");
3078 if (e_flags & EF_PARISC_LAZYSWAP)
3079 strcat (buf, ", lazyswap");
3084 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3085 strcat (buf, ", new calling convention");
3087 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3088 strcat (buf, ", gnu calling convention");
3092 if ((e_flags & EF_IA_64_ABI64))
3093 strcat (buf, ", 64-bit");
3095 strcat (buf, ", 32-bit");
3096 if ((e_flags & EF_IA_64_REDUCEDFP))
3097 strcat (buf, ", reduced fp model");
3098 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3099 strcat (buf, ", no function descriptors, constant gp");
3100 else if ((e_flags & EF_IA_64_CONS_GP))
3101 strcat (buf, ", constant gp");
3102 if ((e_flags & EF_IA_64_ABSOLUTE))
3103 strcat (buf, ", absolute");
3104 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3106 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3107 strcat (buf, ", vms_linkages");
3108 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3110 case EF_IA_64_VMS_COMCOD_SUCCESS:
3112 case EF_IA_64_VMS_COMCOD_WARNING:
3113 strcat (buf, ", warning");
3115 case EF_IA_64_VMS_COMCOD_ERROR:
3116 strcat (buf, ", error");
3118 case EF_IA_64_VMS_COMCOD_ABORT:
3119 strcat (buf, ", abort");
3128 if ((e_flags & EF_VAX_NONPIC))
3129 strcat (buf, ", non-PIC");
3130 if ((e_flags & EF_VAX_DFLOAT))
3131 strcat (buf, ", D-Float");
3132 if ((e_flags & EF_VAX_GFLOAT))
3133 strcat (buf, ", G-Float");
3137 if (e_flags & E_FLAG_RL78_G10)
3138 strcat (buf, ", G10");
3139 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3140 strcat (buf, ", 64-bit doubles");
3144 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3145 strcat (buf, ", 64-bit doubles");
3146 if (e_flags & E_FLAG_RX_DSP)
3147 strcat (buf, ", dsp");
3148 if (e_flags & E_FLAG_RX_PID)
3149 strcat (buf, ", pid");
3150 if (e_flags & E_FLAG_RX_ABI)
3151 strcat (buf, ", RX ABI");
3155 if (e_flags & EF_S390_HIGH_GPRS)
3156 strcat (buf, ", highgprs");
3160 if ((e_flags & EF_C6000_REL))
3161 strcat (buf, ", relocatable module");
3165 strcat (buf, _(": architecture variant: "));
3166 switch (e_flags & EF_MSP430_MACH)
3168 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3169 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3170 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3171 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3172 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3173 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3174 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3175 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3176 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3177 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3178 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3179 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3180 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3181 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3182 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3184 strcat (buf, _(": unknown")); break;
3187 if (e_flags & ~ EF_MSP430_MACH)
3188 strcat (buf, _(": unknown extra flag bits also present"));
3196 get_osabi_name (unsigned int osabi)
3198 static char buff[32];
3202 case ELFOSABI_NONE: return "UNIX - System V";
3203 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3204 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3205 case ELFOSABI_GNU: return "UNIX - GNU";
3206 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3207 case ELFOSABI_AIX: return "UNIX - AIX";
3208 case ELFOSABI_IRIX: return "UNIX - IRIX";
3209 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3210 case ELFOSABI_TRU64: return "UNIX - TRU64";
3211 case ELFOSABI_MODESTO: return "Novell - Modesto";
3212 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3213 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3214 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3215 case ELFOSABI_AROS: return "AROS";
3216 case ELFOSABI_FENIXOS: return "FenixOS";
3219 switch (elf_header.e_machine)
3224 case ELFOSABI_ARM: return "ARM";
3234 case ELFOSABI_STANDALONE: return _("Standalone App");
3243 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3244 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3253 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3259 get_aarch64_segment_type (unsigned long type)
3263 case PT_AARCH64_ARCHEXT:
3264 return "AARCH64_ARCHEXT";
3273 get_arm_segment_type (unsigned long type)
3287 get_mips_segment_type (unsigned long type)
3291 case PT_MIPS_REGINFO:
3293 case PT_MIPS_RTPROC:
3295 case PT_MIPS_OPTIONS:
3297 case PT_MIPS_ABIFLAGS:
3307 get_parisc_segment_type (unsigned long type)
3311 case PT_HP_TLS: return "HP_TLS";
3312 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3313 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3314 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3315 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3316 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3317 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3318 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3319 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3320 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3321 case PT_HP_PARALLEL: return "HP_PARALLEL";
3322 case PT_HP_FASTBIND: return "HP_FASTBIND";
3323 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3324 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3325 case PT_HP_STACK: return "HP_STACK";
3326 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3327 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3328 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3329 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3338 get_ia64_segment_type (unsigned long type)
3342 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3343 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3344 case PT_HP_TLS: return "HP_TLS";
3345 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3346 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3347 case PT_IA_64_HP_STACK: return "HP_STACK";
3356 get_tic6x_segment_type (unsigned long type)
3360 case PT_C6000_PHATTR: return "C6000_PHATTR";
3369 get_segment_type (unsigned long p_type)
3371 static char buff[32];
3375 case PT_NULL: return "NULL";
3376 case PT_LOAD: return "LOAD";
3377 case PT_DYNAMIC: return "DYNAMIC";
3378 case PT_INTERP: return "INTERP";
3379 case PT_NOTE: return "NOTE";
3380 case PT_SHLIB: return "SHLIB";
3381 case PT_PHDR: return "PHDR";
3382 case PT_TLS: return "TLS";
3384 case PT_GNU_EH_FRAME:
3385 return "GNU_EH_FRAME";
3386 case PT_GNU_STACK: return "GNU_STACK";
3387 case PT_GNU_RELRO: return "GNU_RELRO";
3390 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3392 const char * result;
3394 switch (elf_header.e_machine)
3397 result = get_aarch64_segment_type (p_type);
3400 result = get_arm_segment_type (p_type);
3403 case EM_MIPS_RS3_LE:
3404 result = get_mips_segment_type (p_type);
3407 result = get_parisc_segment_type (p_type);
3410 result = get_ia64_segment_type (p_type);
3413 result = get_tic6x_segment_type (p_type);
3423 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3425 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3427 const char * result;
3429 switch (elf_header.e_machine)
3432 result = get_parisc_segment_type (p_type);
3435 result = get_ia64_segment_type (p_type);
3445 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3448 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3455 get_mips_section_type_name (unsigned int sh_type)
3459 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3460 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3461 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3462 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3463 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3464 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3465 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3466 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3467 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3468 case SHT_MIPS_RELD: return "MIPS_RELD";
3469 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3470 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3471 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3472 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3473 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3474 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3475 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3476 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3477 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3478 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3479 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3480 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3481 case SHT_MIPS_LINE: return "MIPS_LINE";
3482 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3483 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3484 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3485 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3486 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3487 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3488 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3489 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3490 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3491 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3492 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3493 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3494 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3495 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3496 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3497 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3498 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3506 get_parisc_section_type_name (unsigned int sh_type)
3510 case SHT_PARISC_EXT: return "PARISC_EXT";
3511 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3512 case SHT_PARISC_DOC: return "PARISC_DOC";
3513 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3514 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3515 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3516 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3524 get_ia64_section_type_name (unsigned int sh_type)
3526 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3527 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3528 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3532 case SHT_IA_64_EXT: return "IA_64_EXT";
3533 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3534 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3535 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3536 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3537 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3538 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3539 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3540 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3541 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3549 get_x86_64_section_type_name (unsigned int sh_type)
3553 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3561 get_aarch64_section_type_name (unsigned int sh_type)
3565 case SHT_AARCH64_ATTRIBUTES:
3566 return "AARCH64_ATTRIBUTES";
3574 get_arm_section_type_name (unsigned int sh_type)
3578 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3579 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3580 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3581 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3582 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3590 get_tic6x_section_type_name (unsigned int sh_type)
3594 case SHT_C6000_UNWIND:
3595 return "C6000_UNWIND";
3596 case SHT_C6000_PREEMPTMAP:
3597 return "C6000_PREEMPTMAP";
3598 case SHT_C6000_ATTRIBUTES:
3599 return "C6000_ATTRIBUTES";
3604 case SHT_TI_HANDLER:
3605 return "TI_HANDLER";
3606 case SHT_TI_INITINFO:
3607 return "TI_INITINFO";
3608 case SHT_TI_PHATTRS:
3609 return "TI_PHATTRS";
3617 get_msp430x_section_type_name (unsigned int sh_type)
3621 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3622 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3623 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3624 default: return NULL;
3629 get_section_type_name (unsigned int sh_type)
3631 static char buff[32];
3635 case SHT_NULL: return "NULL";
3636 case SHT_PROGBITS: return "PROGBITS";
3637 case SHT_SYMTAB: return "SYMTAB";
3638 case SHT_STRTAB: return "STRTAB";
3639 case SHT_RELA: return "RELA";
3640 case SHT_HASH: return "HASH";
3641 case SHT_DYNAMIC: return "DYNAMIC";
3642 case SHT_NOTE: return "NOTE";
3643 case SHT_NOBITS: return "NOBITS";
3644 case SHT_REL: return "REL";
3645 case SHT_SHLIB: return "SHLIB";
3646 case SHT_DYNSYM: return "DYNSYM";
3647 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3648 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3649 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3650 case SHT_GNU_HASH: return "GNU_HASH";
3651 case SHT_GROUP: return "GROUP";
3652 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3653 case SHT_GNU_verdef: return "VERDEF";
3654 case SHT_GNU_verneed: return "VERNEED";
3655 case SHT_GNU_versym: return "VERSYM";
3656 case 0x6ffffff0: return "VERSYM";
3657 case 0x6ffffffc: return "VERDEF";
3658 case 0x7ffffffd: return "AUXILIARY";
3659 case 0x7fffffff: return "FILTER";
3660 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3663 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3665 const char * result;
3667 switch (elf_header.e_machine)
3670 case EM_MIPS_RS3_LE:
3671 result = get_mips_section_type_name (sh_type);
3674 result = get_parisc_section_type_name (sh_type);
3677 result = get_ia64_section_type_name (sh_type);
3682 result = get_x86_64_section_type_name (sh_type);
3685 result = get_aarch64_section_type_name (sh_type);
3688 result = get_arm_section_type_name (sh_type);
3691 result = get_tic6x_section_type_name (sh_type);
3694 result = get_msp430x_section_type_name (sh_type);
3704 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3706 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3708 const char * result;
3710 switch (elf_header.e_machine)
3713 result = get_ia64_section_type_name (sh_type);
3723 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3725 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3726 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3728 /* This message is probably going to be displayed in a 15
3729 character wide field, so put the hex value first. */
3730 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3736 #define OPTION_DEBUG_DUMP 512
3737 #define OPTION_DYN_SYMS 513
3738 #define OPTION_DWARF_DEPTH 514
3739 #define OPTION_DWARF_START 515
3740 #define OPTION_DWARF_CHECK 516
3742 static struct option options[] =
3744 {"all", no_argument, 0, 'a'},
3745 {"file-header", no_argument, 0, 'h'},
3746 {"program-headers", no_argument, 0, 'l'},
3747 {"headers", no_argument, 0, 'e'},
3748 {"histogram", no_argument, 0, 'I'},
3749 {"segments", no_argument, 0, 'l'},
3750 {"sections", no_argument, 0, 'S'},
3751 {"section-headers", no_argument, 0, 'S'},
3752 {"section-groups", no_argument, 0, 'g'},
3753 {"section-details", no_argument, 0, 't'},
3754 {"full-section-name",no_argument, 0, 'N'},
3755 {"symbols", no_argument, 0, 's'},
3756 {"syms", no_argument, 0, 's'},
3757 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3758 {"relocs", no_argument, 0, 'r'},
3759 {"notes", no_argument, 0, 'n'},
3760 {"dynamic", no_argument, 0, 'd'},
3761 {"arch-specific", no_argument, 0, 'A'},
3762 {"version-info", no_argument, 0, 'V'},
3763 {"use-dynamic", no_argument, 0, 'D'},
3764 {"unwind", no_argument, 0, 'u'},
3765 {"archive-index", no_argument, 0, 'c'},
3766 {"hex-dump", required_argument, 0, 'x'},
3767 {"relocated-dump", required_argument, 0, 'R'},
3768 {"string-dump", required_argument, 0, 'p'},
3769 #ifdef SUPPORT_DISASSEMBLY
3770 {"instruction-dump", required_argument, 0, 'i'},
3772 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3774 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3775 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3776 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3778 {"version", no_argument, 0, 'v'},
3779 {"wide", no_argument, 0, 'W'},
3780 {"help", no_argument, 0, 'H'},
3781 {0, no_argument, 0, 0}
3785 usage (FILE * stream)
3787 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3788 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3789 fprintf (stream, _(" Options are:\n\
3790 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3791 -h --file-header Display the ELF file header\n\
3792 -l --program-headers Display the program headers\n\
3793 --segments An alias for --program-headers\n\
3794 -S --section-headers Display the sections' header\n\
3795 --sections An alias for --section-headers\n\
3796 -g --section-groups Display the section groups\n\
3797 -t --section-details Display the section details\n\
3798 -e --headers Equivalent to: -h -l -S\n\
3799 -s --syms Display the symbol table\n\
3800 --symbols An alias for --syms\n\
3801 --dyn-syms Display the dynamic symbol table\n\
3802 -n --notes Display the core notes (if present)\n\
3803 -r --relocs Display the relocations (if present)\n\
3804 -u --unwind Display the unwind info (if present)\n\
3805 -d --dynamic Display the dynamic section (if present)\n\
3806 -V --version-info Display the version sections (if present)\n\
3807 -A --arch-specific Display architecture specific information (if any)\n\
3808 -c --archive-index Display the symbol/file index in an archive\n\
3809 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3810 -x --hex-dump=<number|name>\n\
3811 Dump the contents of section <number|name> as bytes\n\
3812 -p --string-dump=<number|name>\n\
3813 Dump the contents of section <number|name> as strings\n\
3814 -R --relocated-dump=<number|name>\n\
3815 Dump the contents of section <number|name> as relocated bytes\n\
3816 -w[lLiaprmfFsoRt] or\n\
3817 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3818 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3819 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3821 Display the contents of DWARF2 debug sections\n"));
3822 fprintf (stream, _("\
3823 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3824 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3826 #ifdef SUPPORT_DISASSEMBLY
3827 fprintf (stream, _("\
3828 -i --instruction-dump=<number|name>\n\
3829 Disassemble the contents of section <number|name>\n"));
3831 fprintf (stream, _("\
3832 -I --histogram Display histogram of bucket list lengths\n\
3833 -W --wide Allow output width to exceed 80 characters\n\
3834 @<file> Read options from <file>\n\
3835 -H --help Display this information\n\
3836 -v --version Display the version number of readelf\n"));
3838 if (REPORT_BUGS_TO[0] && stream == stdout)
3839 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3841 exit (stream == stdout ? 0 : 1);
3844 /* Record the fact that the user wants the contents of section number
3845 SECTION to be displayed using the method(s) encoded as flags bits
3846 in TYPE. Note, TYPE can be zero if we are creating the array for
3850 request_dump_bynumber (unsigned int section, dump_type type)
3852 if (section >= num_dump_sects)
3854 dump_type * new_dump_sects;
3856 new_dump_sects = (dump_type *) calloc (section + 1,
3857 sizeof (* dump_sects));
3859 if (new_dump_sects == NULL)
3860 error (_("Out of memory allocating dump request table.\n"));
3863 /* Copy current flag settings. */
3864 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3868 dump_sects = new_dump_sects;
3869 num_dump_sects = section + 1;
3874 dump_sects[section] |= type;
3879 /* Request a dump by section name. */
3882 request_dump_byname (const char * section, dump_type type)
3884 struct dump_list_entry * new_request;
3886 new_request = (struct dump_list_entry *)
3887 malloc (sizeof (struct dump_list_entry));
3889 error (_("Out of memory allocating dump request table.\n"));
3891 new_request->name = strdup (section);
3892 if (!new_request->name)
3893 error (_("Out of memory allocating dump request table.\n"));
3895 new_request->type = type;
3897 new_request->next = dump_sects_byname;
3898 dump_sects_byname = new_request;
3902 request_dump (dump_type type)
3908 section = strtoul (optarg, & cp, 0);
3910 if (! *cp && section >= 0)
3911 request_dump_bynumber (section, type);
3913 request_dump_byname (optarg, type);
3918 parse_args (int argc, char ** argv)
3925 while ((c = getopt_long
3926 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3944 do_section_groups++;
3952 do_section_groups++;
3957 do_section_details++;
4001 request_dump (HEX_DUMP);
4004 request_dump (STRING_DUMP);
4007 request_dump (RELOC_DUMP);
4014 dwarf_select_sections_all ();
4019 dwarf_select_sections_by_letters (optarg);
4022 case OPTION_DEBUG_DUMP:
4029 dwarf_select_sections_by_names (optarg);
4032 case OPTION_DWARF_DEPTH:
4036 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4039 case OPTION_DWARF_START:
4043 dwarf_start_die = strtoul (optarg, & cp, 0);
4046 case OPTION_DWARF_CHECK:
4049 case OPTION_DYN_SYMS:
4052 #ifdef SUPPORT_DISASSEMBLY
4054 request_dump (DISASS_DUMP);
4058 print_version (program_name);
4067 /* xgettext:c-format */
4068 error (_("Invalid option '-%c'\n"), c);
4075 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4076 && !do_segments && !do_header && !do_dump && !do_version
4077 && !do_histogram && !do_debugging && !do_arch && !do_notes
4078 && !do_section_groups && !do_archive_index
4083 warn (_("Nothing to do.\n"));
4089 get_elf_class (unsigned int elf_class)
4091 static char buff[32];
4095 case ELFCLASSNONE: return _("none");
4096 case ELFCLASS32: return "ELF32";
4097 case ELFCLASS64: return "ELF64";
4099 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4105 get_data_encoding (unsigned int encoding)
4107 static char buff[32];
4111 case ELFDATANONE: return _("none");
4112 case ELFDATA2LSB: return _("2's complement, little endian");
4113 case ELFDATA2MSB: return _("2's complement, big endian");
4115 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4120 /* Decode the data held in 'elf_header'. */
4123 process_file_header (void)
4125 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4126 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4127 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4128 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4131 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4135 init_dwarf_regnames (elf_header.e_machine);
4141 printf (_("ELF Header:\n"));
4142 printf (_(" Magic: "));
4143 for (i = 0; i < EI_NIDENT; i++)
4144 printf ("%2.2x ", elf_header.e_ident[i]);
4146 printf (_(" Class: %s\n"),
4147 get_elf_class (elf_header.e_ident[EI_CLASS]));
4148 printf (_(" Data: %s\n"),
4149 get_data_encoding (elf_header.e_ident[EI_DATA]));
4150 printf (_(" Version: %d %s\n"),
4151 elf_header.e_ident[EI_VERSION],
4152 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4154 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4155 ? _("<unknown: %lx>")
4157 printf (_(" OS/ABI: %s\n"),
4158 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4159 printf (_(" ABI Version: %d\n"),
4160 elf_header.e_ident[EI_ABIVERSION]);
4161 printf (_(" Type: %s\n"),
4162 get_file_type (elf_header.e_type));
4163 printf (_(" Machine: %s\n"),
4164 get_machine_name (elf_header.e_machine));
4165 printf (_(" Version: 0x%lx\n"),
4166 (unsigned long) elf_header.e_version);
4168 printf (_(" Entry point address: "));
4169 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4170 printf (_("\n Start of program headers: "));
4171 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4172 printf (_(" (bytes into file)\n Start of section headers: "));
4173 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4174 printf (_(" (bytes into file)\n"));
4176 printf (_(" Flags: 0x%lx%s\n"),
4177 (unsigned long) elf_header.e_flags,
4178 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4179 printf (_(" Size of this header: %ld (bytes)\n"),
4180 (long) elf_header.e_ehsize);
4181 printf (_(" Size of program headers: %ld (bytes)\n"),
4182 (long) elf_header.e_phentsize);
4183 printf (_(" Number of program headers: %ld"),
4184 (long) elf_header.e_phnum);
4185 if (section_headers != NULL
4186 && elf_header.e_phnum == PN_XNUM
4187 && section_headers[0].sh_info != 0)
4188 printf (" (%ld)", (long) section_headers[0].sh_info);
4189 putc ('\n', stdout);
4190 printf (_(" Size of section headers: %ld (bytes)\n"),
4191 (long) elf_header.e_shentsize);
4192 printf (_(" Number of section headers: %ld"),
4193 (long) elf_header.e_shnum);
4194 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4195 printf (" (%ld)", (long) section_headers[0].sh_size);
4196 putc ('\n', stdout);
4197 printf (_(" Section header string table index: %ld"),
4198 (long) elf_header.e_shstrndx);
4199 if (section_headers != NULL
4200 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4201 printf (" (%u)", section_headers[0].sh_link);
4202 else if (elf_header.e_shstrndx != SHN_UNDEF
4203 && elf_header.e_shstrndx >= elf_header.e_shnum)
4204 printf (_(" <corrupt: out of range>"));
4205 putc ('\n', stdout);
4208 if (section_headers != NULL)
4210 if (elf_header.e_phnum == PN_XNUM
4211 && section_headers[0].sh_info != 0)
4212 elf_header.e_phnum = section_headers[0].sh_info;
4213 if (elf_header.e_shnum == SHN_UNDEF)
4214 elf_header.e_shnum = section_headers[0].sh_size;
4215 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4216 elf_header.e_shstrndx = section_headers[0].sh_link;
4217 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4218 elf_header.e_shstrndx = SHN_UNDEF;
4219 free (section_headers);
4220 section_headers = NULL;
4227 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4229 Elf32_External_Phdr * phdrs;
4230 Elf32_External_Phdr * external;
4231 Elf_Internal_Phdr * internal;
4233 unsigned int size = elf_header.e_phentsize;
4234 unsigned int num = elf_header.e_phnum;
4236 /* PR binutils/17531: Cope with unexpected section header sizes. */
4237 if (size == 0 || num == 0)
4239 if (size < sizeof * phdrs)
4241 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4244 if (size > sizeof * phdrs)
4245 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4247 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4248 size, num, _("program headers"));
4252 for (i = 0, internal = pheaders, external = phdrs;
4253 i < elf_header.e_phnum;
4254 i++, internal++, external++)
4256 internal->p_type = BYTE_GET (external->p_type);
4257 internal->p_offset = BYTE_GET (external->p_offset);
4258 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4259 internal->p_paddr = BYTE_GET (external->p_paddr);
4260 internal->p_filesz = BYTE_GET (external->p_filesz);
4261 internal->p_memsz = BYTE_GET (external->p_memsz);
4262 internal->p_flags = BYTE_GET (external->p_flags);
4263 internal->p_align = BYTE_GET (external->p_align);
4271 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4273 Elf64_External_Phdr * phdrs;
4274 Elf64_External_Phdr * external;
4275 Elf_Internal_Phdr * internal;
4277 unsigned int size = elf_header.e_phentsize;
4278 unsigned int num = elf_header.e_phnum;
4280 /* PR binutils/17531: Cope with unexpected section header sizes. */
4281 if (size == 0 || num == 0)
4283 if (size < sizeof * phdrs)
4285 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4288 if (size > sizeof * phdrs)
4289 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4291 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4292 size, num, _("program headers"));
4296 for (i = 0, internal = pheaders, external = phdrs;
4297 i < elf_header.e_phnum;
4298 i++, internal++, external++)
4300 internal->p_type = BYTE_GET (external->p_type);
4301 internal->p_flags = BYTE_GET (external->p_flags);
4302 internal->p_offset = BYTE_GET (external->p_offset);
4303 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4304 internal->p_paddr = BYTE_GET (external->p_paddr);
4305 internal->p_filesz = BYTE_GET (external->p_filesz);
4306 internal->p_memsz = BYTE_GET (external->p_memsz);
4307 internal->p_align = BYTE_GET (external->p_align);
4314 /* Returns 1 if the program headers were read into `program_headers'. */
4317 get_program_headers (FILE * file)
4319 Elf_Internal_Phdr * phdrs;
4321 /* Check cache of prior read. */
4322 if (program_headers != NULL)
4325 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4326 sizeof (Elf_Internal_Phdr));
4330 error (_("Out of memory reading %u program headers\n"),
4331 elf_header.e_phnum);
4336 ? get_32bit_program_headers (file, phdrs)
4337 : get_64bit_program_headers (file, phdrs))
4339 program_headers = phdrs;
4347 /* Returns 1 if the program headers were loaded. */
4350 process_program_headers (FILE * file)
4352 Elf_Internal_Phdr * segment;
4355 if (elf_header.e_phnum == 0)
4357 /* PR binutils/12467. */
4358 if (elf_header.e_phoff != 0)
4359 warn (_("possibly corrupt ELF header - it has a non-zero program"
4360 " header offset, but no program headers"));
4361 else if (do_segments)
4362 printf (_("\nThere are no program headers in this file.\n"));
4366 if (do_segments && !do_header)
4368 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4369 printf (_("Entry point "));
4370 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4371 printf (_("\nThere are %d program headers, starting at offset "),
4372 elf_header.e_phnum);
4373 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4377 if (! get_program_headers (file))
4382 if (elf_header.e_phnum > 1)
4383 printf (_("\nProgram Headers:\n"));
4385 printf (_("\nProgram Headers:\n"));
4389 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4392 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4396 (_(" Type Offset VirtAddr PhysAddr\n"));
4398 (_(" FileSiz MemSiz Flags Align\n"));
4405 for (i = 0, segment = program_headers;
4406 i < elf_header.e_phnum;
4411 printf (" %-14.14s ", get_segment_type (segment->p_type));
4415 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4416 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4417 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4418 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4419 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4421 (segment->p_flags & PF_R ? 'R' : ' '),
4422 (segment->p_flags & PF_W ? 'W' : ' '),
4423 (segment->p_flags & PF_X ? 'E' : ' '));
4424 printf ("%#lx", (unsigned long) segment->p_align);
4428 if ((unsigned long) segment->p_offset == segment->p_offset)
4429 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4432 print_vma (segment->p_offset, FULL_HEX);
4436 print_vma (segment->p_vaddr, FULL_HEX);
4438 print_vma (segment->p_paddr, FULL_HEX);
4441 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4442 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4445 print_vma (segment->p_filesz, FULL_HEX);
4449 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4450 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4453 print_vma (segment->p_memsz, FULL_HEX);
4457 (segment->p_flags & PF_R ? 'R' : ' '),
4458 (segment->p_flags & PF_W ? 'W' : ' '),
4459 (segment->p_flags & PF_X ? 'E' : ' '));
4461 if ((unsigned long) segment->p_align == segment->p_align)
4462 printf ("%#lx", (unsigned long) segment->p_align);
4465 print_vma (segment->p_align, PREFIX_HEX);
4470 print_vma (segment->p_offset, FULL_HEX);
4472 print_vma (segment->p_vaddr, FULL_HEX);
4474 print_vma (segment->p_paddr, FULL_HEX);
4476 print_vma (segment->p_filesz, FULL_HEX);
4478 print_vma (segment->p_memsz, FULL_HEX);
4480 (segment->p_flags & PF_R ? 'R' : ' '),
4481 (segment->p_flags & PF_W ? 'W' : ' '),
4482 (segment->p_flags & PF_X ? 'E' : ' '));
4483 print_vma (segment->p_align, HEX);
4488 putc ('\n', stdout);
4490 switch (segment->p_type)
4494 error (_("more than one dynamic segment\n"));
4496 /* By default, assume that the .dynamic section is the first
4497 section in the DYNAMIC segment. */
4498 dynamic_addr = segment->p_offset;
4499 dynamic_size = segment->p_filesz;
4500 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4501 if (dynamic_addr + dynamic_size >= current_file_size)
4503 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4504 dynamic_addr = dynamic_size = 0;
4507 /* Try to locate the .dynamic section. If there is
4508 a section header table, we can easily locate it. */
4509 if (section_headers != NULL)
4511 Elf_Internal_Shdr * sec;
4513 sec = find_section (".dynamic");
4514 if (sec == NULL || sec->sh_size == 0)
4516 /* A corresponding .dynamic section is expected, but on
4517 IA-64/OpenVMS it is OK for it to be missing. */
4518 if (!is_ia64_vms ())
4519 error (_("no .dynamic section in the dynamic segment\n"));
4523 if (sec->sh_type == SHT_NOBITS)
4529 dynamic_addr = sec->sh_offset;
4530 dynamic_size = sec->sh_size;
4532 if (dynamic_addr < segment->p_offset
4533 || dynamic_addr > segment->p_offset + segment->p_filesz)
4534 warn (_("the .dynamic section is not contained"
4535 " within the dynamic segment\n"));
4536 else if (dynamic_addr > segment->p_offset)
4537 warn (_("the .dynamic section is not the first section"
4538 " in the dynamic segment.\n"));
4543 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4545 error (_("Unable to find program interpreter name\n"));
4549 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4551 if (ret >= (int) sizeof (fmt) || ret < 0)
4552 error (_("Internal error: failed to create format string to display program interpreter\n"));
4554 program_interpreter[0] = 0;
4555 if (fscanf (file, fmt, program_interpreter) <= 0)
4556 error (_("Unable to read program interpreter name\n"));
4559 printf (_(" [Requesting program interpreter: %s]\n"),
4560 program_interpreter);
4566 if (do_segments && section_headers != NULL && string_table != NULL)
4568 printf (_("\n Section to Segment mapping:\n"));
4569 printf (_(" Segment Sections...\n"));
4571 for (i = 0; i < elf_header.e_phnum; i++)
4574 Elf_Internal_Shdr * section;
4576 segment = program_headers + i;
4577 section = section_headers + 1;
4579 printf (" %2.2d ", i);
4581 for (j = 1; j < elf_header.e_shnum; j++, section++)
4583 if (!ELF_TBSS_SPECIAL (section, segment)
4584 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4585 printf ("%s ", printable_section_name (section));
4596 /* Find the file offset corresponding to VMA by using the program headers. */
4599 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4601 Elf_Internal_Phdr * seg;
4603 if (! get_program_headers (file))
4605 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4609 for (seg = program_headers;
4610 seg < program_headers + elf_header.e_phnum;
4613 if (seg->p_type != PT_LOAD)
4616 if (vma >= (seg->p_vaddr & -seg->p_align)
4617 && vma + size <= seg->p_vaddr + seg->p_filesz)
4618 return vma - seg->p_vaddr + seg->p_offset;
4621 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4622 (unsigned long) vma);
4627 /* Allocate memory and load the sections headers into the global pointer
4628 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4629 generate any error messages if the load fails. */
4632 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4634 Elf32_External_Shdr * shdrs;
4635 Elf_Internal_Shdr * internal;
4637 unsigned int size = elf_header.e_shentsize;
4638 unsigned int num = probe ? 1 : elf_header.e_shnum;
4640 /* PR binutils/17531: Cope with unexpected section header sizes. */
4641 if (size == 0 || num == 0)
4643 if (size < sizeof * shdrs)
4646 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4649 if (!probe && size > sizeof * shdrs)
4650 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4652 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4654 probe ? NULL : _("section headers"));
4658 if (section_headers != NULL)
4659 free (section_headers);
4660 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4661 sizeof (Elf_Internal_Shdr));
4662 if (section_headers == NULL)
4665 error (_("Out of memory reading %u section headers\n"), num);
4669 for (i = 0, internal = section_headers;
4673 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4674 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4675 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4676 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4677 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4678 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4679 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4680 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4681 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4682 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4690 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4692 Elf64_External_Shdr * shdrs;
4693 Elf_Internal_Shdr * internal;
4695 unsigned int size = elf_header.e_shentsize;
4696 unsigned int num = probe ? 1 : elf_header.e_shnum;
4698 /* PR binutils/17531: Cope with unexpected section header sizes. */
4699 if (size == 0 || num == 0)
4701 if (size < sizeof * shdrs)
4704 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4707 if (! probe && size > sizeof * shdrs)
4708 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4710 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4712 probe ? NULL : _("section headers"));
4716 if (section_headers != NULL)
4717 free (section_headers);
4718 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4719 sizeof (Elf_Internal_Shdr));
4720 if (section_headers == NULL)
4723 error (_("Out of memory reading %u section headers\n"), num);
4727 for (i = 0, internal = section_headers;
4731 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4732 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4733 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4734 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4735 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4736 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4737 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4738 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4739 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4740 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4747 static Elf_Internal_Sym *
4748 get_32bit_elf_symbols (FILE * file,
4749 Elf_Internal_Shdr * section,
4750 unsigned long * num_syms_return)
4752 unsigned long number = 0;
4753 Elf32_External_Sym * esyms = NULL;
4754 Elf_External_Sym_Shndx * shndx = NULL;
4755 Elf_Internal_Sym * isyms = NULL;
4756 Elf_Internal_Sym * psym;
4759 /* Run some sanity checks first. */
4760 if (section->sh_entsize == 0)
4762 error (_("sh_entsize is zero\n"));
4766 if (section->sh_size > current_file_size)
4768 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4769 printable_section_name (section), (unsigned long) section->sh_size);
4773 number = section->sh_size / section->sh_entsize;
4775 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4777 error (_("Invalid sh_entsize\n"));
4781 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4782 section->sh_size, _("symbols"));
4787 if (symtab_shndx_hdr != NULL
4788 && (symtab_shndx_hdr->sh_link
4789 == (unsigned long) (section - section_headers)))
4791 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4792 symtab_shndx_hdr->sh_offset,
4793 1, symtab_shndx_hdr->sh_size,
4794 _("symbol table section indicies"));
4799 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4803 error (_("Out of memory reading %lu symbols\n"),
4804 (unsigned long) number);
4808 for (j = 0, psym = isyms; j < number; j++, psym++)
4810 psym->st_name = BYTE_GET (esyms[j].st_name);
4811 psym->st_value = BYTE_GET (esyms[j].st_value);
4812 psym->st_size = BYTE_GET (esyms[j].st_size);
4813 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4814 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4816 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4817 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4818 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4819 psym->st_info = BYTE_GET (esyms[j].st_info);
4820 psym->st_other = BYTE_GET (esyms[j].st_other);
4829 if (num_syms_return != NULL)
4830 * num_syms_return = isyms == NULL ? 0 : number;
4835 static Elf_Internal_Sym *
4836 get_64bit_elf_symbols (FILE * file,
4837 Elf_Internal_Shdr * section,
4838 unsigned long * num_syms_return)
4840 unsigned long number = 0;
4841 Elf64_External_Sym * esyms = NULL;
4842 Elf_External_Sym_Shndx * shndx = NULL;
4843 Elf_Internal_Sym * isyms = NULL;
4844 Elf_Internal_Sym * psym;
4847 /* Run some sanity checks first. */
4848 if (section->sh_entsize == 0)
4850 error (_("sh_entsize is zero\n"));
4854 if (section->sh_size > current_file_size)
4856 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4857 printable_section_name (section), (unsigned long) section->sh_size);
4861 number = section->sh_size / section->sh_entsize;
4863 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4865 error (_("Invalid sh_entsize\n"));
4869 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4870 section->sh_size, _("symbols"));
4874 if (symtab_shndx_hdr != NULL
4875 && (symtab_shndx_hdr->sh_link
4876 == (unsigned long) (section - section_headers)))
4878 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4879 symtab_shndx_hdr->sh_offset,
4880 1, symtab_shndx_hdr->sh_size,
4881 _("symbol table section indicies"));
4886 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4890 error (_("Out of memory reading %lu symbols\n"),
4891 (unsigned long) number);
4895 for (j = 0, psym = isyms; j < number; j++, psym++)
4897 psym->st_name = BYTE_GET (esyms[j].st_name);
4898 psym->st_info = BYTE_GET (esyms[j].st_info);
4899 psym->st_other = BYTE_GET (esyms[j].st_other);
4900 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4902 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4904 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4905 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4906 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4908 psym->st_value = BYTE_GET (esyms[j].st_value);
4909 psym->st_size = BYTE_GET (esyms[j].st_size);
4918 if (num_syms_return != NULL)
4919 * num_syms_return = isyms == NULL ? 0 : number;
4925 get_elf_section_flags (bfd_vma sh_flags)
4927 static char buff[1024];
4929 int field_size = is_32bit_elf ? 8 : 16;
4931 int size = sizeof (buff) - (field_size + 4 + 1);
4932 bfd_vma os_flags = 0;
4933 bfd_vma proc_flags = 0;
4934 bfd_vma unknown_flags = 0;
4942 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4943 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4944 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4945 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4946 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4947 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4948 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4949 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4950 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4951 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4952 /* IA-64 specific. */
4953 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4954 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4955 /* IA-64 OpenVMS specific. */
4956 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4957 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4958 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4959 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4960 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4961 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4963 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4964 /* SPARC specific. */
4965 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4968 if (do_section_details)
4970 sprintf (buff, "[%*.*lx]: ",
4971 field_size, field_size, (unsigned long) sh_flags);
4972 p += field_size + 4;
4979 flag = sh_flags & - sh_flags;
4982 if (do_section_details)
4986 case SHF_WRITE: sindex = 0; break;
4987 case SHF_ALLOC: sindex = 1; break;
4988 case SHF_EXECINSTR: sindex = 2; break;
4989 case SHF_MERGE: sindex = 3; break;
4990 case SHF_STRINGS: sindex = 4; break;
4991 case SHF_INFO_LINK: sindex = 5; break;
4992 case SHF_LINK_ORDER: sindex = 6; break;
4993 case SHF_OS_NONCONFORMING: sindex = 7; break;
4994 case SHF_GROUP: sindex = 8; break;
4995 case SHF_TLS: sindex = 9; break;
4996 case SHF_EXCLUDE: sindex = 18; break;
5000 switch (elf_header.e_machine)
5003 if (flag == SHF_IA_64_SHORT)
5005 else if (flag == SHF_IA_64_NORECOV)
5008 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5011 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5012 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5013 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5014 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5015 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5016 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5027 case EM_OLD_SPARCV9:
5028 case EM_SPARC32PLUS:
5031 if (flag == SHF_ORDERED)
5041 if (p != buff + field_size + 4)
5043 if (size < (10 + 2))
5050 size -= flags [sindex].len;
5051 p = stpcpy (p, flags [sindex].str);
5053 else if (flag & SHF_MASKOS)
5055 else if (flag & SHF_MASKPROC)
5058 unknown_flags |= flag;
5064 case SHF_WRITE: *p = 'W'; break;
5065 case SHF_ALLOC: *p = 'A'; break;
5066 case SHF_EXECINSTR: *p = 'X'; break;
5067 case SHF_MERGE: *p = 'M'; break;
5068 case SHF_STRINGS: *p = 'S'; break;
5069 case SHF_INFO_LINK: *p = 'I'; break;
5070 case SHF_LINK_ORDER: *p = 'L'; break;
5071 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5072 case SHF_GROUP: *p = 'G'; break;
5073 case SHF_TLS: *p = 'T'; break;
5074 case SHF_EXCLUDE: *p = 'E'; break;
5077 if ((elf_header.e_machine == EM_X86_64
5078 || elf_header.e_machine == EM_L1OM
5079 || elf_header.e_machine == EM_K1OM)
5080 && flag == SHF_X86_64_LARGE)
5082 else if (flag & SHF_MASKOS)
5085 sh_flags &= ~ SHF_MASKOS;
5087 else if (flag & SHF_MASKPROC)
5090 sh_flags &= ~ SHF_MASKPROC;
5100 if (do_section_details)
5104 size -= 5 + field_size;
5105 if (p != buff + field_size + 4)
5113 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5114 (unsigned long) os_flags);
5115 p += 5 + field_size;
5119 size -= 7 + field_size;
5120 if (p != buff + field_size + 4)
5128 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5129 (unsigned long) proc_flags);
5130 p += 7 + field_size;
5134 size -= 10 + field_size;
5135 if (p != buff + field_size + 4)
5143 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5144 (unsigned long) unknown_flags);
5145 p += 10 + field_size;
5154 process_section_headers (FILE * file)
5156 Elf_Internal_Shdr * section;
5159 section_headers = NULL;
5161 if (elf_header.e_shnum == 0)
5163 /* PR binutils/12467. */
5164 if (elf_header.e_shoff != 0)
5165 warn (_("possibly corrupt ELF file header - it has a non-zero"
5166 " section header offset, but no section headers\n"));
5167 else if (do_sections)
5168 printf (_("\nThere are no sections in this file.\n"));
5173 if (do_sections && !do_header)
5174 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5175 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5179 if (! get_32bit_section_headers (file, FALSE))
5182 else if (! get_64bit_section_headers (file, FALSE))
5185 /* Read in the string table, so that we have names to display. */
5186 if (elf_header.e_shstrndx != SHN_UNDEF
5187 && elf_header.e_shstrndx < elf_header.e_shnum)
5189 section = section_headers + elf_header.e_shstrndx;
5191 if (section->sh_size != 0)
5193 string_table = (char *) get_data (NULL, file, section->sh_offset,
5194 1, section->sh_size,
5197 string_table_length = string_table != NULL ? section->sh_size : 0;
5201 /* Scan the sections for the dynamic symbol table
5202 and dynamic string table and debug sections. */
5203 dynamic_symbols = NULL;
5204 dynamic_strings = NULL;
5205 dynamic_syminfo = NULL;
5206 symtab_shndx_hdr = NULL;
5208 eh_addr_size = is_32bit_elf ? 4 : 8;
5209 switch (elf_header.e_machine)
5212 case EM_MIPS_RS3_LE:
5213 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5214 FDE addresses. However, the ABI also has a semi-official ILP32
5215 variant for which the normal FDE address size rules apply.
5217 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5218 section, where XX is the size of longs in bits. Unfortunately,
5219 earlier compilers provided no way of distinguishing ILP32 objects
5220 from LP64 objects, so if there's any doubt, we should assume that
5221 the official LP64 form is being used. */
5222 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5223 && find_section (".gcc_compiled_long32") == NULL)
5229 switch (elf_header.e_flags & EF_H8_MACH)
5231 case E_H8_MACH_H8300:
5232 case E_H8_MACH_H8300HN:
5233 case E_H8_MACH_H8300SN:
5234 case E_H8_MACH_H8300SXN:
5237 case E_H8_MACH_H8300H:
5238 case E_H8_MACH_H8300S:
5239 case E_H8_MACH_H8300SX:
5247 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5249 case EF_M32C_CPU_M16C:
5256 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5259 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5260 if (section->sh_entsize != expected_entsize) \
5263 sprintf_vma (buf, section->sh_entsize); \
5264 /* Note: coded this way so that there is a single string for \
5266 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5267 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5268 (unsigned) expected_entsize); \
5269 section->sh_entsize = expected_entsize; \
5274 #define CHECK_ENTSIZE(section, i, type) \
5275 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5276 sizeof (Elf64_External_##type))
5278 for (i = 0, section = section_headers;
5279 i < elf_header.e_shnum;
5282 char * name = SECTION_NAME (section);
5284 if (section->sh_type == SHT_DYNSYM)
5286 if (dynamic_symbols != NULL)
5288 error (_("File contains multiple dynamic symbol tables\n"));
5292 CHECK_ENTSIZE (section, i, Sym);
5293 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5295 else if (section->sh_type == SHT_STRTAB
5296 && streq (name, ".dynstr"))
5298 if (dynamic_strings != NULL)
5300 error (_("File contains multiple dynamic string tables\n"));
5304 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5305 1, section->sh_size,
5306 _("dynamic strings"));
5307 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5309 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5311 if (symtab_shndx_hdr != NULL)
5313 error (_("File contains multiple symtab shndx tables\n"));
5316 symtab_shndx_hdr = section;
5318 else if (section->sh_type == SHT_SYMTAB)
5319 CHECK_ENTSIZE (section, i, Sym);
5320 else if (section->sh_type == SHT_GROUP)
5321 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5322 else if (section->sh_type == SHT_REL)
5323 CHECK_ENTSIZE (section, i, Rel);
5324 else if (section->sh_type == SHT_RELA)
5325 CHECK_ENTSIZE (section, i, Rela);
5326 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5327 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5328 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5329 || do_debug_str || do_debug_loc || do_debug_ranges
5330 || do_debug_addr || do_debug_cu_index)
5331 && (const_strneq (name, ".debug_")
5332 || const_strneq (name, ".zdebug_")))
5335 name += sizeof (".zdebug_") - 1;
5337 name += sizeof (".debug_") - 1;
5340 || (do_debug_info && const_strneq (name, "info"))
5341 || (do_debug_info && const_strneq (name, "types"))
5342 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5343 || (do_debug_lines && strcmp (name, "line") == 0)
5344 || (do_debug_lines && const_strneq (name, "line."))
5345 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5346 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5347 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5348 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5349 || (do_debug_aranges && const_strneq (name, "aranges"))
5350 || (do_debug_ranges && const_strneq (name, "ranges"))
5351 || (do_debug_frames && const_strneq (name, "frame"))
5352 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5353 || (do_debug_macinfo && const_strneq (name, "macro"))
5354 || (do_debug_str && const_strneq (name, "str"))
5355 || (do_debug_loc && const_strneq (name, "loc"))
5356 || (do_debug_addr && const_strneq (name, "addr"))
5357 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5358 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5360 request_dump_bynumber (i, DEBUG_DUMP);
5362 /* Linkonce section to be combined with .debug_info at link time. */
5363 else if ((do_debugging || do_debug_info)
5364 && const_strneq (name, ".gnu.linkonce.wi."))
5365 request_dump_bynumber (i, DEBUG_DUMP);
5366 else if (do_debug_frames && streq (name, ".eh_frame"))
5367 request_dump_bynumber (i, DEBUG_DUMP);
5368 else if (do_gdb_index && streq (name, ".gdb_index"))
5369 request_dump_bynumber (i, DEBUG_DUMP);
5370 /* Trace sections for Itanium VMS. */
5371 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5372 || do_trace_aranges)
5373 && const_strneq (name, ".trace_"))
5375 name += sizeof (".trace_") - 1;
5378 || (do_trace_info && streq (name, "info"))
5379 || (do_trace_abbrevs && streq (name, "abbrev"))
5380 || (do_trace_aranges && streq (name, "aranges"))
5382 request_dump_bynumber (i, DEBUG_DUMP);
5389 if (elf_header.e_shnum > 1)
5390 printf (_("\nSection Headers:\n"));
5392 printf (_("\nSection Header:\n"));
5396 if (do_section_details)
5398 printf (_(" [Nr] Name\n"));
5399 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5403 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5407 if (do_section_details)
5409 printf (_(" [Nr] Name\n"));
5410 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5414 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5418 if (do_section_details)
5420 printf (_(" [Nr] Name\n"));
5421 printf (_(" Type Address Offset Link\n"));
5422 printf (_(" Size EntSize Info Align\n"));
5426 printf (_(" [Nr] Name Type Address Offset\n"));
5427 printf (_(" Size EntSize Flags Link Info Align\n"));
5431 if (do_section_details)
5432 printf (_(" Flags\n"));
5434 for (i = 0, section = section_headers;
5435 i < elf_header.e_shnum;
5438 printf (" [%2u] ", i);
5439 if (do_section_details)
5440 printf ("%s\n ", printable_section_name (section));
5442 print_symbol (-17, SECTION_NAME (section));
5444 printf (do_wide ? " %-15s " : " %-15.15s ",
5445 get_section_type_name (section->sh_type));
5449 const char * link_too_big = NULL;
5451 print_vma (section->sh_addr, LONG_HEX);
5453 printf ( " %6.6lx %6.6lx %2.2lx",
5454 (unsigned long) section->sh_offset,
5455 (unsigned long) section->sh_size,
5456 (unsigned long) section->sh_entsize);
5458 if (do_section_details)
5459 fputs (" ", stdout);
5461 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5463 if (section->sh_link >= elf_header.e_shnum)
5466 /* The sh_link value is out of range. Normally this indicates
5467 an error but it can have special values in Solaris binaries. */
5468 switch (elf_header.e_machine)
5475 case EM_OLD_SPARCV9:
5476 case EM_SPARC32PLUS:
5479 if (section->sh_link == (SHN_BEFORE & 0xffff))
5480 link_too_big = "BEFORE";
5481 else if (section->sh_link == (SHN_AFTER & 0xffff))
5482 link_too_big = "AFTER";
5489 if (do_section_details)
5491 if (link_too_big != NULL && * link_too_big)
5492 printf ("<%s> ", link_too_big);
5494 printf ("%2u ", section->sh_link);
5495 printf ("%3u %2lu\n", section->sh_info,
5496 (unsigned long) section->sh_addralign);
5499 printf ("%2u %3u %2lu\n",
5502 (unsigned long) section->sh_addralign);
5504 if (link_too_big && ! * link_too_big)
5505 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5506 i, section->sh_link);
5510 print_vma (section->sh_addr, LONG_HEX);
5512 if ((long) section->sh_offset == section->sh_offset)
5513 printf (" %6.6lx", (unsigned long) section->sh_offset);
5517 print_vma (section->sh_offset, LONG_HEX);
5520 if ((unsigned long) section->sh_size == section->sh_size)
5521 printf (" %6.6lx", (unsigned long) section->sh_size);
5525 print_vma (section->sh_size, LONG_HEX);
5528 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5529 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5533 print_vma (section->sh_entsize, LONG_HEX);
5536 if (do_section_details)
5537 fputs (" ", stdout);
5539 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5541 printf ("%2u %3u ", section->sh_link, section->sh_info);
5543 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5544 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5547 print_vma (section->sh_addralign, DEC);
5551 else if (do_section_details)
5553 printf (" %-15.15s ",
5554 get_section_type_name (section->sh_type));
5555 print_vma (section->sh_addr, LONG_HEX);
5556 if ((long) section->sh_offset == section->sh_offset)
5557 printf (" %16.16lx", (unsigned long) section->sh_offset);
5561 print_vma (section->sh_offset, LONG_HEX);
5563 printf (" %u\n ", section->sh_link);
5564 print_vma (section->sh_size, LONG_HEX);
5566 print_vma (section->sh_entsize, LONG_HEX);
5568 printf (" %-16u %lu\n",
5570 (unsigned long) section->sh_addralign);
5575 print_vma (section->sh_addr, LONG_HEX);
5576 if ((long) section->sh_offset == section->sh_offset)
5577 printf (" %8.8lx", (unsigned long) section->sh_offset);
5581 print_vma (section->sh_offset, LONG_HEX);
5584 print_vma (section->sh_size, LONG_HEX);
5586 print_vma (section->sh_entsize, LONG_HEX);
5588 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5590 printf (" %2u %3u %lu\n",
5593 (unsigned long) section->sh_addralign);
5596 if (do_section_details)
5597 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5600 if (!do_section_details)
5602 if (elf_header.e_machine == EM_X86_64
5603 || elf_header.e_machine == EM_L1OM
5604 || elf_header.e_machine == EM_K1OM)
5605 printf (_("Key to Flags:\n\
5606 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5607 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5608 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5610 printf (_("Key to Flags:\n\
5611 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5612 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5613 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5620 get_group_flags (unsigned int flags)
5622 static char buff[32];
5632 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5639 process_section_groups (FILE * file)
5641 Elf_Internal_Shdr * section;
5643 struct group * group;
5644 Elf_Internal_Shdr * symtab_sec;
5645 Elf_Internal_Shdr * strtab_sec;
5646 Elf_Internal_Sym * symtab;
5647 unsigned long num_syms;
5651 /* Don't process section groups unless needed. */
5652 if (!do_unwind && !do_section_groups)
5655 if (elf_header.e_shnum == 0)
5657 if (do_section_groups)
5658 printf (_("\nThere are no sections to group in this file.\n"));
5663 if (section_headers == NULL)
5665 error (_("Section headers are not available!\n"));
5666 /* PR 13622: This can happen with a corrupt ELF header. */
5670 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5671 sizeof (struct group *));
5673 if (section_headers_groups == NULL)
5675 error (_("Out of memory reading %u section group headers\n"),
5676 elf_header.e_shnum);
5680 /* Scan the sections for the group section. */
5682 for (i = 0, section = section_headers;
5683 i < elf_header.e_shnum;
5685 if (section->sh_type == SHT_GROUP)
5688 if (group_count == 0)
5690 if (do_section_groups)
5691 printf (_("\nThere are no section groups in this file.\n"));
5696 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5698 if (section_groups == NULL)
5700 error (_("Out of memory reading %lu groups\n"),
5701 (unsigned long) group_count);
5711 for (i = 0, section = section_headers, group = section_groups;
5712 i < elf_header.e_shnum;
5715 if (section->sh_type == SHT_GROUP)
5717 const char * name = printable_section_name (section);
5718 const char * group_name;
5719 unsigned char * start;
5720 unsigned char * indices;
5721 unsigned int entry, j, size;
5722 Elf_Internal_Shdr * sec;
5723 Elf_Internal_Sym * sym;
5725 /* Get the symbol table. */
5726 if (section->sh_link >= elf_header.e_shnum
5727 || ((sec = section_headers + section->sh_link)->sh_type
5730 error (_("Bad sh_link in group section `%s'\n"), name);
5734 if (symtab_sec != sec)
5739 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5744 error (_("Corrupt header in group section `%s'\n"), name);
5748 if (section->sh_info >= num_syms)
5750 error (_("Bad sh_info in group section `%s'\n"), name);
5754 sym = symtab + section->sh_info;
5756 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5758 if (sym->st_shndx == 0
5759 || sym->st_shndx >= elf_header.e_shnum)
5761 error (_("Bad sh_info in group section `%s'\n"), name);
5765 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5774 /* Get the string table. */
5775 if (symtab_sec->sh_link >= elf_header.e_shnum)
5784 != (sec = section_headers + symtab_sec->sh_link))
5790 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5791 1, strtab_sec->sh_size,
5793 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5795 group_name = sym->st_name < strtab_size
5796 ? strtab + sym->st_name : _("<corrupt>");
5799 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5800 1, section->sh_size,
5806 size = (section->sh_size / section->sh_entsize) - 1;
5807 entry = byte_get (indices, 4);
5810 if (do_section_groups)
5812 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5813 get_group_flags (entry), i, name, group_name, size);
5815 printf (_(" [Index] Name\n"));
5818 group->group_index = i;
5820 for (j = 0; j < size; j++)
5822 struct group_list * g;
5824 entry = byte_get (indices, 4);
5827 if (entry >= elf_header.e_shnum)
5829 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5830 entry, i, elf_header.e_shnum - 1);
5834 if (section_headers_groups [entry] != NULL)
5838 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5840 section_headers_groups [entry]->group_index);
5845 /* Intel C/C++ compiler may put section 0 in a
5846 section group. We just warn it the first time
5847 and ignore it afterwards. */
5848 static int warned = 0;
5851 error (_("section 0 in group section [%5u]\n"),
5852 section_headers_groups [entry]->group_index);
5858 section_headers_groups [entry] = group;
5860 if (do_section_groups)
5862 sec = section_headers + entry;
5863 printf (" [%5u] %s\n", entry, printable_section_name (sec));
5866 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5867 g->section_index = entry;
5868 g->next = group->root;
5886 /* Data used to display dynamic fixups. */
5888 struct ia64_vms_dynfixup
5890 bfd_vma needed_ident; /* Library ident number. */
5891 bfd_vma needed; /* Index in the dstrtab of the library name. */
5892 bfd_vma fixup_needed; /* Index of the library. */
5893 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5894 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5897 /* Data used to display dynamic relocations. */
5899 struct ia64_vms_dynimgrela
5901 bfd_vma img_rela_cnt; /* Number of relocations. */
5902 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5905 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5909 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5910 const char *strtab, unsigned int strtab_sz)
5912 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5914 const char *lib_name;
5916 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5917 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5918 _("dynamic section image fixups"));
5922 if (fixup->needed < strtab_sz)
5923 lib_name = strtab + fixup->needed;
5926 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5927 (unsigned long) fixup->needed);
5930 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5931 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5933 (_("Seg Offset Type SymVec DataType\n"));
5935 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5940 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5941 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5942 type = BYTE_GET (imfs [i].type);
5943 rtype = elf_ia64_reloc_type (type);
5945 printf (" 0x%08x ", type);
5947 printf (" %-32s ", rtype);
5948 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5949 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5955 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5958 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5960 Elf64_External_VMS_IMAGE_RELA *imrs;
5963 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5964 1, imgrela->img_rela_cnt * sizeof (*imrs),
5965 _("dynamic section image relocations"));
5969 printf (_("\nImage relocs\n"));
5971 (_("Seg Offset Type Addend Seg Sym Off\n"));
5973 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5978 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5979 printf ("%08" BFD_VMA_FMT "x ",
5980 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5981 type = BYTE_GET (imrs [i].type);
5982 rtype = elf_ia64_reloc_type (type);
5984 printf ("0x%08x ", type);
5986 printf ("%-31s ", rtype);
5987 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5988 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5989 printf ("%08" BFD_VMA_FMT "x\n",
5990 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5996 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5999 process_ia64_vms_dynamic_relocs (FILE *file)
6001 struct ia64_vms_dynfixup fixup;
6002 struct ia64_vms_dynimgrela imgrela;
6003 Elf_Internal_Dyn *entry;
6005 bfd_vma strtab_off = 0;
6006 bfd_vma strtab_sz = 0;
6007 char *strtab = NULL;
6009 memset (&fixup, 0, sizeof (fixup));
6010 memset (&imgrela, 0, sizeof (imgrela));
6012 /* Note: the order of the entries is specified by the OpenVMS specs. */
6013 for (entry = dynamic_section;
6014 entry < dynamic_section + dynamic_nent;
6017 switch (entry->d_tag)
6019 case DT_IA_64_VMS_STRTAB_OFFSET:
6020 strtab_off = entry->d_un.d_val;
6023 strtab_sz = entry->d_un.d_val;
6025 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6026 1, strtab_sz, _("dynamic string section"));
6029 case DT_IA_64_VMS_NEEDED_IDENT:
6030 fixup.needed_ident = entry->d_un.d_val;
6033 fixup.needed = entry->d_un.d_val;
6035 case DT_IA_64_VMS_FIXUP_NEEDED:
6036 fixup.fixup_needed = entry->d_un.d_val;
6038 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6039 fixup.fixup_rela_cnt = entry->d_un.d_val;
6041 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6042 fixup.fixup_rela_off = entry->d_un.d_val;
6044 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6047 case DT_IA_64_VMS_IMG_RELA_CNT:
6048 imgrela.img_rela_cnt = entry->d_un.d_val;
6050 case DT_IA_64_VMS_IMG_RELA_OFF:
6051 imgrela.img_rela_off = entry->d_un.d_val;
6053 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6073 } dynamic_relocations [] =
6075 { "REL", DT_REL, DT_RELSZ, FALSE },
6076 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6077 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6080 /* Process the reloc section. */
6083 process_relocs (FILE * file)
6085 unsigned long rel_size;
6086 unsigned long rel_offset;
6092 if (do_using_dynamic)
6096 int has_dynamic_reloc;
6099 has_dynamic_reloc = 0;
6101 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6103 is_rela = dynamic_relocations [i].rela;
6104 name = dynamic_relocations [i].name;
6105 rel_size = dynamic_info [dynamic_relocations [i].size];
6106 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6108 has_dynamic_reloc |= rel_size;
6110 if (is_rela == UNKNOWN)
6112 if (dynamic_relocations [i].reloc == DT_JMPREL)
6113 switch (dynamic_info[DT_PLTREL])
6127 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6128 name, rel_offset, rel_size);
6130 dump_relocations (file,
6131 offset_from_vma (file, rel_offset, rel_size),
6133 dynamic_symbols, num_dynamic_syms,
6134 dynamic_strings, dynamic_strings_length,
6140 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6142 if (! has_dynamic_reloc)
6143 printf (_("\nThere are no dynamic relocations in this file.\n"));
6147 Elf_Internal_Shdr * section;
6151 for (i = 0, section = section_headers;
6152 i < elf_header.e_shnum;
6155 if ( section->sh_type != SHT_RELA
6156 && section->sh_type != SHT_REL)
6159 rel_offset = section->sh_offset;
6160 rel_size = section->sh_size;
6164 Elf_Internal_Shdr * strsec;
6167 printf (_("\nRelocation section "));
6169 if (string_table == NULL)
6170 printf ("%d", section->sh_name);
6172 printf ("'%s'", printable_section_name (section));
6174 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6175 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6177 is_rela = section->sh_type == SHT_RELA;
6179 if (section->sh_link != 0
6180 && section->sh_link < elf_header.e_shnum)
6182 Elf_Internal_Shdr * symsec;
6183 Elf_Internal_Sym * symtab;
6184 unsigned long nsyms;
6185 unsigned long strtablen = 0;
6186 char * strtab = NULL;
6188 symsec = section_headers + section->sh_link;
6189 if (symsec->sh_type != SHT_SYMTAB
6190 && symsec->sh_type != SHT_DYNSYM)
6193 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6198 if (symsec->sh_link != 0
6199 && symsec->sh_link < elf_header.e_shnum)
6201 strsec = section_headers + symsec->sh_link;
6203 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6206 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6209 dump_relocations (file, rel_offset, rel_size,
6210 symtab, nsyms, strtab, strtablen,
6212 symsec->sh_type == SHT_DYNSYM);
6218 dump_relocations (file, rel_offset, rel_size,
6219 NULL, 0, NULL, 0, is_rela, 0);
6226 printf (_("\nThere are no relocations in this file.\n"));
6232 /* Process the unwind section. */
6234 #include "unwind-ia64.h"
6236 /* An absolute address consists of a section and an offset. If the
6237 section is NULL, the offset itself is the address, otherwise, the
6238 address equals to LOAD_ADDRESS(section) + offset. */
6242 unsigned short section;
6246 #define ABSADDR(a) \
6248 ? section_headers [(a).section].sh_addr + (a).offset \
6251 struct ia64_unw_table_entry
6253 struct absaddr start;
6255 struct absaddr info;
6258 struct ia64_unw_aux_info
6261 struct ia64_unw_table_entry *table; /* Unwind table. */
6262 unsigned long table_len; /* Length of unwind table. */
6263 unsigned char * info; /* Unwind info. */
6264 unsigned long info_size; /* Size of unwind info. */
6265 bfd_vma info_addr; /* starting address of unwind info. */
6266 bfd_vma seg_base; /* Starting address of segment. */
6267 Elf_Internal_Sym * symtab; /* The symbol table. */
6268 unsigned long nsyms; /* Number of symbols. */
6269 char * strtab; /* The string table. */
6270 unsigned long strtab_size; /* Size of string table. */
6274 find_symbol_for_address (Elf_Internal_Sym * symtab,
6275 unsigned long nsyms,
6276 const char * strtab,
6277 unsigned long strtab_size,
6278 struct absaddr addr,
6279 const char ** symname,
6282 bfd_vma dist = 0x100000;
6283 Elf_Internal_Sym * sym;
6284 Elf_Internal_Sym * best = NULL;
6287 REMOVE_ARCH_BITS (addr.offset);
6289 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6291 bfd_vma value = sym->st_value;
6293 REMOVE_ARCH_BITS (value);
6295 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6296 && sym->st_name != 0
6297 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6298 && addr.offset >= value
6299 && addr.offset - value < dist)
6302 dist = addr.offset - value;
6310 *symname = (best->st_name >= strtab_size
6311 ? _("<corrupt>") : strtab + best->st_name);
6317 *offset = addr.offset;
6321 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6323 struct ia64_unw_table_entry * tp;
6326 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6330 const unsigned char * dp;
6331 const unsigned char * head;
6332 const char * procname;
6334 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6335 aux->strtab_size, tp->start, &procname, &offset);
6337 fputs ("\n<", stdout);
6341 fputs (procname, stdout);
6344 printf ("+%lx", (unsigned long) offset);
6347 fputs (">: [", stdout);
6348 print_vma (tp->start.offset, PREFIX_HEX);
6349 fputc ('-', stdout);
6350 print_vma (tp->end.offset, PREFIX_HEX);
6351 printf ("], info at +0x%lx\n",
6352 (unsigned long) (tp->info.offset - aux->seg_base));
6354 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6355 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6357 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6358 (unsigned) UNW_VER (stamp),
6359 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6360 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6361 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6362 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6364 if (UNW_VER (stamp) != 1)
6366 printf (_("\tUnknown version.\n"));
6371 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6372 dp = unw_decode (dp, in_body, & in_body);
6377 slurp_ia64_unwind_table (FILE * file,
6378 struct ia64_unw_aux_info * aux,
6379 Elf_Internal_Shdr * sec)
6381 unsigned long size, nrelas, i;
6382 Elf_Internal_Phdr * seg;
6383 struct ia64_unw_table_entry * tep;
6384 Elf_Internal_Shdr * relsec;
6385 Elf_Internal_Rela * rela;
6386 Elf_Internal_Rela * rp;
6387 unsigned char * table;
6389 Elf_Internal_Sym * sym;
6390 const char * relname;
6392 /* First, find the starting address of the segment that includes
6395 if (elf_header.e_phnum)
6397 if (! get_program_headers (file))
6400 for (seg = program_headers;
6401 seg < program_headers + elf_header.e_phnum;
6404 if (seg->p_type != PT_LOAD)
6407 if (sec->sh_addr >= seg->p_vaddr
6408 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6410 aux->seg_base = seg->p_vaddr;
6416 /* Second, build the unwind table from the contents of the unwind section: */
6417 size = sec->sh_size;
6418 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6423 aux->table = (struct ia64_unw_table_entry *)
6424 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6426 for (tp = table; tp < table + size; ++tep)
6428 tep->start.section = SHN_UNDEF;
6429 tep->end.section = SHN_UNDEF;
6430 tep->info.section = SHN_UNDEF;
6431 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6432 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6433 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6434 tep->start.offset += aux->seg_base;
6435 tep->end.offset += aux->seg_base;
6436 tep->info.offset += aux->seg_base;
6440 /* Third, apply any relocations to the unwind table: */
6441 for (relsec = section_headers;
6442 relsec < section_headers + elf_header.e_shnum;
6445 if (relsec->sh_type != SHT_RELA
6446 || relsec->sh_info >= elf_header.e_shnum
6447 || section_headers + relsec->sh_info != sec)
6450 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6454 for (rp = rela; rp < rela + nrelas; ++rp)
6456 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6457 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6459 if (! const_strneq (relname, "R_IA64_SEGREL"))
6461 warn (_("Skipping unexpected relocation type %s\n"), relname);
6465 i = rp->r_offset / (3 * eh_addr_size);
6467 switch (rp->r_offset/eh_addr_size % 3)
6470 aux->table[i].start.section = sym->st_shndx;
6471 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6474 aux->table[i].end.section = sym->st_shndx;
6475 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6478 aux->table[i].info.section = sym->st_shndx;
6479 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6489 aux->table_len = size / (3 * eh_addr_size);
6494 ia64_process_unwind (FILE * file)
6496 Elf_Internal_Shdr * sec;
6497 Elf_Internal_Shdr * unwsec = NULL;
6498 Elf_Internal_Shdr * strsec;
6499 unsigned long i, unwcount = 0, unwstart = 0;
6500 struct ia64_unw_aux_info aux;
6502 memset (& aux, 0, sizeof (aux));
6504 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6506 if (sec->sh_type == SHT_SYMTAB
6507 && sec->sh_link < elf_header.e_shnum)
6509 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6511 strsec = section_headers + sec->sh_link;
6512 if (aux.strtab != NULL)
6514 error (_("Multiple auxillary string tables encountered\n"));
6517 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6520 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6522 else if (sec->sh_type == SHT_IA_64_UNWIND)
6527 printf (_("\nThere are no unwind sections in this file.\n"));
6529 while (unwcount-- > 0)
6534 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6535 i < elf_header.e_shnum; ++i, ++sec)
6536 if (sec->sh_type == SHT_IA_64_UNWIND)
6541 /* We have already counted the number of SHT_IA64_UNWIND
6542 sections so the loop above should never fail. */
6543 assert (unwsec != NULL);
6546 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6548 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6550 /* We need to find which section group it is in. */
6551 struct group_list * g;
6553 if (section_headers_groups == NULL
6554 || section_headers_groups [i] == NULL)
6555 i = elf_header.e_shnum;
6558 g = section_headers_groups [i]->root;
6560 for (; g != NULL; g = g->next)
6562 sec = section_headers + g->section_index;
6564 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6569 i = elf_header.e_shnum;
6572 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6574 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6575 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6576 suffix = SECTION_NAME (unwsec) + len;
6577 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6579 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6580 && streq (SECTION_NAME (sec) + len2, suffix))
6585 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6586 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6587 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6588 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6590 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6591 suffix = SECTION_NAME (unwsec) + len;
6592 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6594 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6595 && streq (SECTION_NAME (sec) + len2, suffix))
6599 if (i == elf_header.e_shnum)
6601 printf (_("\nCould not find unwind info section for "));
6603 if (string_table == NULL)
6604 printf ("%d", unwsec->sh_name);
6606 printf ("'%s'", printable_section_name (unwsec));
6610 aux.info_addr = sec->sh_addr;
6611 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6614 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6616 printf (_("\nUnwind section "));
6618 if (string_table == NULL)
6619 printf ("%d", unwsec->sh_name);
6621 printf ("'%s'", printable_section_name (unwsec));
6623 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6624 (unsigned long) unwsec->sh_offset,
6625 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6627 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6629 if (aux.table_len > 0)
6630 dump_ia64_unwind (& aux);
6633 free ((char *) aux.table);
6635 free ((char *) aux.info);
6644 free ((char *) aux.strtab);
6647 struct hppa_unw_table_entry
6649 struct absaddr start;
6651 unsigned int Cannot_unwind:1; /* 0 */
6652 unsigned int Millicode:1; /* 1 */
6653 unsigned int Millicode_save_sr0:1; /* 2 */
6654 unsigned int Region_description:2; /* 3..4 */
6655 unsigned int reserved1:1; /* 5 */
6656 unsigned int Entry_SR:1; /* 6 */
6657 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6658 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6659 unsigned int Args_stored:1; /* 16 */
6660 unsigned int Variable_Frame:1; /* 17 */
6661 unsigned int Separate_Package_Body:1; /* 18 */
6662 unsigned int Frame_Extension_Millicode:1; /* 19 */
6663 unsigned int Stack_Overflow_Check:1; /* 20 */
6664 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6665 unsigned int Ada_Region:1; /* 22 */
6666 unsigned int cxx_info:1; /* 23 */
6667 unsigned int cxx_try_catch:1; /* 24 */
6668 unsigned int sched_entry_seq:1; /* 25 */
6669 unsigned int reserved2:1; /* 26 */
6670 unsigned int Save_SP:1; /* 27 */
6671 unsigned int Save_RP:1; /* 28 */
6672 unsigned int Save_MRP_in_frame:1; /* 29 */
6673 unsigned int extn_ptr_defined:1; /* 30 */
6674 unsigned int Cleanup_defined:1; /* 31 */
6676 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6677 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6678 unsigned int Large_frame:1; /* 2 */
6679 unsigned int Pseudo_SP_Set:1; /* 3 */
6680 unsigned int reserved4:1; /* 4 */
6681 unsigned int Total_frame_size:27; /* 5..31 */
6684 struct hppa_unw_aux_info
6686 struct hppa_unw_table_entry *table; /* Unwind table. */
6687 unsigned long table_len; /* Length of unwind table. */
6688 bfd_vma seg_base; /* Starting address of segment. */
6689 Elf_Internal_Sym * symtab; /* The symbol table. */
6690 unsigned long nsyms; /* Number of symbols. */
6691 char * strtab; /* The string table. */
6692 unsigned long strtab_size; /* Size of string table. */
6696 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6698 struct hppa_unw_table_entry * tp;
6700 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6703 const char * procname;
6705 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6706 aux->strtab_size, tp->start, &procname,
6709 fputs ("\n<", stdout);
6713 fputs (procname, stdout);
6716 printf ("+%lx", (unsigned long) offset);
6719 fputs (">: [", stdout);
6720 print_vma (tp->start.offset, PREFIX_HEX);
6721 fputc ('-', stdout);
6722 print_vma (tp->end.offset, PREFIX_HEX);
6725 #define PF(_m) if (tp->_m) printf (#_m " ");
6726 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6729 PF(Millicode_save_sr0);
6730 /* PV(Region_description); */
6736 PF(Separate_Package_Body);
6737 PF(Frame_Extension_Millicode);
6738 PF(Stack_Overflow_Check);
6739 PF(Two_Instruction_SP_Increment);
6743 PF(sched_entry_seq);
6746 PF(Save_MRP_in_frame);
6747 PF(extn_ptr_defined);
6748 PF(Cleanup_defined);
6749 PF(MPE_XL_interrupt_marker);
6750 PF(HP_UX_interrupt_marker);
6753 PV(Total_frame_size);
6762 slurp_hppa_unwind_table (FILE * file,
6763 struct hppa_unw_aux_info * aux,
6764 Elf_Internal_Shdr * sec)
6766 unsigned long size, unw_ent_size, nentries, nrelas, i;
6767 Elf_Internal_Phdr * seg;
6768 struct hppa_unw_table_entry * tep;
6769 Elf_Internal_Shdr * relsec;
6770 Elf_Internal_Rela * rela;
6771 Elf_Internal_Rela * rp;
6772 unsigned char * table;
6774 Elf_Internal_Sym * sym;
6775 const char * relname;
6777 /* First, find the starting address of the segment that includes
6780 if (elf_header.e_phnum)
6782 if (! get_program_headers (file))
6785 for (seg = program_headers;
6786 seg < program_headers + elf_header.e_phnum;
6789 if (seg->p_type != PT_LOAD)
6792 if (sec->sh_addr >= seg->p_vaddr
6793 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6795 aux->seg_base = seg->p_vaddr;
6801 /* Second, build the unwind table from the contents of the unwind
6803 size = sec->sh_size;
6804 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6810 nentries = size / unw_ent_size;
6811 size = unw_ent_size * nentries;
6813 tep = aux->table = (struct hppa_unw_table_entry *)
6814 xcmalloc (nentries, sizeof (aux->table[0]));
6816 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6818 unsigned int tmp1, tmp2;
6820 tep->start.section = SHN_UNDEF;
6821 tep->end.section = SHN_UNDEF;
6823 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6824 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6825 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6826 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6828 tep->start.offset += aux->seg_base;
6829 tep->end.offset += aux->seg_base;
6831 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6832 tep->Millicode = (tmp1 >> 30) & 0x1;
6833 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6834 tep->Region_description = (tmp1 >> 27) & 0x3;
6835 tep->reserved1 = (tmp1 >> 26) & 0x1;
6836 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6837 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6838 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6839 tep->Args_stored = (tmp1 >> 15) & 0x1;
6840 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6841 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6842 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6843 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6844 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6845 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6846 tep->cxx_info = (tmp1 >> 8) & 0x1;
6847 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6848 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6849 tep->reserved2 = (tmp1 >> 5) & 0x1;
6850 tep->Save_SP = (tmp1 >> 4) & 0x1;
6851 tep->Save_RP = (tmp1 >> 3) & 0x1;
6852 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6853 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6854 tep->Cleanup_defined = tmp1 & 0x1;
6856 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6857 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6858 tep->Large_frame = (tmp2 >> 29) & 0x1;
6859 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6860 tep->reserved4 = (tmp2 >> 27) & 0x1;
6861 tep->Total_frame_size = tmp2 & 0x7ffffff;
6865 /* Third, apply any relocations to the unwind table. */
6866 for (relsec = section_headers;
6867 relsec < section_headers + elf_header.e_shnum;
6870 if (relsec->sh_type != SHT_RELA
6871 || relsec->sh_info >= elf_header.e_shnum
6872 || section_headers + relsec->sh_info != sec)
6875 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6879 for (rp = rela; rp < rela + nrelas; ++rp)
6881 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6882 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6884 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6885 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6887 warn (_("Skipping unexpected relocation type %s\n"), relname);
6891 i = rp->r_offset / unw_ent_size;
6893 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6896 aux->table[i].start.section = sym->st_shndx;
6897 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6900 aux->table[i].end.section = sym->st_shndx;
6901 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6911 aux->table_len = nentries;
6917 hppa_process_unwind (FILE * file)
6919 struct hppa_unw_aux_info aux;
6920 Elf_Internal_Shdr * unwsec = NULL;
6921 Elf_Internal_Shdr * strsec;
6922 Elf_Internal_Shdr * sec;
6925 if (string_table == NULL)
6928 memset (& aux, 0, sizeof (aux));
6930 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6932 if (sec->sh_type == SHT_SYMTAB
6933 && sec->sh_link < elf_header.e_shnum)
6935 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6937 strsec = section_headers + sec->sh_link;
6938 if (aux.strtab != NULL)
6940 error (_("Multiple auxillary string tables encountered\n"));
6943 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6946 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6948 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6953 printf (_("\nThere are no unwind sections in this file.\n"));
6955 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6957 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6959 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
6960 printable_section_name (sec),
6961 (unsigned long) sec->sh_offset,
6962 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6964 slurp_hppa_unwind_table (file, &aux, sec);
6965 if (aux.table_len > 0)
6966 dump_hppa_unwind (&aux);
6969 free ((char *) aux.table);
6977 free ((char *) aux.strtab);
6982 unsigned char * data; /* The unwind data. */
6983 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6984 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6985 unsigned long nrelas; /* The number of relocations. */
6986 unsigned int rel_type; /* REL or RELA ? */
6987 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6990 struct arm_unw_aux_info
6992 FILE * file; /* The file containing the unwind sections. */
6993 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6994 unsigned long nsyms; /* Number of symbols. */
6995 char * strtab; /* The file's string table. */
6996 unsigned long strtab_size; /* Size of string table. */
7000 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7001 bfd_vma fn, struct absaddr addr)
7003 const char *procname;
7006 if (addr.section == SHN_UNDEF)
7009 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7010 aux->strtab_size, addr, &procname,
7013 print_vma (fn, PREFIX_HEX);
7017 fputs (" <", stdout);
7018 fputs (procname, stdout);
7021 printf ("+0x%lx", (unsigned long) sym_offset);
7022 fputc ('>', stdout);
7029 arm_free_section (struct arm_section *arm_sec)
7031 if (arm_sec->data != NULL)
7032 free (arm_sec->data);
7034 if (arm_sec->rela != NULL)
7035 free (arm_sec->rela);
7038 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7039 cached section and install SEC instead.
7040 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7041 and return its valued in * WORDP, relocating if necessary.
7042 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7043 relocation's offset in ADDR.
7044 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7045 into the string table of the symbol associated with the reloc. If no
7046 reloc was applied store -1 there.
7047 5) Return TRUE upon success, FALSE otherwise. */
7050 get_unwind_section_word (struct arm_unw_aux_info * aux,
7051 struct arm_section * arm_sec,
7052 Elf_Internal_Shdr * sec,
7053 bfd_vma word_offset,
7054 unsigned int * wordp,
7055 struct absaddr * addr,
7058 Elf_Internal_Rela *rp;
7059 Elf_Internal_Sym *sym;
7060 const char * relname;
7062 bfd_boolean wrapped;
7064 if (sec == NULL || arm_sec == NULL)
7067 addr->section = SHN_UNDEF;
7070 if (sym_name != NULL)
7071 *sym_name = (bfd_vma) -1;
7073 /* If necessary, update the section cache. */
7074 if (sec != arm_sec->sec)
7076 Elf_Internal_Shdr *relsec;
7078 arm_free_section (arm_sec);
7081 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7082 sec->sh_size, _("unwind data"));
7083 arm_sec->rela = NULL;
7084 arm_sec->nrelas = 0;
7086 for (relsec = section_headers;
7087 relsec < section_headers + elf_header.e_shnum;
7090 if (relsec->sh_info >= elf_header.e_shnum
7091 || section_headers + relsec->sh_info != sec
7092 /* PR 15745: Check the section type as well. */
7093 || (relsec->sh_type != SHT_REL
7094 && relsec->sh_type != SHT_RELA))
7097 arm_sec->rel_type = relsec->sh_type;
7098 if (relsec->sh_type == SHT_REL)
7100 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7102 & arm_sec->rela, & arm_sec->nrelas))
7105 else /* relsec->sh_type == SHT_RELA */
7107 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7109 & arm_sec->rela, & arm_sec->nrelas))
7115 arm_sec->next_rela = arm_sec->rela;
7118 /* If there is no unwind data we can do nothing. */
7119 if (arm_sec->data == NULL)
7122 /* If the offset is invalid then fail. */
7123 if (word_offset > sec->sh_size - 4)
7126 /* Get the word at the required offset. */
7127 word = byte_get (arm_sec->data + word_offset, 4);
7129 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7130 if (arm_sec->rela == NULL)
7136 /* Look through the relocs to find the one that applies to the provided offset. */
7138 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7140 bfd_vma prelval, offset;
7142 if (rp->r_offset > word_offset && !wrapped)
7147 if (rp->r_offset > word_offset)
7150 if (rp->r_offset & 3)
7152 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7153 (unsigned long) rp->r_offset);
7157 if (rp->r_offset < word_offset)
7160 /* PR 17531: file: 027-161405-0.004 */
7161 if (aux->symtab == NULL)
7164 if (arm_sec->rel_type == SHT_REL)
7166 offset = word & 0x7fffffff;
7167 if (offset & 0x40000000)
7168 offset |= ~ (bfd_vma) 0x7fffffff;
7170 else if (arm_sec->rel_type == SHT_RELA)
7171 offset = rp->r_addend;
7174 error (_("Unknown section relocation type %d encountered\n"),
7179 /* PR 17531 file: 027-1241568-0.004. */
7180 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7182 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7183 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7187 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7188 offset += sym->st_value;
7189 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7191 /* Check that we are processing the expected reloc type. */
7192 if (elf_header.e_machine == EM_ARM)
7194 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7195 if (relname == NULL)
7197 warn (_("Skipping unknown ARM relocation type: %d\n"),
7198 (int) ELF32_R_TYPE (rp->r_info));
7202 if (streq (relname, "R_ARM_NONE"))
7205 if (! streq (relname, "R_ARM_PREL31"))
7207 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7211 else if (elf_header.e_machine == EM_TI_C6000)
7213 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7214 if (relname == NULL)
7216 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7217 (int) ELF32_R_TYPE (rp->r_info));
7221 if (streq (relname, "R_C6000_NONE"))
7224 if (! streq (relname, "R_C6000_PREL31"))
7226 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7234 /* This function currently only supports ARM and TI unwinders. */
7235 warn (_("Only TI and ARM unwinders are currently supported\n"));
7239 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7240 addr->section = sym->st_shndx;
7241 addr->offset = offset;
7244 * sym_name = sym->st_name;
7249 arm_sec->next_rela = rp;
7254 static const char *tic6x_unwind_regnames[16] =
7256 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7257 "A14", "A13", "A12", "A11", "A10",
7258 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7262 decode_tic6x_unwind_regmask (unsigned int mask)
7266 for (i = 12; mask; mask >>= 1, i--)
7270 fputs (tic6x_unwind_regnames[i], stdout);
7272 fputs (", ", stdout);
7278 if (remaining == 0 && more_words) \
7281 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7282 data_offset, & word, & addr, NULL)) \
7288 #define GET_OP(OP) \
7293 (OP) = word >> 24; \
7298 printf (_("[Truncated opcode]\n")); \
7301 printf ("0x%02x ", OP)
7304 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7305 unsigned int word, unsigned int remaining,
7306 unsigned int more_words,
7307 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7308 struct arm_section *data_arm_sec)
7310 struct absaddr addr;
7312 /* Decode the unwinding instructions. */
7315 unsigned int op, op2;
7324 printf (" 0x%02x ", op);
7326 if ((op & 0xc0) == 0x00)
7328 int offset = ((op & 0x3f) << 2) + 4;
7330 printf (" vsp = vsp + %d", offset);
7332 else if ((op & 0xc0) == 0x40)
7334 int offset = ((op & 0x3f) << 2) + 4;
7336 printf (" vsp = vsp - %d", offset);
7338 else if ((op & 0xf0) == 0x80)
7341 if (op == 0x80 && op2 == 0)
7342 printf (_("Refuse to unwind"));
7345 unsigned int mask = ((op & 0x0f) << 8) | op2;
7350 for (i = 0; i < 12; i++)
7351 if (mask & (1 << i))
7357 printf ("r%d", 4 + i);
7362 else if ((op & 0xf0) == 0x90)
7364 if (op == 0x9d || op == 0x9f)
7365 printf (_(" [Reserved]"));
7367 printf (" vsp = r%d", op & 0x0f);
7369 else if ((op & 0xf0) == 0xa0)
7371 int end = 4 + (op & 0x07);
7376 for (i = 4; i <= end; i++)
7392 else if (op == 0xb0)
7393 printf (_(" finish"));
7394 else if (op == 0xb1)
7397 if (op2 == 0 || (op2 & 0xf0) != 0)
7398 printf (_("[Spare]"));
7401 unsigned int mask = op2 & 0x0f;
7406 for (i = 0; i < 12; i++)
7407 if (mask & (1 << i))
7418 else if (op == 0xb2)
7420 unsigned char buf[9];
7421 unsigned int i, len;
7422 unsigned long offset;
7424 for (i = 0; i < sizeof (buf); i++)
7427 if ((buf[i] & 0x80) == 0)
7430 if (i == sizeof (buf))
7431 printf (_("corrupt change to vsp"));
7434 offset = read_uleb128 (buf, &len, buf + i + 1);
7435 assert (len == i + 1);
7436 offset = offset * 4 + 0x204;
7437 printf ("vsp = vsp + %ld", offset);
7440 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7442 unsigned int first, last;
7449 printf ("pop {D%d", first);
7451 printf ("-D%d", first + last);
7454 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7456 unsigned int count = op & 0x07;
7460 printf ("-D%d", 8 + count);
7463 else if (op >= 0xc0 && op <= 0xc5)
7465 unsigned int count = op & 0x07;
7467 printf (" pop {wR10");
7469 printf ("-wR%d", 10 + count);
7472 else if (op == 0xc6)
7474 unsigned int first, last;
7479 printf ("pop {wR%d", first);
7481 printf ("-wR%d", first + last);
7484 else if (op == 0xc7)
7487 if (op2 == 0 || (op2 & 0xf0) != 0)
7488 printf (_("[Spare]"));
7491 unsigned int mask = op2 & 0x0f;
7496 for (i = 0; i < 4; i++)
7497 if (mask & (1 << i))
7503 printf ("wCGR%d", i);
7509 printf (_(" [unsupported opcode]"));
7515 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7516 unsigned int word, unsigned int remaining,
7517 unsigned int more_words,
7518 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7519 struct arm_section *data_arm_sec)
7521 struct absaddr addr;
7523 /* Decode the unwinding instructions. */
7526 unsigned int op, op2;
7535 printf (" 0x%02x ", op);
7537 if ((op & 0xc0) == 0x00)
7539 int offset = ((op & 0x3f) << 3) + 8;
7540 printf (" sp = sp + %d", offset);
7542 else if ((op & 0xc0) == 0x80)
7545 if (op == 0x80 && op2 == 0)
7546 printf (_("Refuse to unwind"));
7549 unsigned int mask = ((op & 0x1f) << 8) | op2;
7551 printf ("pop compact {");
7555 decode_tic6x_unwind_regmask (mask);
7559 else if ((op & 0xf0) == 0xc0)
7567 unsigned int offset;
7571 /* Scan entire instruction first so that GET_OP output is not
7572 interleaved with disassembly. */
7574 for (i = 0; nregs < (op & 0xf); i++)
7580 regpos[nregs].offset = i * 2;
7581 regpos[nregs].reg = reg;
7588 regpos[nregs].offset = i * 2 + 1;
7589 regpos[nregs].reg = reg;
7594 printf (_("pop frame {"));
7596 for (i = i * 2; i > 0; i--)
7598 if (regpos[reg].offset == i - 1)
7600 name = tic6x_unwind_regnames[regpos[reg].reg];
7607 fputs (name, stdout);
7614 else if (op == 0xd0)
7615 printf (" MOV FP, SP");
7616 else if (op == 0xd1)
7617 printf (" __c6xabi_pop_rts");
7618 else if (op == 0xd2)
7620 unsigned char buf[9];
7621 unsigned int i, len;
7622 unsigned long offset;
7624 for (i = 0; i < sizeof (buf); i++)
7627 if ((buf[i] & 0x80) == 0)
7630 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7631 if (i == sizeof (buf))
7633 printf ("<corrupt sp adjust>\n");
7634 warn (_("Corrupt stack pointer adjustment detected\n"));
7638 offset = read_uleb128 (buf, &len, buf + i + 1);
7639 assert (len == i + 1);
7640 offset = offset * 8 + 0x408;
7641 printf (_("sp = sp + %ld"), offset);
7643 else if ((op & 0xf0) == 0xe0)
7645 if ((op & 0x0f) == 7)
7648 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7652 printf (_(" [unsupported opcode]"));
7659 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7663 offset = word & 0x7fffffff;
7664 if (offset & 0x40000000)
7665 offset |= ~ (bfd_vma) 0x7fffffff;
7667 if (elf_header.e_machine == EM_TI_C6000)
7670 return offset + where;
7674 decode_arm_unwind (struct arm_unw_aux_info * aux,
7676 unsigned int remaining,
7677 bfd_vma data_offset,
7678 Elf_Internal_Shdr * data_sec,
7679 struct arm_section * data_arm_sec)
7682 unsigned int more_words = 0;
7683 struct absaddr addr;
7684 bfd_vma sym_name = (bfd_vma) -1;
7688 /* Fetch the first word.
7689 Note - when decoding an object file the address extracted
7690 here will always be 0. So we also pass in the sym_name
7691 parameter so that we can find the symbol associated with
7692 the personality routine. */
7693 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7694 & word, & addr, & sym_name))
7700 if ((word & 0x80000000) == 0)
7702 /* Expand prel31 for personality routine. */
7704 const char *procname;
7706 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7707 printf (_(" Personality routine: "));
7709 && addr.section == SHN_UNDEF && addr.offset == 0
7710 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7712 procname = aux->strtab + sym_name;
7713 print_vma (fn, PREFIX_HEX);
7716 fputs (" <", stdout);
7717 fputs (procname, stdout);
7718 fputc ('>', stdout);
7722 procname = arm_print_vma_and_name (aux, fn, addr);
7723 fputc ('\n', stdout);
7725 /* The GCC personality routines use the standard compact
7726 encoding, starting with one byte giving the number of
7728 if (procname != NULL
7729 && (const_strneq (procname, "__gcc_personality_v0")
7730 || const_strneq (procname, "__gxx_personality_v0")
7731 || const_strneq (procname, "__gcj_personality_v0")
7732 || const_strneq (procname, "__gnu_objc_personality_v0")))
7739 printf (_(" [Truncated data]\n"));
7742 more_words = word >> 24;
7752 /* ARM EHABI Section 6.3:
7754 An exception-handling table entry for the compact model looks like:
7758 1 0 index Data for personalityRoutine[index] */
7760 if (elf_header.e_machine == EM_ARM
7761 && (word & 0x70000000))
7762 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7764 per_index = (word >> 24) & 0x7f;
7765 printf (_(" Compact model index: %d\n"), per_index);
7772 else if (per_index < 3)
7774 more_words = (word >> 16) & 0xff;
7780 switch (elf_header.e_machine)
7785 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7786 data_offset, data_sec, data_arm_sec);
7790 warn (_("Unknown ARM compact model index encountered\n"));
7791 printf (_(" [reserved]\n"));
7798 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7799 data_offset, data_sec, data_arm_sec);
7801 else if (per_index < 5)
7803 if (((word >> 17) & 0x7f) == 0x7f)
7804 printf (_(" Restore stack from frame pointer\n"));
7806 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7807 printf (_(" Registers restored: "));
7809 printf (" (compact) ");
7810 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7812 printf (_(" Return register: %s\n"),
7813 tic6x_unwind_regnames[word & 0xf]);
7816 printf (_(" [reserved (%d)]\n"), per_index);
7820 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7821 elf_header.e_machine);
7824 /* Decode the descriptors. Not implemented. */
7828 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7830 struct arm_section exidx_arm_sec, extab_arm_sec;
7831 unsigned int i, exidx_len;
7833 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7834 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7835 exidx_len = exidx_sec->sh_size / 8;
7837 for (i = 0; i < exidx_len; i++)
7839 unsigned int exidx_fn, exidx_entry;
7840 struct absaddr fn_addr, entry_addr;
7843 fputc ('\n', stdout);
7845 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7846 8 * i, & exidx_fn, & fn_addr, NULL)
7847 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7848 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7850 arm_free_section (& exidx_arm_sec);
7851 arm_free_section (& extab_arm_sec);
7855 /* ARM EHABI, Section 5:
7856 An index table entry consists of 2 words.
7857 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7858 if (exidx_fn & 0x80000000)
7859 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7861 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7863 arm_print_vma_and_name (aux, fn, fn_addr);
7864 fputs (": ", stdout);
7866 if (exidx_entry == 1)
7868 print_vma (exidx_entry, PREFIX_HEX);
7869 fputs (" [cantunwind]\n", stdout);
7871 else if (exidx_entry & 0x80000000)
7873 print_vma (exidx_entry, PREFIX_HEX);
7874 fputc ('\n', stdout);
7875 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7879 bfd_vma table, table_offset = 0;
7880 Elf_Internal_Shdr *table_sec;
7882 fputs ("@", stdout);
7883 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7884 print_vma (table, PREFIX_HEX);
7887 /* Locate the matching .ARM.extab. */
7888 if (entry_addr.section != SHN_UNDEF
7889 && entry_addr.section < elf_header.e_shnum)
7891 table_sec = section_headers + entry_addr.section;
7892 table_offset = entry_addr.offset;
7896 table_sec = find_section_by_address (table);
7897 if (table_sec != NULL)
7898 table_offset = table - table_sec->sh_addr;
7900 if (table_sec == NULL)
7902 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7903 (unsigned long) table);
7906 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7913 arm_free_section (&exidx_arm_sec);
7914 arm_free_section (&extab_arm_sec);
7917 /* Used for both ARM and C6X unwinding tables. */
7920 arm_process_unwind (FILE *file)
7922 struct arm_unw_aux_info aux;
7923 Elf_Internal_Shdr *unwsec = NULL;
7924 Elf_Internal_Shdr *strsec;
7925 Elf_Internal_Shdr *sec;
7927 unsigned int sec_type;
7929 switch (elf_header.e_machine)
7932 sec_type = SHT_ARM_EXIDX;
7936 sec_type = SHT_C6000_UNWIND;
7940 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
7941 elf_header.e_machine);
7945 if (string_table == NULL)
7948 memset (& aux, 0, sizeof (aux));
7951 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7953 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7955 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7957 strsec = section_headers + sec->sh_link;
7959 /* PR binutils/17531 file: 011-12666-0.004. */
7960 if (aux.strtab != NULL)
7962 error (_("Multiple string tables found in file.\n"));
7965 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7966 1, strsec->sh_size, _("string table"));
7967 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7969 else if (sec->sh_type == sec_type)
7974 printf (_("\nThere are no unwind sections in this file.\n"));
7976 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7978 if (sec->sh_type == sec_type)
7980 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7981 printable_section_name (sec),
7982 (unsigned long) sec->sh_offset,
7983 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7985 dump_arm_unwind (&aux, sec);
7992 free ((char *) aux.strtab);
7996 process_unwind (FILE * file)
7998 struct unwind_handler
8001 void (* handler)(FILE *);
8004 { EM_ARM, arm_process_unwind },
8005 { EM_IA_64, ia64_process_unwind },
8006 { EM_PARISC, hppa_process_unwind },
8007 { EM_TI_C6000, arm_process_unwind },
8015 for (i = 0; handlers[i].handler != NULL; i++)
8016 if (elf_header.e_machine == handlers[i].machtype)
8018 handlers[i].handler (file);
8022 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8023 get_machine_name (elf_header.e_machine));
8027 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8029 switch (entry->d_tag)
8032 if (entry->d_un.d_val == 0)
8036 static const char * opts[] =
8038 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8039 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8040 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8041 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8047 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8048 if (entry->d_un.d_val & (1 << cnt))
8050 printf ("%s%s", first ? "" : " ", opts[cnt]);
8056 case DT_MIPS_IVERSION:
8057 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8058 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8062 sprintf_vma (buf, entry->d_un.d_ptr);
8063 /* Note: coded this way so that there is a single string for translation. */
8064 printf (_("<corrupt: %s>"), buf);
8068 case DT_MIPS_TIME_STAMP:
8073 time_t atime = entry->d_un.d_val;
8074 tmp = gmtime (&atime);
8075 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8076 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8077 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8078 printf (_("Time Stamp: %s"), timebuf);
8082 case DT_MIPS_RLD_VERSION:
8083 case DT_MIPS_LOCAL_GOTNO:
8084 case DT_MIPS_CONFLICTNO:
8085 case DT_MIPS_LIBLISTNO:
8086 case DT_MIPS_SYMTABNO:
8087 case DT_MIPS_UNREFEXTNO:
8088 case DT_MIPS_HIPAGENO:
8089 case DT_MIPS_DELTA_CLASS_NO:
8090 case DT_MIPS_DELTA_INSTANCE_NO:
8091 case DT_MIPS_DELTA_RELOC_NO:
8092 case DT_MIPS_DELTA_SYM_NO:
8093 case DT_MIPS_DELTA_CLASSSYM_NO:
8094 case DT_MIPS_COMPACT_SIZE:
8095 print_vma (entry->d_un.d_ptr, DEC);
8099 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8105 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8107 switch (entry->d_tag)
8109 case DT_HP_DLD_FLAGS:
8118 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8119 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8120 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8121 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8122 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8123 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8124 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8125 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8126 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8127 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8128 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8129 { DT_HP_GST, "HP_GST" },
8130 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8131 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8132 { DT_HP_NODELETE, "HP_NODELETE" },
8133 { DT_HP_GROUP, "HP_GROUP" },
8134 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8138 bfd_vma val = entry->d_un.d_val;
8140 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8141 if (val & flags[cnt].bit)
8145 fputs (flags[cnt].str, stdout);
8147 val ^= flags[cnt].bit;
8150 if (val != 0 || first)
8154 print_vma (val, HEX);
8160 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8168 /* VMS vs Unix time offset and factor. */
8170 #define VMS_EPOCH_OFFSET 35067168000000000LL
8171 #define VMS_GRANULARITY_FACTOR 10000000
8173 /* Display a VMS time in a human readable format. */
8176 print_vms_time (bfd_int64_t vmstime)
8181 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8182 tm = gmtime (&unxtime);
8183 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8184 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8185 tm->tm_hour, tm->tm_min, tm->tm_sec);
8190 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8192 switch (entry->d_tag)
8194 case DT_IA_64_PLT_RESERVE:
8195 /* First 3 slots reserved. */
8196 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8198 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8201 case DT_IA_64_VMS_LINKTIME:
8203 print_vms_time (entry->d_un.d_val);
8207 case DT_IA_64_VMS_LNKFLAGS:
8208 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8209 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8210 printf (" CALL_DEBUG");
8211 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8212 printf (" NOP0BUFS");
8213 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8214 printf (" P0IMAGE");
8215 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8216 printf (" MKTHREADS");
8217 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8218 printf (" UPCALLS");
8219 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8221 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8222 printf (" INITIALIZE");
8223 if (entry->d_un.d_val & VMS_LF_MAIN)
8225 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8226 printf (" EXE_INIT");
8227 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8228 printf (" TBK_IN_IMG");
8229 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8230 printf (" DBG_IN_IMG");
8231 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8232 printf (" TBK_IN_DSF");
8233 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8234 printf (" DBG_IN_DSF");
8235 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8236 printf (" SIGNATURES");
8237 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8238 printf (" REL_SEG_OFF");
8242 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8249 get_32bit_dynamic_section (FILE * file)
8251 Elf32_External_Dyn * edyn;
8252 Elf32_External_Dyn * ext;
8253 Elf_Internal_Dyn * entry;
8255 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8256 dynamic_size, _("dynamic section"));
8260 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8261 might not have the luxury of section headers. Look for the DT_NULL
8262 terminator to determine the number of entries. */
8263 for (ext = edyn, dynamic_nent = 0;
8264 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8268 if (BYTE_GET (ext->d_tag) == DT_NULL)
8272 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8274 if (dynamic_section == NULL)
8276 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8277 (unsigned long) dynamic_nent);
8282 for (ext = edyn, entry = dynamic_section;
8283 entry < dynamic_section + dynamic_nent;
8286 entry->d_tag = BYTE_GET (ext->d_tag);
8287 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8296 get_64bit_dynamic_section (FILE * file)
8298 Elf64_External_Dyn * edyn;
8299 Elf64_External_Dyn * ext;
8300 Elf_Internal_Dyn * entry;
8302 /* Read in the data. */
8303 edyn = (Elf64_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 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8313 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8317 if (BYTE_GET (ext->d_tag) == DT_NULL)
8321 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8323 if (dynamic_section == NULL)
8325 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8326 (unsigned long) dynamic_nent);
8331 /* Convert from external to internal formats. */
8332 for (ext = edyn, entry = dynamic_section;
8333 entry < dynamic_section + dynamic_nent;
8336 entry->d_tag = BYTE_GET (ext->d_tag);
8337 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8346 print_dynamic_flags (bfd_vma flags)
8354 flag = flags & - flags;
8364 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8365 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8366 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8367 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8368 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8369 default: fputs (_("unknown"), stdout); break;
8375 /* Parse and display the contents of the dynamic section. */
8378 process_dynamic_section (FILE * file)
8380 Elf_Internal_Dyn * entry;
8382 if (dynamic_size == 0)
8385 printf (_("\nThere is no dynamic section in this file.\n"));
8392 if (! get_32bit_dynamic_section (file))
8395 else if (! get_64bit_dynamic_section (file))
8398 /* Find the appropriate symbol table. */
8399 if (dynamic_symbols == NULL)
8401 for (entry = dynamic_section;
8402 entry < dynamic_section + dynamic_nent;
8405 Elf_Internal_Shdr section;
8407 if (entry->d_tag != DT_SYMTAB)
8410 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8412 /* Since we do not know how big the symbol table is,
8413 we default to reading in the entire file (!) and
8414 processing that. This is overkill, I know, but it
8416 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8418 if (archive_file_offset != 0)
8419 section.sh_size = archive_file_size - section.sh_offset;
8422 if (fseek (file, 0, SEEK_END))
8423 error (_("Unable to seek to end of file!\n"));
8425 section.sh_size = ftell (file) - section.sh_offset;
8429 section.sh_entsize = sizeof (Elf32_External_Sym);
8431 section.sh_entsize = sizeof (Elf64_External_Sym);
8432 section.sh_name = string_table_length;
8434 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8435 if (num_dynamic_syms < 1)
8437 error (_("Unable to determine the number of symbols to load\n"));
8443 /* Similarly find a string table. */
8444 if (dynamic_strings == NULL)
8446 for (entry = dynamic_section;
8447 entry < dynamic_section + dynamic_nent;
8450 unsigned long offset;
8453 if (entry->d_tag != DT_STRTAB)
8456 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8458 /* Since we do not know how big the string table is,
8459 we default to reading in the entire file (!) and
8460 processing that. This is overkill, I know, but it
8463 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8465 if (archive_file_offset != 0)
8466 str_tab_len = archive_file_size - offset;
8469 if (fseek (file, 0, SEEK_END))
8470 error (_("Unable to seek to end of file\n"));
8471 str_tab_len = ftell (file) - offset;
8474 if (str_tab_len < 1)
8477 (_("Unable to determine the length of the dynamic string table\n"));
8481 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8483 _("dynamic string table"));
8484 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8489 /* And find the syminfo section if available. */
8490 if (dynamic_syminfo == NULL)
8492 unsigned long syminsz = 0;
8494 for (entry = dynamic_section;
8495 entry < dynamic_section + dynamic_nent;
8498 if (entry->d_tag == DT_SYMINENT)
8500 /* Note: these braces are necessary to avoid a syntax
8501 error from the SunOS4 C compiler. */
8502 /* PR binutils/17531: A corrupt file can trigger this test.
8503 So do not use an assert, instead generate an error message. */
8504 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8505 error (_("Bad value (%d) for SYMINENT entry\n"),
8506 (int) entry->d_un.d_val);
8508 else if (entry->d_tag == DT_SYMINSZ)
8509 syminsz = entry->d_un.d_val;
8510 else if (entry->d_tag == DT_SYMINFO)
8511 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8515 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8517 Elf_External_Syminfo * extsyminfo;
8518 Elf_External_Syminfo * extsym;
8519 Elf_Internal_Syminfo * syminfo;
8521 /* There is a syminfo section. Read the data. */
8522 extsyminfo = (Elf_External_Syminfo *)
8523 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8524 _("symbol information"));
8528 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8529 if (dynamic_syminfo == NULL)
8531 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8532 (unsigned long) syminsz);
8536 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8537 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8538 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8539 ++syminfo, ++extsym)
8541 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8542 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8549 if (do_dynamic && dynamic_addr)
8550 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8551 dynamic_addr, (unsigned long) dynamic_nent);
8553 printf (_(" Tag Type Name/Value\n"));
8555 for (entry = dynamic_section;
8556 entry < dynamic_section + dynamic_nent;
8564 print_vma (entry->d_tag, FULL_HEX);
8565 dtype = get_dynamic_type (entry->d_tag);
8566 printf (" (%s)%*s", dtype,
8567 ((is_32bit_elf ? 27 : 19)
8568 - (int) strlen (dtype)),
8572 switch (entry->d_tag)
8576 print_dynamic_flags (entry->d_un.d_val);
8586 switch (entry->d_tag)
8589 printf (_("Auxiliary library"));
8593 printf (_("Filter library"));
8597 printf (_("Configuration file"));
8601 printf (_("Dependency audit library"));
8605 printf (_("Audit library"));
8609 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8610 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8614 print_vma (entry->d_un.d_val, PREFIX_HEX);
8623 printf (_("Flags:"));
8625 if (entry->d_un.d_val == 0)
8626 printf (_(" None\n"));
8629 unsigned long int val = entry->d_un.d_val;
8631 if (val & DTF_1_PARINIT)
8633 printf (" PARINIT");
8634 val ^= DTF_1_PARINIT;
8636 if (val & DTF_1_CONFEXP)
8638 printf (" CONFEXP");
8639 val ^= DTF_1_CONFEXP;
8642 printf (" %lx", val);
8651 printf (_("Flags:"));
8653 if (entry->d_un.d_val == 0)
8654 printf (_(" None\n"));
8657 unsigned long int val = entry->d_un.d_val;
8659 if (val & DF_P1_LAZYLOAD)
8661 printf (" LAZYLOAD");
8662 val ^= DF_P1_LAZYLOAD;
8664 if (val & DF_P1_GROUPPERM)
8666 printf (" GROUPPERM");
8667 val ^= DF_P1_GROUPPERM;
8670 printf (" %lx", val);
8679 printf (_("Flags:"));
8680 if (entry->d_un.d_val == 0)
8681 printf (_(" None\n"));
8684 unsigned long int val = entry->d_un.d_val;
8691 if (val & DF_1_GLOBAL)
8696 if (val & DF_1_GROUP)
8701 if (val & DF_1_NODELETE)
8703 printf (" NODELETE");
8704 val ^= DF_1_NODELETE;
8706 if (val & DF_1_LOADFLTR)
8708 printf (" LOADFLTR");
8709 val ^= DF_1_LOADFLTR;
8711 if (val & DF_1_INITFIRST)
8713 printf (" INITFIRST");
8714 val ^= DF_1_INITFIRST;
8716 if (val & DF_1_NOOPEN)
8721 if (val & DF_1_ORIGIN)
8726 if (val & DF_1_DIRECT)
8731 if (val & DF_1_TRANS)
8736 if (val & DF_1_INTERPOSE)
8738 printf (" INTERPOSE");
8739 val ^= DF_1_INTERPOSE;
8741 if (val & DF_1_NODEFLIB)
8743 printf (" NODEFLIB");
8744 val ^= DF_1_NODEFLIB;
8746 if (val & DF_1_NODUMP)
8751 if (val & DF_1_CONFALT)
8753 printf (" CONFALT");
8754 val ^= DF_1_CONFALT;
8756 if (val & DF_1_ENDFILTEE)
8758 printf (" ENDFILTEE");
8759 val ^= DF_1_ENDFILTEE;
8761 if (val & DF_1_DISPRELDNE)
8763 printf (" DISPRELDNE");
8764 val ^= DF_1_DISPRELDNE;
8766 if (val & DF_1_DISPRELPND)
8768 printf (" DISPRELPND");
8769 val ^= DF_1_DISPRELPND;
8771 if (val & DF_1_NODIRECT)
8773 printf (" NODIRECT");
8774 val ^= DF_1_NODIRECT;
8776 if (val & DF_1_IGNMULDEF)
8778 printf (" IGNMULDEF");
8779 val ^= DF_1_IGNMULDEF;
8781 if (val & DF_1_NOKSYMS)
8783 printf (" NOKSYMS");
8784 val ^= DF_1_NOKSYMS;
8786 if (val & DF_1_NOHDR)
8791 if (val & DF_1_EDITED)
8796 if (val & DF_1_NORELOC)
8798 printf (" NORELOC");
8799 val ^= DF_1_NORELOC;
8801 if (val & DF_1_SYMINTPOSE)
8803 printf (" SYMINTPOSE");
8804 val ^= DF_1_SYMINTPOSE;
8806 if (val & DF_1_GLOBAUDIT)
8808 printf (" GLOBAUDIT");
8809 val ^= DF_1_GLOBAUDIT;
8811 if (val & DF_1_SINGLETON)
8813 printf (" SINGLETON");
8814 val ^= DF_1_SINGLETON;
8817 printf (" %lx", val);
8824 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8826 puts (get_dynamic_type (entry->d_un.d_val));
8846 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8852 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8853 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8859 switch (entry->d_tag)
8862 printf (_("Shared library: [%s]"), name);
8864 if (streq (name, program_interpreter))
8865 printf (_(" program interpreter"));
8869 printf (_("Library soname: [%s]"), name);
8873 printf (_("Library rpath: [%s]"), name);
8877 printf (_("Library runpath: [%s]"), name);
8881 print_vma (entry->d_un.d_val, PREFIX_HEX);
8886 print_vma (entry->d_un.d_val, PREFIX_HEX);
8899 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8903 case DT_INIT_ARRAYSZ:
8904 case DT_FINI_ARRAYSZ:
8905 case DT_GNU_CONFLICTSZ:
8906 case DT_GNU_LIBLISTSZ:
8909 print_vma (entry->d_un.d_val, UNSIGNED);
8910 printf (_(" (bytes)\n"));
8920 print_vma (entry->d_un.d_val, UNSIGNED);
8933 if (entry->d_tag == DT_USED
8934 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8936 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8940 printf (_("Not needed object: [%s]\n"), name);
8945 print_vma (entry->d_un.d_val, PREFIX_HEX);
8951 /* The value of this entry is ignored. */
8956 case DT_GNU_PRELINKED:
8960 time_t atime = entry->d_un.d_val;
8962 tmp = gmtime (&atime);
8963 /* PR 17533 file: 041-1244816-0.004. */
8965 printf (_("<corrupt time val: %lx"),
8966 (unsigned long) atime);
8968 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8969 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8970 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8976 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8979 print_vma (entry->d_un.d_val, PREFIX_HEX);
8985 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8986 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8991 switch (elf_header.e_machine)
8994 case EM_MIPS_RS3_LE:
8995 dynamic_section_mips_val (entry);
8998 dynamic_section_parisc_val (entry);
9001 dynamic_section_ia64_val (entry);
9004 print_vma (entry->d_un.d_val, PREFIX_HEX);
9016 get_ver_flags (unsigned int flags)
9018 static char buff[32];
9025 if (flags & VER_FLG_BASE)
9026 strcat (buff, "BASE ");
9028 if (flags & VER_FLG_WEAK)
9030 if (flags & VER_FLG_BASE)
9031 strcat (buff, "| ");
9033 strcat (buff, "WEAK ");
9036 if (flags & VER_FLG_INFO)
9038 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9039 strcat (buff, "| ");
9041 strcat (buff, "INFO ");
9044 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9045 strcat (buff, _("| <unknown>"));
9050 /* Display the contents of the version sections. */
9053 process_version_sections (FILE * file)
9055 Elf_Internal_Shdr * section;
9062 for (i = 0, section = section_headers;
9063 i < elf_header.e_shnum;
9066 switch (section->sh_type)
9068 case SHT_GNU_verdef:
9070 Elf_External_Verdef * edefs;
9077 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9078 printable_section_name (section),
9081 printf (_(" Addr: 0x"));
9082 printf_vma (section->sh_addr);
9083 printf (_(" Offset: %#08lx Link: %u (%s)"),
9084 (unsigned long) section->sh_offset, section->sh_link,
9085 printable_section_name_from_index (section->sh_link));
9087 edefs = (Elf_External_Verdef *)
9088 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9089 _("version definition section"));
9092 endbuf = (char *) edefs + section->sh_size;
9094 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9097 Elf_External_Verdef * edef;
9098 Elf_Internal_Verdef ent;
9099 Elf_External_Verdaux * eaux;
9100 Elf_Internal_Verdaux aux;
9104 /* Check for very large indicies. */
9105 if (idx > (size_t) (endbuf - (char *) edefs))
9108 vstart = ((char *) edefs) + idx;
9109 if (vstart + sizeof (*edef) > endbuf)
9112 edef = (Elf_External_Verdef *) vstart;
9114 ent.vd_version = BYTE_GET (edef->vd_version);
9115 ent.vd_flags = BYTE_GET (edef->vd_flags);
9116 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9117 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9118 ent.vd_hash = BYTE_GET (edef->vd_hash);
9119 ent.vd_aux = BYTE_GET (edef->vd_aux);
9120 ent.vd_next = BYTE_GET (edef->vd_next);
9122 printf (_(" %#06x: Rev: %d Flags: %s"),
9123 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9125 printf (_(" Index: %d Cnt: %d "),
9126 ent.vd_ndx, ent.vd_cnt);
9128 /* Check for overflow. */
9129 if (ent.vd_aux > (size_t) (endbuf - vstart))
9132 vstart += ent.vd_aux;
9134 eaux = (Elf_External_Verdaux *) vstart;
9136 aux.vda_name = BYTE_GET (eaux->vda_name);
9137 aux.vda_next = BYTE_GET (eaux->vda_next);
9139 if (VALID_DYNAMIC_NAME (aux.vda_name))
9140 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9142 printf (_("Name index: %ld\n"), aux.vda_name);
9144 isum = idx + ent.vd_aux;
9146 for (j = 1; j < ent.vd_cnt; j++)
9148 /* Check for overflow. */
9149 if (aux.vda_next > (size_t) (endbuf - vstart))
9152 isum += aux.vda_next;
9153 vstart += aux.vda_next;
9155 eaux = (Elf_External_Verdaux *) vstart;
9156 if (vstart + sizeof (*eaux) > endbuf)
9159 aux.vda_name = BYTE_GET (eaux->vda_name);
9160 aux.vda_next = BYTE_GET (eaux->vda_next);
9162 if (VALID_DYNAMIC_NAME (aux.vda_name))
9163 printf (_(" %#06x: Parent %d: %s\n"),
9164 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9166 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9167 isum, j, aux.vda_name);
9171 printf (_(" Version def aux past end of section\n"));
9173 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9174 if (idx + ent.vd_next <= idx)
9180 if (cnt < section->sh_info)
9181 printf (_(" Version definition past end of section\n"));
9187 case SHT_GNU_verneed:
9189 Elf_External_Verneed * eneed;
9196 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9197 printable_section_name (section), section->sh_info);
9199 printf (_(" Addr: 0x"));
9200 printf_vma (section->sh_addr);
9201 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9202 (unsigned long) section->sh_offset, section->sh_link,
9203 printable_section_name_from_index (section->sh_link));
9205 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9206 section->sh_offset, 1,
9208 _("Version Needs section"));
9211 endbuf = (char *) eneed + section->sh_size;
9213 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9215 Elf_External_Verneed * entry;
9216 Elf_Internal_Verneed ent;
9221 if (idx > (size_t) (endbuf - (char *) eneed))
9224 vstart = ((char *) eneed) + idx;
9225 if (vstart + sizeof (*entry) > endbuf)
9228 entry = (Elf_External_Verneed *) vstart;
9230 ent.vn_version = BYTE_GET (entry->vn_version);
9231 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9232 ent.vn_file = BYTE_GET (entry->vn_file);
9233 ent.vn_aux = BYTE_GET (entry->vn_aux);
9234 ent.vn_next = BYTE_GET (entry->vn_next);
9236 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9238 if (VALID_DYNAMIC_NAME (ent.vn_file))
9239 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9241 printf (_(" File: %lx"), ent.vn_file);
9243 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9245 /* Check for overflow. */
9246 if (ent.vn_aux > (size_t) (endbuf - vstart))
9249 vstart += ent.vn_aux;
9251 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9253 Elf_External_Vernaux * eaux;
9254 Elf_Internal_Vernaux aux;
9256 if (vstart + sizeof (*eaux) > endbuf)
9258 eaux = (Elf_External_Vernaux *) vstart;
9260 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9261 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9262 aux.vna_other = BYTE_GET (eaux->vna_other);
9263 aux.vna_name = BYTE_GET (eaux->vna_name);
9264 aux.vna_next = BYTE_GET (eaux->vna_next);
9266 if (VALID_DYNAMIC_NAME (aux.vna_name))
9267 printf (_(" %#06x: Name: %s"),
9268 isum, GET_DYNAMIC_NAME (aux.vna_name));
9270 printf (_(" %#06x: Name index: %lx"),
9271 isum, aux.vna_name);
9273 printf (_(" Flags: %s Version: %d\n"),
9274 get_ver_flags (aux.vna_flags), aux.vna_other);
9276 /* Check for overflow. */
9277 if (aux.vna_next > (size_t) (endbuf - vstart))
9280 isum += aux.vna_next;
9281 vstart += aux.vna_next;
9285 warn (_("Missing Version Needs auxillary information\n"));
9287 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9289 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9290 cnt = section->sh_info;
9296 if (cnt < section->sh_info)
9297 warn (_("Missing Version Needs information\n"));
9303 case SHT_GNU_versym:
9305 Elf_Internal_Shdr * link_section;
9308 unsigned char * edata;
9309 unsigned short * data;
9311 Elf_Internal_Sym * symbols;
9312 Elf_Internal_Shdr * string_sec;
9313 unsigned long num_syms;
9316 if (section->sh_link >= elf_header.e_shnum)
9319 link_section = section_headers + section->sh_link;
9320 total = section->sh_size / sizeof (Elf_External_Versym);
9322 if (link_section->sh_link >= elf_header.e_shnum)
9327 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9328 if (symbols == NULL)
9331 string_sec = section_headers + link_section->sh_link;
9333 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9334 string_sec->sh_size,
9335 _("version string table"));
9342 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9343 printable_section_name (section), (unsigned long) total);
9345 printf (_(" Addr: "));
9346 printf_vma (section->sh_addr);
9347 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9348 (unsigned long) section->sh_offset, section->sh_link,
9349 printable_section_name (link_section));
9351 off = offset_from_vma (file,
9352 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9353 total * sizeof (short));
9354 edata = (unsigned char *) get_data (NULL, file, off, total,
9356 _("version symbol data"));
9364 data = (short unsigned int *) cmalloc (total, sizeof (short));
9366 for (cnt = total; cnt --;)
9367 data[cnt] = byte_get (edata + cnt * sizeof (short),
9372 for (cnt = 0; cnt < total; cnt += 4)
9375 int check_def, check_need;
9378 printf (" %03x:", cnt);
9380 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9381 switch (data[cnt + j])
9384 fputs (_(" 0 (*local*) "), stdout);
9388 fputs (_(" 1 (*global*) "), stdout);
9392 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9393 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9395 /* If this index value is greater than the size of the symbols
9396 array, break to avoid an out-of-bounds read. */
9397 if ((unsigned long)(cnt + j) >= num_syms)
9399 warn (_("invalid index into symbol array\n"));
9405 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9406 || section_headers[symbols[cnt + j].st_shndx].sh_type
9409 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9416 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9418 Elf_Internal_Verneed ivn;
9419 unsigned long offset;
9421 offset = offset_from_vma
9422 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9423 sizeof (Elf_External_Verneed));
9427 Elf_Internal_Vernaux ivna;
9428 Elf_External_Verneed evn;
9429 Elf_External_Vernaux evna;
9430 unsigned long a_off;
9432 if (get_data (&evn, file, offset, sizeof (evn), 1,
9433 _("version need")) == NULL)
9436 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9437 ivn.vn_next = BYTE_GET (evn.vn_next);
9439 a_off = offset + ivn.vn_aux;
9443 if (get_data (&evna, file, a_off, sizeof (evna),
9444 1, _("version need aux (2)")) == NULL)
9451 ivna.vna_next = BYTE_GET (evna.vna_next);
9452 ivna.vna_other = BYTE_GET (evna.vna_other);
9455 a_off += ivna.vna_next;
9457 while (ivna.vna_other != data[cnt + j]
9458 && ivna.vna_next != 0);
9460 if (ivna.vna_other == data[cnt + j])
9462 ivna.vna_name = BYTE_GET (evna.vna_name);
9464 if (ivna.vna_name >= string_sec->sh_size)
9465 name = _("*invalid*");
9467 name = strtab + ivna.vna_name;
9468 nn += printf ("(%s%-*s",
9470 12 - (int) strlen (name),
9476 offset += ivn.vn_next;
9478 while (ivn.vn_next);
9481 if (check_def && data[cnt + j] != 0x8001
9482 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9484 Elf_Internal_Verdef ivd;
9485 Elf_External_Verdef evd;
9486 unsigned long offset;
9488 offset = offset_from_vma
9489 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9494 if (get_data (&evd, file, offset, sizeof (evd), 1,
9495 _("version def")) == NULL)
9498 /* PR 17531: file: 046-1082287-0.004. */
9499 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9504 ivd.vd_next = BYTE_GET (evd.vd_next);
9505 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9508 offset += ivd.vd_next;
9510 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9511 && ivd.vd_next != 0);
9513 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9515 Elf_External_Verdaux evda;
9516 Elf_Internal_Verdaux ivda;
9518 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9520 if (get_data (&evda, file,
9521 offset - ivd.vd_next + ivd.vd_aux,
9523 _("version def aux")) == NULL)
9526 ivda.vda_name = BYTE_GET (evda.vda_name);
9528 if (ivda.vda_name >= string_sec->sh_size)
9529 name = _("*invalid*");
9531 name = strtab + ivda.vda_name;
9532 nn += printf ("(%s%-*s",
9534 12 - (int) strlen (name),
9540 printf ("%*c", 18 - nn, ' ');
9558 printf (_("\nNo version information found in this file.\n"));
9564 get_symbol_binding (unsigned int binding)
9566 static char buff[32];
9570 case STB_LOCAL: return "LOCAL";
9571 case STB_GLOBAL: return "GLOBAL";
9572 case STB_WEAK: return "WEAK";
9574 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9575 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9577 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9579 if (binding == STB_GNU_UNIQUE
9580 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9581 /* GNU is still using the default value 0. */
9582 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9584 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9587 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9593 get_symbol_type (unsigned int type)
9595 static char buff[32];
9599 case STT_NOTYPE: return "NOTYPE";
9600 case STT_OBJECT: return "OBJECT";
9601 case STT_FUNC: return "FUNC";
9602 case STT_SECTION: return "SECTION";
9603 case STT_FILE: return "FILE";
9604 case STT_COMMON: return "COMMON";
9605 case STT_TLS: return "TLS";
9606 case STT_RELC: return "RELC";
9607 case STT_SRELC: return "SRELC";
9609 if (type >= STT_LOPROC && type <= STT_HIPROC)
9611 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9612 return "THUMB_FUNC";
9614 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9617 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9618 return "PARISC_MILLI";
9620 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9622 else if (type >= STT_LOOS && type <= STT_HIOS)
9624 if (elf_header.e_machine == EM_PARISC)
9626 if (type == STT_HP_OPAQUE)
9628 if (type == STT_HP_STUB)
9632 if (type == STT_GNU_IFUNC
9633 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9634 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9635 /* GNU is still using the default value 0. */
9636 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9639 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9642 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9648 get_symbol_visibility (unsigned int visibility)
9652 case STV_DEFAULT: return "DEFAULT";
9653 case STV_INTERNAL: return "INTERNAL";
9654 case STV_HIDDEN: return "HIDDEN";
9655 case STV_PROTECTED: return "PROTECTED";
9661 get_mips_symbol_other (unsigned int other)
9673 case STO_MICROMIPS | STO_MIPS_PIC:
9674 return "MICROMIPS, MIPS PIC";
9683 get_ia64_symbol_other (unsigned int other)
9687 static char res[32];
9691 /* Function types is for images and .STB files only. */
9692 switch (elf_header.e_type)
9696 switch (VMS_ST_FUNC_TYPE (other))
9698 case VMS_SFT_CODE_ADDR:
9699 strcat (res, " CA");
9701 case VMS_SFT_SYMV_IDX:
9702 strcat (res, " VEC");
9705 strcat (res, " FD");
9707 case VMS_SFT_RESERVE:
9708 strcat (res, " RSV");
9717 switch (VMS_ST_LINKAGE (other))
9719 case VMS_STL_IGNORE:
9720 strcat (res, " IGN");
9722 case VMS_STL_RESERVE:
9723 strcat (res, " RSV");
9726 strcat (res, " STD");
9729 strcat (res, " LNK");
9744 get_ppc64_symbol_other (unsigned int other)
9746 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9748 static char buf[32];
9749 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9750 PPC64_LOCAL_ENTRY_OFFSET (other));
9757 get_symbol_other (unsigned int other)
9759 const char * result = NULL;
9760 static char buff [32];
9765 switch (elf_header.e_machine)
9768 result = get_mips_symbol_other (other);
9771 result = get_ia64_symbol_other (other);
9774 result = get_ppc64_symbol_other (other);
9783 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9788 get_symbol_index_type (unsigned int type)
9790 static char buff[32];
9794 case SHN_UNDEF: return "UND";
9795 case SHN_ABS: return "ABS";
9796 case SHN_COMMON: return "COM";
9798 if (type == SHN_IA_64_ANSI_COMMON
9799 && elf_header.e_machine == EM_IA_64
9800 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9802 else if ((elf_header.e_machine == EM_X86_64
9803 || elf_header.e_machine == EM_L1OM
9804 || elf_header.e_machine == EM_K1OM)
9805 && type == SHN_X86_64_LCOMMON)
9807 else if ((type == SHN_MIPS_SCOMMON
9808 && elf_header.e_machine == EM_MIPS)
9809 || (type == SHN_TIC6X_SCOMMON
9810 && elf_header.e_machine == EM_TI_C6000))
9812 else if (type == SHN_MIPS_SUNDEFINED
9813 && elf_header.e_machine == EM_MIPS)
9815 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9816 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9817 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9818 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9819 else if (type >= SHN_LORESERVE)
9820 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9821 else if (type >= elf_header.e_shnum)
9822 sprintf (buff, _("bad section index[%3d]"), type);
9824 sprintf (buff, "%3d", type);
9832 get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
9834 unsigned char * e_data;
9837 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9838 attempting to allocate memory when the read is bound to fail. */
9839 if (ent_size * number > current_file_size)
9841 error (_("Invalid number of dynamic entries: %lu\n"),
9842 (unsigned long) number);
9846 e_data = (unsigned char *) cmalloc (number, ent_size);
9849 error (_("Out of memory reading %lu dynamic entries\n"),
9850 (unsigned long) number);
9854 if (fread (e_data, ent_size, number, file) != number)
9856 error (_("Unable to read in %lu bytes of dynamic data\n"),
9857 (unsigned long) (number * ent_size));
9862 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9865 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9866 (unsigned long) number);
9872 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9880 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9882 Elf_Internal_Sym * psym;
9885 n = print_vma (si, DEC_5);
9887 fputs (&" "[n], stdout);
9888 printf (" %3lu: ", hn);
9890 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
9892 printf (_("<No info available for dynamic symbol number %lu>\n"),
9893 (unsigned long) si);
9897 psym = dynamic_symbols + si;
9898 print_vma (psym->st_value, LONG_HEX);
9900 print_vma (psym->st_size, DEC_5);
9902 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9903 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9904 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9905 /* Check to see if any other bits in the st_other field are set.
9906 Note - displaying this information disrupts the layout of the
9907 table being generated, but for the moment this case is very
9909 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9910 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9911 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9912 if (VALID_DYNAMIC_NAME (psym->st_name))
9913 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9915 printf (_(" <corrupt: %14ld>"), psym->st_name);
9920 get_symbol_version_string (FILE *file, int is_dynsym,
9922 unsigned long int strtab_size,
9923 unsigned int si, Elf_Internal_Sym *psym,
9924 enum versioned_symbol_info *sym_info,
9925 unsigned short *vna_other)
9927 const char *version_string = NULL;
9930 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9932 unsigned char data[2];
9933 unsigned short vers_data;
9934 unsigned long offset;
9938 offset = offset_from_vma
9939 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9940 sizeof data + si * sizeof (vers_data));
9942 if (get_data (&data, file, offset + si * sizeof (vers_data),
9943 sizeof (data), 1, _("version data")) == NULL)
9946 vers_data = byte_get (data, 2);
9948 is_nobits = (psym->st_shndx < elf_header.e_shnum
9949 && section_headers[psym->st_shndx].sh_type
9952 check_def = (psym->st_shndx != SHN_UNDEF);
9954 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9956 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9957 && (is_nobits || ! check_def))
9959 Elf_External_Verneed evn;
9960 Elf_Internal_Verneed ivn;
9961 Elf_Internal_Vernaux ivna;
9963 /* We must test both. */
9964 offset = offset_from_vma
9965 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9970 unsigned long vna_off;
9972 if (get_data (&evn, file, offset, sizeof (evn), 1,
9973 _("version need")) == NULL)
9981 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9982 ivn.vn_next = BYTE_GET (evn.vn_next);
9984 vna_off = offset + ivn.vn_aux;
9988 Elf_External_Vernaux evna;
9990 if (get_data (&evna, file, vna_off,
9992 _("version need aux (3)")) == NULL)
10000 ivna.vna_other = BYTE_GET (evna.vna_other);
10001 ivna.vna_next = BYTE_GET (evna.vna_next);
10002 ivna.vna_name = BYTE_GET (evna.vna_name);
10005 vna_off += ivna.vna_next;
10007 while (ivna.vna_other != vers_data
10008 && ivna.vna_next != 0);
10010 if (ivna.vna_other == vers_data)
10013 offset += ivn.vn_next;
10015 while (ivn.vn_next != 0);
10017 if (ivna.vna_other == vers_data)
10019 *sym_info = symbol_undefined;
10020 *vna_other = ivna.vna_other;
10021 version_string = (ivna.vna_name < strtab_size
10022 ? strtab + ivna.vna_name
10026 else if (! is_nobits)
10027 error (_("bad dynamic symbol\n"));
10034 if (vers_data != 0x8001
10035 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10037 Elf_Internal_Verdef ivd;
10038 Elf_Internal_Verdaux ivda;
10039 Elf_External_Verdaux evda;
10042 off = offset_from_vma
10044 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10045 sizeof (Elf_External_Verdef));
10049 Elf_External_Verdef evd;
10051 if (get_data (&evd, file, off, sizeof (evd),
10052 1, _("version def")) == NULL)
10060 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10061 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10062 ivd.vd_next = BYTE_GET (evd.vd_next);
10065 off += ivd.vd_next;
10067 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10068 && ivd.vd_next != 0);
10070 off -= ivd.vd_next;
10073 if (get_data (&evda, file, off, sizeof (evda),
10074 1, _("version def aux")) == NULL)
10075 return version_string;
10077 ivda.vda_name = BYTE_GET (evda.vda_name);
10079 if (psym->st_name != ivda.vda_name)
10081 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10082 ? symbol_hidden : symbol_public);
10083 version_string = (ivda.vda_name < strtab_size
10084 ? strtab + ivda.vda_name
10091 return version_string;
10094 /* Dump the symbol table. */
10096 process_symbol_table (FILE * file)
10098 Elf_Internal_Shdr * section;
10099 bfd_size_type nbuckets = 0;
10100 bfd_size_type nchains = 0;
10101 bfd_vma * buckets = NULL;
10102 bfd_vma * chains = NULL;
10103 bfd_vma ngnubuckets = 0;
10104 bfd_vma * gnubuckets = NULL;
10105 bfd_vma * gnuchains = NULL;
10106 bfd_vma gnusymidx = 0;
10107 bfd_size_type ngnuchains = 0;
10109 if (!do_syms && !do_dyn_syms && !do_histogram)
10112 if (dynamic_info[DT_HASH]
10114 || (do_using_dynamic
10116 && dynamic_strings != NULL)))
10118 unsigned char nb[8];
10119 unsigned char nc[8];
10120 unsigned int hash_ent_size = 4;
10122 if ((elf_header.e_machine == EM_ALPHA
10123 || elf_header.e_machine == EM_S390
10124 || elf_header.e_machine == EM_S390_OLD)
10125 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10129 (archive_file_offset
10130 + offset_from_vma (file, dynamic_info[DT_HASH],
10131 sizeof nb + sizeof nc)),
10134 error (_("Unable to seek to start of dynamic information\n"));
10138 if (fread (nb, hash_ent_size, 1, file) != 1)
10140 error (_("Failed to read in number of buckets\n"));
10144 if (fread (nc, hash_ent_size, 1, file) != 1)
10146 error (_("Failed to read in number of chains\n"));
10150 nbuckets = byte_get (nb, hash_ent_size);
10151 nchains = byte_get (nc, hash_ent_size);
10153 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10154 chains = get_dynamic_data (file, nchains, hash_ent_size);
10157 if (buckets == NULL || chains == NULL)
10159 if (do_using_dynamic)
10170 if (dynamic_info_DT_GNU_HASH
10172 || (do_using_dynamic
10174 && dynamic_strings != NULL)))
10176 unsigned char nb[16];
10177 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10178 bfd_vma buckets_vma;
10181 (archive_file_offset
10182 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10186 error (_("Unable to seek to start of dynamic information\n"));
10190 if (fread (nb, 16, 1, file) != 1)
10192 error (_("Failed to read in number of buckets\n"));
10196 ngnubuckets = byte_get (nb, 4);
10197 gnusymidx = byte_get (nb + 4, 4);
10198 bitmaskwords = byte_get (nb + 8, 4);
10199 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10201 buckets_vma += bitmaskwords * 4;
10203 buckets_vma += bitmaskwords * 8;
10206 (archive_file_offset
10207 + offset_from_vma (file, buckets_vma, 4)),
10210 error (_("Unable to seek to start of dynamic information\n"));
10214 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10216 if (gnubuckets == NULL)
10219 for (i = 0; i < ngnubuckets; i++)
10220 if (gnubuckets[i] != 0)
10222 if (gnubuckets[i] < gnusymidx)
10225 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10226 maxchain = gnubuckets[i];
10229 if (maxchain == 0xffffffff)
10232 maxchain -= gnusymidx;
10235 (archive_file_offset
10236 + offset_from_vma (file, buckets_vma
10237 + 4 * (ngnubuckets + maxchain), 4)),
10240 error (_("Unable to seek to start of dynamic information\n"));
10246 if (fread (nb, 4, 1, file) != 1)
10248 error (_("Failed to determine last chain length\n"));
10252 if (maxchain + 1 == 0)
10257 while ((byte_get (nb, 4) & 1) == 0);
10260 (archive_file_offset
10261 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10264 error (_("Unable to seek to start of dynamic information\n"));
10268 gnuchains = get_dynamic_data (file, maxchain, 4);
10269 ngnuchains = maxchain;
10272 if (gnuchains == NULL)
10277 if (do_using_dynamic)
10282 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10284 && do_using_dynamic
10285 && dynamic_strings != NULL
10286 && dynamic_symbols != NULL)
10290 if (dynamic_info[DT_HASH])
10294 printf (_("\nSymbol table for image:\n"));
10296 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10298 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10300 for (hn = 0; hn < nbuckets; hn++)
10305 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10306 print_dynamic_symbol (si, hn);
10310 if (dynamic_info_DT_GNU_HASH)
10312 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10314 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10316 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10318 for (hn = 0; hn < ngnubuckets; ++hn)
10319 if (gnubuckets[hn] != 0)
10321 bfd_vma si = gnubuckets[hn];
10322 bfd_vma off = si - gnusymidx;
10326 print_dynamic_symbol (si, hn);
10329 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10333 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10334 && section_headers != NULL)
10338 for (i = 0, section = section_headers;
10339 i < elf_header.e_shnum;
10343 char * strtab = NULL;
10344 unsigned long int strtab_size = 0;
10345 Elf_Internal_Sym * symtab;
10346 Elf_Internal_Sym * psym;
10347 unsigned long num_syms;
10349 if ((section->sh_type != SHT_SYMTAB
10350 && section->sh_type != SHT_DYNSYM)
10352 && section->sh_type == SHT_SYMTAB))
10355 if (section->sh_entsize == 0)
10357 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10358 printable_section_name (section));
10362 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10363 printable_section_name (section),
10364 (unsigned long) (section->sh_size / section->sh_entsize));
10367 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10369 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10371 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10372 if (symtab == NULL)
10375 if (section->sh_link == elf_header.e_shstrndx)
10377 strtab = string_table;
10378 strtab_size = string_table_length;
10380 else if (section->sh_link < elf_header.e_shnum)
10382 Elf_Internal_Shdr * string_sec;
10384 string_sec = section_headers + section->sh_link;
10386 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10387 1, string_sec->sh_size,
10388 _("string table"));
10389 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10392 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10394 const char *version_string;
10395 enum versioned_symbol_info sym_info;
10396 unsigned short vna_other;
10398 printf ("%6d: ", si);
10399 print_vma (psym->st_value, LONG_HEX);
10401 print_vma (psym->st_size, DEC_5);
10402 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10403 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10404 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10405 /* Check to see if any other bits in the st_other field are set.
10406 Note - displaying this information disrupts the layout of the
10407 table being generated, but for the moment this case is very rare. */
10408 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10409 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10410 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10411 print_symbol (25, psym->st_name < strtab_size
10412 ? strtab + psym->st_name : _("<corrupt>"));
10415 = get_symbol_version_string (file,
10416 section->sh_type == SHT_DYNSYM,
10417 strtab, strtab_size, si,
10418 psym, &sym_info, &vna_other);
10419 if (version_string)
10421 if (sym_info == symbol_undefined)
10422 printf ("@%s (%d)", version_string, vna_other);
10424 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10432 if (strtab != string_table)
10438 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10440 if (do_histogram && buckets != NULL)
10442 unsigned long * lengths;
10443 unsigned long * counts;
10446 unsigned long maxlength = 0;
10447 unsigned long nzero_counts = 0;
10448 unsigned long nsyms = 0;
10450 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10451 (unsigned long) nbuckets);
10453 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10454 if (lengths == NULL)
10456 error (_("Out of memory allocating space for histogram buckets\n"));
10460 printf (_(" Length Number %% of total Coverage\n"));
10461 for (hn = 0; hn < nbuckets; ++hn)
10463 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10466 if (maxlength < ++lengths[hn])
10469 /* PR binutils/17531: A corrupt binary could contain broken
10470 histogram data. Do not go into an infinite loop trying
10472 if (chains[si] == si)
10474 error (_("histogram chain links to itself\n"));
10480 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10481 if (counts == NULL)
10484 error (_("Out of memory allocating space for histogram counts\n"));
10488 for (hn = 0; hn < nbuckets; ++hn)
10489 ++counts[lengths[hn]];
10494 printf (" 0 %-10lu (%5.1f%%)\n",
10495 counts[0], (counts[0] * 100.0) / nbuckets);
10496 for (i = 1; i <= maxlength; ++i)
10498 nzero_counts += counts[i] * i;
10499 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10500 i, counts[i], (counts[i] * 100.0) / nbuckets,
10501 (nzero_counts * 100.0) / nsyms);
10509 if (buckets != NULL)
10515 if (do_histogram && gnubuckets != NULL)
10517 unsigned long * lengths;
10518 unsigned long * counts;
10520 unsigned long maxlength = 0;
10521 unsigned long nzero_counts = 0;
10522 unsigned long nsyms = 0;
10524 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10525 (unsigned long) ngnubuckets);
10527 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10528 if (lengths == NULL)
10530 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10534 printf (_(" Length Number %% of total Coverage\n"));
10536 for (hn = 0; hn < ngnubuckets; ++hn)
10537 if (gnubuckets[hn] != 0)
10539 bfd_vma off, length = 1;
10541 for (off = gnubuckets[hn] - gnusymidx;
10542 /* PR 17531 file: 010-77222-0.004. */
10543 off < ngnuchains && (gnuchains[off] & 1) == 0;
10546 lengths[hn] = length;
10547 if (length > maxlength)
10548 maxlength = length;
10552 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10553 if (counts == NULL)
10556 error (_("Out of memory allocating space for gnu histogram counts\n"));
10560 for (hn = 0; hn < ngnubuckets; ++hn)
10561 ++counts[lengths[hn]];
10563 if (ngnubuckets > 0)
10566 printf (" 0 %-10lu (%5.1f%%)\n",
10567 counts[0], (counts[0] * 100.0) / ngnubuckets);
10568 for (j = 1; j <= maxlength; ++j)
10570 nzero_counts += counts[j] * j;
10571 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10572 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10573 (nzero_counts * 100.0) / nsyms);
10587 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10591 if (dynamic_syminfo == NULL
10593 /* No syminfo, this is ok. */
10596 /* There better should be a dynamic symbol section. */
10597 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10601 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10602 dynamic_syminfo_offset, dynamic_syminfo_nent);
10604 printf (_(" Num: Name BoundTo Flags\n"));
10605 for (i = 0; i < dynamic_syminfo_nent; ++i)
10607 unsigned short int flags = dynamic_syminfo[i].si_flags;
10609 printf ("%4d: ", i);
10610 if (i >= num_dynamic_syms)
10611 printf (_("<corrupt index>"));
10612 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10613 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10615 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10618 switch (dynamic_syminfo[i].si_boundto)
10620 case SYMINFO_BT_SELF:
10621 fputs ("SELF ", stdout);
10623 case SYMINFO_BT_PARENT:
10624 fputs ("PARENT ", stdout);
10627 if (dynamic_syminfo[i].si_boundto > 0
10628 && dynamic_syminfo[i].si_boundto < dynamic_nent
10629 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10631 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10635 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10639 if (flags & SYMINFO_FLG_DIRECT)
10640 printf (" DIRECT");
10641 if (flags & SYMINFO_FLG_PASSTHRU)
10642 printf (" PASSTHRU");
10643 if (flags & SYMINFO_FLG_COPY)
10645 if (flags & SYMINFO_FLG_LAZYLOAD)
10646 printf (" LAZYLOAD");
10654 /* Check to see if the given reloc needs to be handled in a target specific
10655 manner. If so then process the reloc and return TRUE otherwise return
10659 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10660 unsigned char * start,
10661 Elf_Internal_Sym * symtab)
10663 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10665 switch (elf_header.e_machine)
10668 case EM_MSP430_OLD:
10670 static Elf_Internal_Sym * saved_sym = NULL;
10672 switch (reloc_type)
10674 case 10: /* R_MSP430_SYM_DIFF */
10675 if (uses_msp430x_relocs ())
10677 case 21: /* R_MSP430X_SYM_DIFF */
10678 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10681 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10682 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10683 goto handle_sym_diff;
10685 case 5: /* R_MSP430_16_BYTE */
10686 case 9: /* R_MSP430_8 */
10687 if (uses_msp430x_relocs ())
10689 goto handle_sym_diff;
10691 case 2: /* R_MSP430_ABS16 */
10692 case 15: /* R_MSP430X_ABS16 */
10693 if (! uses_msp430x_relocs ())
10695 goto handle_sym_diff;
10698 if (saved_sym != NULL)
10702 value = reloc->r_addend
10703 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10704 - saved_sym->st_value);
10706 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10714 if (saved_sym != NULL)
10715 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10722 case EM_CYGNUS_MN10300:
10724 static Elf_Internal_Sym * saved_sym = NULL;
10726 switch (reloc_type)
10728 case 34: /* R_MN10300_ALIGN */
10730 case 33: /* R_MN10300_SYM_DIFF */
10731 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10733 case 1: /* R_MN10300_32 */
10734 case 2: /* R_MN10300_16 */
10735 if (saved_sym != NULL)
10739 value = reloc->r_addend
10740 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10741 - saved_sym->st_value);
10743 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10750 if (saved_sym != NULL)
10751 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10761 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10762 DWARF debug sections. This is a target specific test. Note - we do not
10763 go through the whole including-target-headers-multiple-times route, (as
10764 we have already done with <elf/h8.h>) because this would become very
10765 messy and even then this function would have to contain target specific
10766 information (the names of the relocs instead of their numeric values).
10767 FIXME: This is not the correct way to solve this problem. The proper way
10768 is to have target specific reloc sizing and typing functions created by
10769 the reloc-macros.h header, in the same way that it already creates the
10770 reloc naming functions. */
10773 is_32bit_abs_reloc (unsigned int reloc_type)
10775 switch (elf_header.e_machine)
10779 return reloc_type == 1; /* R_386_32. */
10781 return reloc_type == 1; /* R_68K_32. */
10783 return reloc_type == 1; /* R_860_32. */
10785 return reloc_type == 2; /* R_960_32. */
10787 return reloc_type == 258; /* R_AARCH64_ABS32 */
10789 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10791 return reloc_type == 1; /* R_ARC_32. */
10793 return reloc_type == 2; /* R_ARM_ABS32 */
10796 return reloc_type == 1;
10797 case EM_ADAPTEVA_EPIPHANY:
10798 return reloc_type == 3;
10800 return reloc_type == 0x12; /* R_byte4_data. */
10802 return reloc_type == 3; /* R_CRIS_32. */
10804 return reloc_type == 3; /* R_CR16_NUM32. */
10806 return reloc_type == 15; /* R_CRX_NUM32. */
10807 case EM_CYGNUS_FRV:
10808 return reloc_type == 1;
10809 case EM_CYGNUS_D10V:
10811 return reloc_type == 6; /* R_D10V_32. */
10812 case EM_CYGNUS_D30V:
10814 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10816 return reloc_type == 3; /* R_DLX_RELOC_32. */
10817 case EM_CYGNUS_FR30:
10819 return reloc_type == 3; /* R_FR30_32. */
10823 return reloc_type == 1; /* R_H8_DIR32. */
10825 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10828 return reloc_type == 2; /* R_IP2K_32. */
10830 return reloc_type == 2; /* R_IQ2000_32. */
10831 case EM_LATTICEMICO32:
10832 return reloc_type == 3; /* R_LM32_32. */
10835 return reloc_type == 3; /* R_M32C_32. */
10837 return reloc_type == 34; /* R_M32R_32_RELA. */
10839 return reloc_type == 1; /* R_MCORE_ADDR32. */
10840 case EM_CYGNUS_MEP:
10841 return reloc_type == 4; /* R_MEP_32. */
10843 return reloc_type == 2; /* R_METAG_ADDR32. */
10844 case EM_MICROBLAZE:
10845 return reloc_type == 1; /* R_MICROBLAZE_32. */
10847 return reloc_type == 2; /* R_MIPS_32. */
10849 return reloc_type == 4; /* R_MMIX_32. */
10850 case EM_CYGNUS_MN10200:
10852 return reloc_type == 1; /* R_MN10200_32. */
10853 case EM_CYGNUS_MN10300:
10855 return reloc_type == 1; /* R_MN10300_32. */
10857 return reloc_type == 1; /* R_MOXIE_32. */
10858 case EM_MSP430_OLD:
10860 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10862 return reloc_type == 2; /* R_MT_32. */
10864 return reloc_type == 20; /* R_NDS32_RELA. */
10865 case EM_ALTERA_NIOS2:
10866 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
10868 return reloc_type == 1; /* R_NIOS_32. */
10870 return reloc_type == 1; /* R_OR1K_32. */
10872 return (reloc_type == 1 /* R_PARISC_DIR32. */
10873 || reloc_type == 41); /* R_PARISC_SECREL32. */
10876 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10878 return reloc_type == 1; /* R_PPC64_ADDR32. */
10880 return reloc_type == 1; /* R_PPC_ADDR32. */
10882 return reloc_type == 1; /* R_RL78_DIR32. */
10884 return reloc_type == 1; /* R_RX_DIR32. */
10886 return reloc_type == 1; /* R_I370_ADDR31. */
10889 return reloc_type == 4; /* R_S390_32. */
10891 return reloc_type == 8; /* R_SCORE_ABS32. */
10893 return reloc_type == 1; /* R_SH_DIR32. */
10894 case EM_SPARC32PLUS:
10897 return reloc_type == 3 /* R_SPARC_32. */
10898 || reloc_type == 23; /* R_SPARC_UA32. */
10900 return reloc_type == 6; /* R_SPU_ADDR32 */
10902 return reloc_type == 1; /* R_C6000_ABS32. */
10904 return reloc_type == 2; /* R_TILEGX_32. */
10906 return reloc_type == 1; /* R_TILEPRO_32. */
10907 case EM_CYGNUS_V850:
10909 return reloc_type == 6; /* R_V850_ABS32. */
10911 return reloc_type == 0x33; /* R_V810_WORD. */
10913 return reloc_type == 1; /* R_VAX_32. */
10917 return reloc_type == 10; /* R_X86_64_32. */
10920 return reloc_type == 3; /* R_XC16C_ABS_32. */
10922 return reloc_type == 4; /* R_XGATE_32. */
10924 return reloc_type == 1; /* R_XSTROMY16_32. */
10925 case EM_XTENSA_OLD:
10927 return reloc_type == 1; /* R_XTENSA_32. */
10929 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10930 elf_header.e_machine);
10935 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10936 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10939 is_32bit_pcrel_reloc (unsigned int reloc_type)
10941 switch (elf_header.e_machine)
10945 return reloc_type == 2; /* R_386_PC32. */
10947 return reloc_type == 4; /* R_68K_PC32. */
10949 return reloc_type == 261; /* R_AARCH64_PREL32 */
10950 case EM_ADAPTEVA_EPIPHANY:
10951 return reloc_type == 6;
10953 return reloc_type == 10; /* R_ALPHA_SREL32. */
10955 return reloc_type == 3; /* R_ARM_REL32 */
10956 case EM_MICROBLAZE:
10957 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
10959 return reloc_type == 9; /* R_OR1K_32_PCREL. */
10961 return reloc_type == 9; /* R_PARISC_PCREL32. */
10963 return reloc_type == 26; /* R_PPC_REL32. */
10965 return reloc_type == 26; /* R_PPC64_REL32. */
10968 return reloc_type == 5; /* R_390_PC32. */
10970 return reloc_type == 2; /* R_SH_REL32. */
10971 case EM_SPARC32PLUS:
10974 return reloc_type == 6; /* R_SPARC_DISP32. */
10976 return reloc_type == 13; /* R_SPU_REL32. */
10978 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10980 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
10984 return reloc_type == 2; /* R_X86_64_PC32. */
10985 case EM_XTENSA_OLD:
10987 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
10989 /* Do not abort or issue an error message here. Not all targets use
10990 pc-relative 32-bit relocs in their DWARF debug information and we
10991 have already tested for target coverage in is_32bit_abs_reloc. A
10992 more helpful warning message will be generated by apply_relocations
10993 anyway, so just return. */
10998 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10999 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11002 is_64bit_abs_reloc (unsigned int reloc_type)
11004 switch (elf_header.e_machine)
11007 return reloc_type == 257; /* R_AARCH64_ABS64. */
11009 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11011 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11013 return reloc_type == 80; /* R_PARISC_DIR64. */
11015 return reloc_type == 38; /* R_PPC64_ADDR64. */
11016 case EM_SPARC32PLUS:
11019 return reloc_type == 54; /* R_SPARC_UA64. */
11023 return reloc_type == 1; /* R_X86_64_64. */
11026 return reloc_type == 22; /* R_S390_64. */
11028 return reloc_type == 1; /* R_TILEGX_64. */
11030 return reloc_type == 18; /* R_MIPS_64. */
11036 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11037 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11040 is_64bit_pcrel_reloc (unsigned int reloc_type)
11042 switch (elf_header.e_machine)
11045 return reloc_type == 260; /* R_AARCH64_PREL64. */
11047 return reloc_type == 11; /* R_ALPHA_SREL64. */
11049 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11051 return reloc_type == 72; /* R_PARISC_PCREL64. */
11053 return reloc_type == 44; /* R_PPC64_REL64. */
11054 case EM_SPARC32PLUS:
11057 return reloc_type == 46; /* R_SPARC_DISP64. */
11061 return reloc_type == 24; /* R_X86_64_PC64. */
11064 return reloc_type == 23; /* R_S390_PC64. */
11066 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11072 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11073 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11076 is_24bit_abs_reloc (unsigned int reloc_type)
11078 switch (elf_header.e_machine)
11080 case EM_CYGNUS_MN10200:
11082 return reloc_type == 4; /* R_MN10200_24. */
11088 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11089 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11092 is_16bit_abs_reloc (unsigned int reloc_type)
11094 switch (elf_header.e_machine)
11098 return reloc_type == 4; /* R_AVR_16. */
11099 case EM_ADAPTEVA_EPIPHANY:
11100 return reloc_type == 5;
11101 case EM_CYGNUS_D10V:
11103 return reloc_type == 3; /* R_D10V_16. */
11107 return reloc_type == R_H8_DIR16;
11110 return reloc_type == 1; /* R_IP2K_16. */
11113 return reloc_type == 1; /* R_M32C_16 */
11115 if (uses_msp430x_relocs ())
11116 return reloc_type == 2; /* R_MSP430_ABS16. */
11117 case EM_MSP430_OLD:
11118 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11120 return reloc_type == 19; /* R_NDS32_RELA. */
11121 case EM_ALTERA_NIOS2:
11122 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11124 return reloc_type == 9; /* R_NIOS_16. */
11126 return reloc_type == 2; /* R_OR1K_16. */
11128 return reloc_type == 2; /* R_C6000_ABS16. */
11131 return reloc_type == 2; /* R_XC16C_ABS_16. */
11132 case EM_CYGNUS_MN10200:
11134 return reloc_type == 2; /* R_MN10200_16. */
11135 case EM_CYGNUS_MN10300:
11137 return reloc_type == 2; /* R_MN10300_16. */
11139 return reloc_type == 3; /* R_XGATE_16. */
11145 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11146 relocation entries (possibly formerly used for SHT_GROUP sections). */
11149 is_none_reloc (unsigned int reloc_type)
11151 switch (elf_header.e_machine)
11153 case EM_68K: /* R_68K_NONE. */
11154 case EM_386: /* R_386_NONE. */
11155 case EM_SPARC32PLUS:
11157 case EM_SPARC: /* R_SPARC_NONE. */
11158 case EM_MIPS: /* R_MIPS_NONE. */
11159 case EM_PARISC: /* R_PARISC_NONE. */
11160 case EM_ALPHA: /* R_ALPHA_NONE. */
11161 case EM_ADAPTEVA_EPIPHANY:
11162 case EM_PPC: /* R_PPC_NONE. */
11163 case EM_PPC64: /* R_PPC64_NONE. */
11164 case EM_ARM: /* R_ARM_NONE. */
11165 case EM_IA_64: /* R_IA64_NONE. */
11166 case EM_SH: /* R_SH_NONE. */
11168 case EM_S390: /* R_390_NONE. */
11169 case EM_CRIS: /* R_CRIS_NONE. */
11170 case EM_X86_64: /* R_X86_64_NONE. */
11171 case EM_L1OM: /* R_X86_64_NONE. */
11172 case EM_K1OM: /* R_X86_64_NONE. */
11173 case EM_MN10300: /* R_MN10300_NONE. */
11174 case EM_MOXIE: /* R_MOXIE_NONE. */
11175 case EM_M32R: /* R_M32R_NONE. */
11176 case EM_TI_C6000:/* R_C6000_NONE. */
11177 case EM_TILEGX: /* R_TILEGX_NONE. */
11178 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11180 case EM_C166: /* R_XC16X_NONE. */
11181 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11182 case EM_NIOS32: /* R_NIOS_NONE. */
11183 case EM_OR1K: /* R_OR1K_NONE. */
11184 return reloc_type == 0;
11186 return reloc_type == 0 || reloc_type == 256;
11188 return (reloc_type == 0 /* R_XTENSA_NONE. */
11189 || reloc_type == 204 /* R_NDS32_DIFF8. */
11190 || reloc_type == 205 /* R_NDS32_DIFF16. */
11191 || reloc_type == 206 /* R_NDS32_DIFF32. */
11192 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11193 case EM_XTENSA_OLD:
11195 return (reloc_type == 0 /* R_XTENSA_NONE. */
11196 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11197 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11198 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11200 return reloc_type == 3; /* R_METAG_NONE. */
11205 /* Apply relocations to a section.
11206 Note: So far support has been added only for those relocations
11207 which can be found in debug sections.
11208 FIXME: Add support for more relocations ? */
11211 apply_relocations (void * file,
11212 Elf_Internal_Shdr * section,
11213 unsigned char * start)
11215 Elf_Internal_Shdr * relsec;
11216 unsigned char * end = start + section->sh_size;
11218 if (elf_header.e_type != ET_REL)
11221 /* Find the reloc section associated with the section. */
11222 for (relsec = section_headers;
11223 relsec < section_headers + elf_header.e_shnum;
11226 bfd_boolean is_rela;
11227 unsigned long num_relocs;
11228 Elf_Internal_Rela * relocs;
11229 Elf_Internal_Rela * rp;
11230 Elf_Internal_Shdr * symsec;
11231 Elf_Internal_Sym * symtab;
11232 unsigned long num_syms;
11233 Elf_Internal_Sym * sym;
11235 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11236 || relsec->sh_info >= elf_header.e_shnum
11237 || section_headers + relsec->sh_info != section
11238 || relsec->sh_size == 0
11239 || relsec->sh_link >= elf_header.e_shnum)
11242 is_rela = relsec->sh_type == SHT_RELA;
11246 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11247 relsec->sh_size, & relocs, & num_relocs))
11252 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11253 relsec->sh_size, & relocs, & num_relocs))
11257 /* SH uses RELA but uses in place value instead of the addend field. */
11258 if (elf_header.e_machine == EM_SH)
11261 symsec = section_headers + relsec->sh_link;
11262 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11264 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11267 unsigned int reloc_type;
11268 unsigned int reloc_size;
11269 unsigned char * rloc;
11270 unsigned long sym_index;
11272 reloc_type = get_reloc_type (rp->r_info);
11274 if (target_specific_reloc_handling (rp, start, symtab))
11276 else if (is_none_reloc (reloc_type))
11278 else if (is_32bit_abs_reloc (reloc_type)
11279 || is_32bit_pcrel_reloc (reloc_type))
11281 else if (is_64bit_abs_reloc (reloc_type)
11282 || is_64bit_pcrel_reloc (reloc_type))
11284 else if (is_24bit_abs_reloc (reloc_type))
11286 else if (is_16bit_abs_reloc (reloc_type))
11290 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11291 reloc_type, printable_section_name (section));
11295 rloc = start + rp->r_offset;
11296 if ((rloc + reloc_size) > end || (rloc < start))
11298 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11299 (unsigned long) rp->r_offset,
11300 printable_section_name (section));
11304 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11305 if (sym_index >= num_syms)
11307 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11308 sym_index, printable_section_name (section));
11311 sym = symtab + sym_index;
11313 /* If the reloc has a symbol associated with it,
11314 make sure that it is of an appropriate type.
11316 Relocations against symbols without type can happen.
11317 Gcc -feliminate-dwarf2-dups may generate symbols
11318 without type for debug info.
11320 Icc generates relocations against function symbols
11321 instead of local labels.
11323 Relocations against object symbols can happen, eg when
11324 referencing a global array. For an example of this see
11325 the _clz.o binary in libgcc.a. */
11327 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11329 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11330 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11331 (long int)(rp - relocs),
11332 printable_section_name (relsec));
11338 addend += rp->r_addend;
11339 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11340 partial_inplace. */
11342 || (elf_header.e_machine == EM_XTENSA
11343 && reloc_type == 1)
11344 || ((elf_header.e_machine == EM_PJ
11345 || elf_header.e_machine == EM_PJ_OLD)
11346 && reloc_type == 1)
11347 || ((elf_header.e_machine == EM_D30V
11348 || elf_header.e_machine == EM_CYGNUS_D30V)
11349 && reloc_type == 12))
11350 addend += byte_get (rloc, reloc_size);
11352 if (is_32bit_pcrel_reloc (reloc_type)
11353 || is_64bit_pcrel_reloc (reloc_type))
11355 /* On HPPA, all pc-relative relocations are biased by 8. */
11356 if (elf_header.e_machine == EM_PARISC)
11358 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11362 byte_put (rloc, addend + sym->st_value, reloc_size);
11371 #ifdef SUPPORT_DISASSEMBLY
11373 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11375 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11377 /* FIXME: XXX -- to be done --- XXX */
11383 /* Reads in the contents of SECTION from FILE, returning a pointer
11384 to a malloc'ed buffer or NULL if something went wrong. */
11387 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11389 bfd_size_type num_bytes;
11391 num_bytes = section->sh_size;
11393 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11395 printf (_("\nSection '%s' has no data to dump.\n"),
11396 printable_section_name (section));
11400 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11401 _("section contents"));
11406 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11408 Elf_Internal_Shdr * relsec;
11409 bfd_size_type num_bytes;
11413 bfd_boolean some_strings_shown;
11415 start = get_section_contents (section, file);
11419 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11421 /* If the section being dumped has relocations against it the user might
11422 be expecting these relocations to have been applied. Check for this
11423 case and issue a warning message in order to avoid confusion.
11424 FIXME: Maybe we ought to have an option that dumps a section with
11425 relocs applied ? */
11426 for (relsec = section_headers;
11427 relsec < section_headers + elf_header.e_shnum;
11430 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11431 || relsec->sh_info >= elf_header.e_shnum
11432 || section_headers + relsec->sh_info != section
11433 || relsec->sh_size == 0
11434 || relsec->sh_link >= elf_header.e_shnum)
11437 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11441 num_bytes = section->sh_size;
11443 end = start + num_bytes;
11444 some_strings_shown = FALSE;
11448 while (!ISPRINT (* data))
11449 if (++ data >= end)
11454 size_t maxlen = end - data;
11457 /* PR 11128: Use two separate invocations in order to work
11458 around bugs in the Solaris 8 implementation of printf. */
11459 printf (" [%6tx] ", data - start);
11461 printf (" [%6Ix] ", (size_t) (data - start));
11465 print_symbol ((int) maxlen, data);
11467 data += strnlen (data, maxlen);
11471 printf (_("<corrupt>\n"));
11474 some_strings_shown = TRUE;
11478 if (! some_strings_shown)
11479 printf (_(" No strings found in this section."));
11487 dump_section_as_bytes (Elf_Internal_Shdr * section,
11489 bfd_boolean relocate)
11491 Elf_Internal_Shdr * relsec;
11492 bfd_size_type bytes;
11494 unsigned char * data;
11495 unsigned char * start;
11497 start = (unsigned char *) get_section_contents (section, file);
11501 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11505 apply_relocations (file, section, start);
11509 /* If the section being dumped has relocations against it the user might
11510 be expecting these relocations to have been applied. Check for this
11511 case and issue a warning message in order to avoid confusion.
11512 FIXME: Maybe we ought to have an option that dumps a section with
11513 relocs applied ? */
11514 for (relsec = section_headers;
11515 relsec < section_headers + elf_header.e_shnum;
11518 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11519 || relsec->sh_info >= elf_header.e_shnum
11520 || section_headers + relsec->sh_info != section
11521 || relsec->sh_size == 0
11522 || relsec->sh_link >= elf_header.e_shnum)
11525 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11530 addr = section->sh_addr;
11531 bytes = section->sh_size;
11540 lbytes = (bytes > 16 ? 16 : bytes);
11542 printf (" 0x%8.8lx ", (unsigned long) addr);
11544 for (j = 0; j < 16; j++)
11547 printf ("%2.2x", data[j]);
11555 for (j = 0; j < lbytes; j++)
11558 if (k >= ' ' && k < 0x7f)
11576 /* Uncompresses a section that was compressed using zlib, in place. */
11579 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11580 dwarf_size_type *size ATTRIBUTE_UNUSED)
11582 #ifndef HAVE_ZLIB_H
11585 dwarf_size_type compressed_size = *size;
11586 unsigned char * compressed_buffer = *buffer;
11587 dwarf_size_type uncompressed_size;
11588 unsigned char * uncompressed_buffer;
11591 dwarf_size_type header_size = 12;
11593 /* Read the zlib header. In this case, it should be "ZLIB" followed
11594 by the uncompressed section size, 8 bytes in big-endian order. */
11595 if (compressed_size < header_size
11596 || ! streq ((char *) compressed_buffer, "ZLIB"))
11599 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11600 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11601 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11602 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11603 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11604 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11605 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11606 uncompressed_size += compressed_buffer[11];
11608 /* It is possible the section consists of several compressed
11609 buffers concatenated together, so we uncompress in a loop. */
11610 strm.zalloc = NULL;
11612 strm.opaque = NULL;
11613 strm.avail_in = compressed_size - header_size;
11614 strm.next_in = (Bytef *) compressed_buffer + header_size;
11615 strm.avail_out = uncompressed_size;
11616 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11618 rc = inflateInit (& strm);
11619 while (strm.avail_in > 0)
11623 strm.next_out = ((Bytef *) uncompressed_buffer
11624 + (uncompressed_size - strm.avail_out));
11625 rc = inflate (&strm, Z_FINISH);
11626 if (rc != Z_STREAM_END)
11628 rc = inflateReset (& strm);
11630 rc = inflateEnd (& strm);
11632 || strm.avail_out != 0)
11635 free (compressed_buffer);
11636 *buffer = uncompressed_buffer;
11637 *size = uncompressed_size;
11641 free (uncompressed_buffer);
11642 /* Indicate decompression failure. */
11645 #endif /* HAVE_ZLIB_H */
11649 load_specific_debug_section (enum dwarf_section_display_enum debug,
11650 Elf_Internal_Shdr * sec, void * file)
11652 struct dwarf_section * section = &debug_displays [debug].section;
11655 /* If it is already loaded, do nothing. */
11656 if (section->start != NULL)
11659 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11660 section->address = sec->sh_addr;
11661 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11663 sec->sh_size, buf);
11664 if (section->start == NULL)
11668 section->size = sec->sh_size;
11669 if (uncompress_section_contents (§ion->start, §ion->size))
11670 sec->sh_size = section->size;
11673 if (section->start == NULL)
11676 if (debug_displays [debug].relocate)
11677 apply_relocations ((FILE *) file, sec, section->start);
11682 /* If this is not NULL, load_debug_section will only look for sections
11683 within the list of sections given here. */
11684 unsigned int *section_subset = NULL;
11687 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11689 struct dwarf_section * section = &debug_displays [debug].section;
11690 Elf_Internal_Shdr * sec;
11692 /* Locate the debug section. */
11693 sec = find_section_in_set (section->uncompressed_name, section_subset);
11695 section->name = section->uncompressed_name;
11698 sec = find_section_in_set (section->compressed_name, section_subset);
11700 section->name = section->compressed_name;
11705 /* If we're loading from a subset of sections, and we've loaded
11706 a section matching this name before, it's likely that it's a
11708 if (section_subset != NULL)
11709 free_debug_section (debug);
11711 return load_specific_debug_section (debug, sec, (FILE *) file);
11715 free_debug_section (enum dwarf_section_display_enum debug)
11717 struct dwarf_section * section = &debug_displays [debug].section;
11719 if (section->start == NULL)
11722 free ((char *) section->start);
11723 section->start = NULL;
11724 section->address = 0;
11729 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11731 char * name = SECTION_NAME (section);
11732 const char * print_name = printable_section_name (section);
11733 bfd_size_type length;
11737 length = section->sh_size;
11740 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
11743 if (section->sh_type == SHT_NOBITS)
11745 /* There is no point in dumping the contents of a debugging section
11746 which has the NOBITS type - the bits in the file will be random.
11747 This can happen when a file containing a .eh_frame section is
11748 stripped with the --only-keep-debug command line option. */
11749 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11754 if (const_strneq (name, ".gnu.linkonce.wi."))
11755 name = ".debug_info";
11757 /* See if we know how to display the contents of this section. */
11758 for (i = 0; i < max; i++)
11759 if (streq (debug_displays[i].section.uncompressed_name, name)
11760 || (i == line && const_strneq (name, ".debug_line."))
11761 || streq (debug_displays[i].section.compressed_name, name))
11763 struct dwarf_section * sec = &debug_displays [i].section;
11764 int secondary = (section != find_section (name));
11767 free_debug_section ((enum dwarf_section_display_enum) i);
11769 if (i == line && const_strneq (name, ".debug_line."))
11771 else if (streq (sec->uncompressed_name, name))
11772 sec->name = sec->uncompressed_name;
11774 sec->name = sec->compressed_name;
11775 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11778 /* If this debug section is part of a CU/TU set in a .dwp file,
11779 restrict load_debug_section to the sections in that set. */
11780 section_subset = find_cu_tu_set (file, shndx);
11782 result &= debug_displays[i].display (sec, file);
11784 section_subset = NULL;
11786 if (secondary || (i != info && i != abbrev))
11787 free_debug_section ((enum dwarf_section_display_enum) i);
11795 printf (_("Unrecognized debug section: %s\n"), print_name);
11802 /* Set DUMP_SECTS for all sections where dumps were requested
11803 based on section name. */
11806 initialise_dumps_byname (void)
11808 struct dump_list_entry * cur;
11810 for (cur = dump_sects_byname; cur; cur = cur->next)
11815 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11816 if (streq (SECTION_NAME (section_headers + i), cur->name))
11818 request_dump_bynumber (i, cur->type);
11823 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11829 process_section_contents (FILE * file)
11831 Elf_Internal_Shdr * section;
11837 initialise_dumps_byname ();
11839 for (i = 0, section = section_headers;
11840 i < elf_header.e_shnum && i < num_dump_sects;
11843 #ifdef SUPPORT_DISASSEMBLY
11844 if (dump_sects[i] & DISASS_DUMP)
11845 disassemble_section (section, file);
11847 if (dump_sects[i] & HEX_DUMP)
11848 dump_section_as_bytes (section, file, FALSE);
11850 if (dump_sects[i] & RELOC_DUMP)
11851 dump_section_as_bytes (section, file, TRUE);
11853 if (dump_sects[i] & STRING_DUMP)
11854 dump_section_as_strings (section, file);
11856 if (dump_sects[i] & DEBUG_DUMP)
11857 display_debug_section (i, section, file);
11860 /* Check to see if the user requested a
11861 dump of a section that does not exist. */
11862 while (i++ < num_dump_sects)
11864 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11868 process_mips_fpe_exception (int mask)
11873 if (mask & OEX_FPU_INEX)
11874 fputs ("INEX", stdout), first = 0;
11875 if (mask & OEX_FPU_UFLO)
11876 printf ("%sUFLO", first ? "" : "|"), first = 0;
11877 if (mask & OEX_FPU_OFLO)
11878 printf ("%sOFLO", first ? "" : "|"), first = 0;
11879 if (mask & OEX_FPU_DIV0)
11880 printf ("%sDIV0", first ? "" : "|"), first = 0;
11881 if (mask & OEX_FPU_INVAL)
11882 printf ("%sINVAL", first ? "" : "|");
11885 fputs ("0", stdout);
11888 /* Display's the value of TAG at location P. If TAG is
11889 greater than 0 it is assumed to be an unknown tag, and
11890 a message is printed to this effect. Otherwise it is
11891 assumed that a message has already been printed.
11893 If the bottom bit of TAG is set it assumed to have a
11894 string value, otherwise it is assumed to have an integer
11897 Returns an updated P pointing to the first unread byte
11898 beyond the end of TAG's value.
11900 Reads at or beyond END will not be made. */
11902 static unsigned char *
11903 display_tag_value (int tag,
11905 const unsigned char * const end)
11910 printf (" Tag_unknown_%d: ", tag);
11914 warn (_("<corrupt tag>\n"));
11918 /* PR 17531 file: 027-19978-0.004. */
11919 size_t maxlen = (end - p) - 1;
11924 print_symbol ((int) maxlen, (const char *) p);
11925 p += strnlen ((char *) p, maxlen) + 1;
11929 printf (_("<corrupt string tag>"));
11930 p = (unsigned char *) end;
11938 val = read_uleb128 (p, &len, end);
11940 printf ("%ld (0x%lx)\n", val, val);
11947 /* ARM EABI attributes section. */
11952 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11954 const char ** table;
11955 } arm_attr_public_tag;
11957 static const char * arm_attr_tag_CPU_arch[] =
11958 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11959 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11960 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11961 static const char * arm_attr_tag_THUMB_ISA_use[] =
11962 {"No", "Thumb-1", "Thumb-2"};
11963 static const char * arm_attr_tag_FP_arch[] =
11964 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11965 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
11966 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11967 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11968 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11969 static const char * arm_attr_tag_PCS_config[] =
11970 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11971 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11972 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11973 {"V6", "SB", "TLS", "Unused"};
11974 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11975 {"Absolute", "PC-relative", "SB-relative", "None"};
11976 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11977 {"Absolute", "PC-relative", "None"};
11978 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11979 {"None", "direct", "GOT-indirect"};
11980 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11981 {"None", "??? 1", "2", "??? 3", "4"};
11982 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11983 static const char * arm_attr_tag_ABI_FP_denormal[] =
11984 {"Unused", "Needed", "Sign only"};
11985 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11986 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11987 static const char * arm_attr_tag_ABI_FP_number_model[] =
11988 {"Unused", "Finite", "RTABI", "IEEE 754"};
11989 static const char * arm_attr_tag_ABI_enum_size[] =
11990 {"Unused", "small", "int", "forced to int"};
11991 static const char * arm_attr_tag_ABI_HardFP_use[] =
11992 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11993 static const char * arm_attr_tag_ABI_VFP_args[] =
11994 {"AAPCS", "VFP registers", "custom"};
11995 static const char * arm_attr_tag_ABI_WMMX_args[] =
11996 {"AAPCS", "WMMX registers", "custom"};
11997 static const char * arm_attr_tag_ABI_optimization_goals[] =
11998 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11999 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12000 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12001 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12002 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12003 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12004 static const char * arm_attr_tag_FP_HP_extension[] =
12005 {"Not Allowed", "Allowed"};
12006 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12007 {"None", "IEEE 754", "Alternative Format"};
12008 static const char * arm_attr_tag_MPextension_use[] =
12009 {"Not Allowed", "Allowed"};
12010 static const char * arm_attr_tag_DIV_use[] =
12011 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12012 "Allowed in v7-A with integer division extension"};
12013 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12014 static const char * arm_attr_tag_Virtualization_use[] =
12015 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12016 "TrustZone and Virtualization Extensions"};
12017 static const char * arm_attr_tag_MPextension_use_legacy[] =
12018 {"Not Allowed", "Allowed"};
12020 #define LOOKUP(id, name) \
12021 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12022 static arm_attr_public_tag arm_attr_public_tags[] =
12024 {4, "CPU_raw_name", 1, NULL},
12025 {5, "CPU_name", 1, NULL},
12026 LOOKUP(6, CPU_arch),
12027 {7, "CPU_arch_profile", 0, NULL},
12028 LOOKUP(8, ARM_ISA_use),
12029 LOOKUP(9, THUMB_ISA_use),
12030 LOOKUP(10, FP_arch),
12031 LOOKUP(11, WMMX_arch),
12032 LOOKUP(12, Advanced_SIMD_arch),
12033 LOOKUP(13, PCS_config),
12034 LOOKUP(14, ABI_PCS_R9_use),
12035 LOOKUP(15, ABI_PCS_RW_data),
12036 LOOKUP(16, ABI_PCS_RO_data),
12037 LOOKUP(17, ABI_PCS_GOT_use),
12038 LOOKUP(18, ABI_PCS_wchar_t),
12039 LOOKUP(19, ABI_FP_rounding),
12040 LOOKUP(20, ABI_FP_denormal),
12041 LOOKUP(21, ABI_FP_exceptions),
12042 LOOKUP(22, ABI_FP_user_exceptions),
12043 LOOKUP(23, ABI_FP_number_model),
12044 {24, "ABI_align_needed", 0, NULL},
12045 {25, "ABI_align_preserved", 0, NULL},
12046 LOOKUP(26, ABI_enum_size),
12047 LOOKUP(27, ABI_HardFP_use),
12048 LOOKUP(28, ABI_VFP_args),
12049 LOOKUP(29, ABI_WMMX_args),
12050 LOOKUP(30, ABI_optimization_goals),
12051 LOOKUP(31, ABI_FP_optimization_goals),
12052 {32, "compatibility", 0, NULL},
12053 LOOKUP(34, CPU_unaligned_access),
12054 LOOKUP(36, FP_HP_extension),
12055 LOOKUP(38, ABI_FP_16bit_format),
12056 LOOKUP(42, MPextension_use),
12057 LOOKUP(44, DIV_use),
12058 {64, "nodefaults", 0, NULL},
12059 {65, "also_compatible_with", 0, NULL},
12060 LOOKUP(66, T2EE_use),
12061 {67, "conformance", 1, NULL},
12062 LOOKUP(68, Virtualization_use),
12063 LOOKUP(70, MPextension_use_legacy)
12067 static unsigned char *
12068 display_arm_attribute (unsigned char * p,
12069 const unsigned char * const end)
12074 arm_attr_public_tag * attr;
12078 tag = read_uleb128 (p, &len, end);
12081 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12083 if (arm_attr_public_tags[i].tag == tag)
12085 attr = &arm_attr_public_tags[i];
12092 printf (" Tag_%s: ", attr->name);
12093 switch (attr->type)
12098 case 7: /* Tag_CPU_arch_profile. */
12099 val = read_uleb128 (p, &len, end);
12103 case 0: printf (_("None\n")); break;
12104 case 'A': printf (_("Application\n")); break;
12105 case 'R': printf (_("Realtime\n")); break;
12106 case 'M': printf (_("Microcontroller\n")); break;
12107 case 'S': printf (_("Application or Realtime\n")); break;
12108 default: printf ("??? (%d)\n", val); break;
12112 case 24: /* Tag_align_needed. */
12113 val = read_uleb128 (p, &len, end);
12117 case 0: printf (_("None\n")); break;
12118 case 1: printf (_("8-byte\n")); break;
12119 case 2: printf (_("4-byte\n")); break;
12120 case 3: printf ("??? 3\n"); break;
12123 printf (_("8-byte and up to %d-byte extended\n"),
12126 printf ("??? (%d)\n", val);
12131 case 25: /* Tag_align_preserved. */
12132 val = read_uleb128 (p, &len, end);
12136 case 0: printf (_("None\n")); break;
12137 case 1: printf (_("8-byte, except leaf SP\n")); break;
12138 case 2: printf (_("8-byte\n")); break;
12139 case 3: printf ("??? 3\n"); break;
12142 printf (_("8-byte and up to %d-byte extended\n"),
12145 printf ("??? (%d)\n", val);
12150 case 32: /* Tag_compatibility. */
12152 val = read_uleb128 (p, &len, end);
12154 printf (_("flag = %d, vendor = "), val);
12157 size_t maxlen = (end - p) - 1;
12159 print_symbol ((int) maxlen, (const char *) p);
12160 p += strnlen ((char *) p, maxlen) + 1;
12164 printf (_("<corrupt>"));
12165 p = (unsigned char *) end;
12171 case 64: /* Tag_nodefaults. */
12172 /* PR 17531: file: 001-505008-0.01. */
12175 printf (_("True\n"));
12178 case 65: /* Tag_also_compatible_with. */
12179 val = read_uleb128 (p, &len, end);
12181 if (val == 6 /* Tag_CPU_arch. */)
12183 val = read_uleb128 (p, &len, end);
12185 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12186 printf ("??? (%d)\n", val);
12188 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12192 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12202 return display_tag_value (-1, p, end);
12204 return display_tag_value (0, p, end);
12207 assert (attr->type & 0x80);
12208 val = read_uleb128 (p, &len, end);
12210 type = attr->type & 0x7f;
12212 printf ("??? (%d)\n", val);
12214 printf ("%s\n", attr->table[val]);
12219 return display_tag_value (tag, p, end);
12222 static unsigned char *
12223 display_gnu_attribute (unsigned char * p,
12224 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12225 const unsigned char * const end)
12231 tag = read_uleb128 (p, &len, end);
12234 /* Tag_compatibility is the only generic GNU attribute defined at
12238 val = read_uleb128 (p, &len, end);
12241 printf (_("flag = %d, vendor = "), val);
12244 printf (_("<corrupt>\n"));
12245 warn (_("corrupt vendor attribute\n"));
12251 size_t maxlen = (end - p) - 1;
12253 print_symbol ((int) maxlen, (const char *) p);
12254 p += strnlen ((char *) p, maxlen) + 1;
12258 printf (_("<corrupt>"));
12259 p = (unsigned char *) end;
12266 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12267 return display_proc_gnu_attribute (p, tag, end);
12269 return display_tag_value (tag, p, end);
12272 static unsigned char *
12273 display_power_gnu_attribute (unsigned char * p,
12275 const unsigned char * const end)
12280 if (tag == Tag_GNU_Power_ABI_FP)
12282 val = read_uleb128 (p, &len, end);
12284 printf (" Tag_GNU_Power_ABI_FP: ");
12289 printf (_("Hard or soft float\n"));
12292 printf (_("Hard float\n"));
12295 printf (_("Soft float\n"));
12298 printf (_("Single-precision hard float\n"));
12301 printf ("??? (%d)\n", val);
12307 if (tag == Tag_GNU_Power_ABI_Vector)
12309 val = read_uleb128 (p, &len, end);
12311 printf (" Tag_GNU_Power_ABI_Vector: ");
12315 printf (_("Any\n"));
12318 printf (_("Generic\n"));
12321 printf ("AltiVec\n");
12327 printf ("??? (%d)\n", val);
12333 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12337 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12341 val = read_uleb128 (p, &len, end);
12343 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12347 printf (_("Any\n"));
12350 printf ("r3/r4\n");
12353 printf (_("Memory\n"));
12356 printf ("??? (%d)\n", val);
12362 return display_tag_value (tag & 1, p, end);
12366 display_sparc_hwcaps (int mask)
12372 if (mask & ELF_SPARC_HWCAP_MUL32)
12373 fputs ("mul32", stdout), first = 0;
12374 if (mask & ELF_SPARC_HWCAP_DIV32)
12375 printf ("%sdiv32", first ? "" : "|"), first = 0;
12376 if (mask & ELF_SPARC_HWCAP_FSMULD)
12377 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12378 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12379 printf ("%sv8plus", first ? "" : "|"), first = 0;
12380 if (mask & ELF_SPARC_HWCAP_POPC)
12381 printf ("%spopc", first ? "" : "|"), first = 0;
12382 if (mask & ELF_SPARC_HWCAP_VIS)
12383 printf ("%svis", first ? "" : "|"), first = 0;
12384 if (mask & ELF_SPARC_HWCAP_VIS2)
12385 printf ("%svis2", first ? "" : "|"), first = 0;
12386 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12387 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12388 if (mask & ELF_SPARC_HWCAP_FMAF)
12389 printf ("%sfmaf", first ? "" : "|"), first = 0;
12390 if (mask & ELF_SPARC_HWCAP_VIS3)
12391 printf ("%svis3", first ? "" : "|"), first = 0;
12392 if (mask & ELF_SPARC_HWCAP_HPC)
12393 printf ("%shpc", first ? "" : "|"), first = 0;
12394 if (mask & ELF_SPARC_HWCAP_RANDOM)
12395 printf ("%srandom", first ? "" : "|"), first = 0;
12396 if (mask & ELF_SPARC_HWCAP_TRANS)
12397 printf ("%strans", first ? "" : "|"), first = 0;
12398 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12399 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12400 if (mask & ELF_SPARC_HWCAP_IMA)
12401 printf ("%sima", first ? "" : "|"), first = 0;
12402 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12403 printf ("%scspare", first ? "" : "|"), first = 0;
12406 fputc ('0', stdout);
12407 fputc ('\n', stdout);
12411 display_sparc_hwcaps2 (int mask)
12417 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12418 fputs ("fjathplus", stdout), first = 0;
12419 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12420 printf ("%svis3b", first ? "" : "|"), first = 0;
12421 if (mask & ELF_SPARC_HWCAP2_ADP)
12422 printf ("%sadp", first ? "" : "|"), first = 0;
12423 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12424 printf ("%ssparc5", first ? "" : "|"), first = 0;
12425 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12426 printf ("%smwait", first ? "" : "|"), first = 0;
12427 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12428 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12429 if (mask & ELF_SPARC_HWCAP2_XMONT)
12430 printf ("%sxmont2", first ? "" : "|"), first = 0;
12431 if (mask & ELF_SPARC_HWCAP2_NSEC)
12432 printf ("%snsec", first ? "" : "|"), first = 0;
12433 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12434 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12435 if (mask & ELF_SPARC_HWCAP2_FJDES)
12436 printf ("%sfjdes", first ? "" : "|"), first = 0;
12437 if (mask & ELF_SPARC_HWCAP2_FJAES)
12438 printf ("%sfjaes", first ? "" : "|"), first = 0;
12441 fputc ('0', stdout);
12442 fputc ('\n', stdout);
12445 static unsigned char *
12446 display_sparc_gnu_attribute (unsigned char * p,
12448 const unsigned char * const end)
12453 if (tag == Tag_GNU_Sparc_HWCAPS)
12455 val = read_uleb128 (p, &len, end);
12457 printf (" Tag_GNU_Sparc_HWCAPS: ");
12458 display_sparc_hwcaps (val);
12461 if (tag == Tag_GNU_Sparc_HWCAPS2)
12463 val = read_uleb128 (p, &len, end);
12465 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12466 display_sparc_hwcaps2 (val);
12470 return display_tag_value (tag, p, end);
12474 print_mips_fp_abi_value (int val)
12478 case Val_GNU_MIPS_ABI_FP_ANY:
12479 printf (_("Hard or soft float\n"));
12481 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12482 printf (_("Hard float (double precision)\n"));
12484 case Val_GNU_MIPS_ABI_FP_SINGLE:
12485 printf (_("Hard float (single precision)\n"));
12487 case Val_GNU_MIPS_ABI_FP_SOFT:
12488 printf (_("Soft float\n"));
12490 case Val_GNU_MIPS_ABI_FP_OLD_64:
12491 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12493 case Val_GNU_MIPS_ABI_FP_XX:
12494 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12496 case Val_GNU_MIPS_ABI_FP_64:
12497 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12499 case Val_GNU_MIPS_ABI_FP_64A:
12500 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12503 printf ("??? (%d)\n", val);
12508 static unsigned char *
12509 display_mips_gnu_attribute (unsigned char * p,
12511 const unsigned char * const end)
12513 if (tag == Tag_GNU_MIPS_ABI_FP)
12518 val = read_uleb128 (p, &len, end);
12520 printf (" Tag_GNU_MIPS_ABI_FP: ");
12522 print_mips_fp_abi_value (val);
12527 if (tag == Tag_GNU_MIPS_ABI_MSA)
12532 val = read_uleb128 (p, &len, end);
12534 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12538 case Val_GNU_MIPS_ABI_MSA_ANY:
12539 printf (_("Any MSA or not\n"));
12541 case Val_GNU_MIPS_ABI_MSA_128:
12542 printf (_("128-bit MSA\n"));
12545 printf ("??? (%d)\n", val);
12551 return display_tag_value (tag & 1, p, end);
12554 static unsigned char *
12555 display_tic6x_attribute (unsigned char * p,
12556 const unsigned char * const end)
12562 tag = read_uleb128 (p, &len, end);
12568 val = read_uleb128 (p, &len, end);
12570 printf (" Tag_ISA: ");
12574 case C6XABI_Tag_ISA_none:
12575 printf (_("None\n"));
12577 case C6XABI_Tag_ISA_C62X:
12580 case C6XABI_Tag_ISA_C67X:
12583 case C6XABI_Tag_ISA_C67XP:
12584 printf ("C67x+\n");
12586 case C6XABI_Tag_ISA_C64X:
12589 case C6XABI_Tag_ISA_C64XP:
12590 printf ("C64x+\n");
12592 case C6XABI_Tag_ISA_C674X:
12593 printf ("C674x\n");
12596 printf ("??? (%d)\n", val);
12601 case Tag_ABI_wchar_t:
12602 val = read_uleb128 (p, &len, end);
12604 printf (" Tag_ABI_wchar_t: ");
12608 printf (_("Not used\n"));
12611 printf (_("2 bytes\n"));
12614 printf (_("4 bytes\n"));
12617 printf ("??? (%d)\n", val);
12622 case Tag_ABI_stack_align_needed:
12623 val = read_uleb128 (p, &len, end);
12625 printf (" Tag_ABI_stack_align_needed: ");
12629 printf (_("8-byte\n"));
12632 printf (_("16-byte\n"));
12635 printf ("??? (%d)\n", val);
12640 case Tag_ABI_stack_align_preserved:
12641 val = read_uleb128 (p, &len, end);
12643 printf (" Tag_ABI_stack_align_preserved: ");
12647 printf (_("8-byte\n"));
12650 printf (_("16-byte\n"));
12653 printf ("??? (%d)\n", val);
12659 val = read_uleb128 (p, &len, end);
12661 printf (" Tag_ABI_DSBT: ");
12665 printf (_("DSBT addressing not used\n"));
12668 printf (_("DSBT addressing used\n"));
12671 printf ("??? (%d)\n", val);
12677 val = read_uleb128 (p, &len, end);
12679 printf (" Tag_ABI_PID: ");
12683 printf (_("Data addressing position-dependent\n"));
12686 printf (_("Data addressing position-independent, GOT near DP\n"));
12689 printf (_("Data addressing position-independent, GOT far from DP\n"));
12692 printf ("??? (%d)\n", val);
12698 val = read_uleb128 (p, &len, end);
12700 printf (" Tag_ABI_PIC: ");
12704 printf (_("Code addressing position-dependent\n"));
12707 printf (_("Code addressing position-independent\n"));
12710 printf ("??? (%d)\n", val);
12715 case Tag_ABI_array_object_alignment:
12716 val = read_uleb128 (p, &len, end);
12718 printf (" Tag_ABI_array_object_alignment: ");
12722 printf (_("8-byte\n"));
12725 printf (_("4-byte\n"));
12728 printf (_("16-byte\n"));
12731 printf ("??? (%d)\n", val);
12736 case Tag_ABI_array_object_align_expected:
12737 val = read_uleb128 (p, &len, end);
12739 printf (" Tag_ABI_array_object_align_expected: ");
12743 printf (_("8-byte\n"));
12746 printf (_("4-byte\n"));
12749 printf (_("16-byte\n"));
12752 printf ("??? (%d)\n", val);
12757 case Tag_ABI_compatibility:
12759 val = read_uleb128 (p, &len, end);
12761 printf (" Tag_ABI_compatibility: ");
12762 printf (_("flag = %d, vendor = "), val);
12765 size_t maxlen = (end - p) - 1;
12767 print_symbol ((int) maxlen, (const char *) p);
12768 p += strnlen ((char *) p, maxlen) + 1;
12772 printf (_("<corrupt>"));
12773 p = (unsigned char *) end;
12779 case Tag_ABI_conformance:
12781 printf (" Tag_ABI_conformance: \"");
12784 size_t maxlen = (end - p) - 1;
12786 print_symbol ((int) maxlen, (const char *) p);
12787 p += strnlen ((char *) p, maxlen) + 1;
12791 printf (_("<corrupt>"));
12792 p = (unsigned char *) end;
12799 return display_tag_value (tag, p, end);
12803 display_raw_attribute (unsigned char * p, unsigned char * end)
12805 unsigned long addr = 0;
12806 size_t bytes = end - p;
12813 int lbytes = (bytes > 16 ? 16 : bytes);
12815 printf (" 0x%8.8lx ", addr);
12817 for (j = 0; j < 16; j++)
12820 printf ("%2.2x", p[j]);
12828 for (j = 0; j < lbytes; j++)
12831 if (k >= ' ' && k < 0x7f)
12847 static unsigned char *
12848 display_msp430x_attribute (unsigned char * p,
12849 const unsigned char * const end)
12855 tag = read_uleb128 (p, & len, end);
12860 case OFBA_MSPABI_Tag_ISA:
12861 val = read_uleb128 (p, &len, end);
12863 printf (" Tag_ISA: ");
12866 case 0: printf (_("None\n")); break;
12867 case 1: printf (_("MSP430\n")); break;
12868 case 2: printf (_("MSP430X\n")); break;
12869 default: printf ("??? (%d)\n", val); break;
12873 case OFBA_MSPABI_Tag_Code_Model:
12874 val = read_uleb128 (p, &len, end);
12876 printf (" Tag_Code_Model: ");
12879 case 0: printf (_("None\n")); break;
12880 case 1: printf (_("Small\n")); break;
12881 case 2: printf (_("Large\n")); break;
12882 default: printf ("??? (%d)\n", val); break;
12886 case OFBA_MSPABI_Tag_Data_Model:
12887 val = read_uleb128 (p, &len, end);
12889 printf (" Tag_Data_Model: ");
12892 case 0: printf (_("None\n")); break;
12893 case 1: printf (_("Small\n")); break;
12894 case 2: printf (_("Large\n")); break;
12895 case 3: printf (_("Restricted Large\n")); break;
12896 default: printf ("??? (%d)\n", val); break;
12901 printf (_(" <unknown tag %d>: "), tag);
12908 size_t maxlen = (end - p) - 1;
12910 print_symbol ((int) maxlen, (const char *) p);
12911 p += strnlen ((char *) p, maxlen) + 1;
12915 printf (_("<corrupt>"));
12916 p = (unsigned char *) end;
12922 val = read_uleb128 (p, &len, end);
12924 printf ("%d (0x%x)\n", val, val);
12934 process_attributes (FILE * file,
12935 const char * public_name,
12936 unsigned int proc_type,
12937 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12938 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12940 Elf_Internal_Shdr * sect;
12943 /* Find the section header so that we get the size. */
12944 for (i = 0, sect = section_headers;
12945 i < elf_header.e_shnum;
12948 unsigned char * contents;
12951 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12954 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12955 sect->sh_size, _("attributes"));
12956 if (contents == NULL)
12962 bfd_vma section_len;
12964 section_len = sect->sh_size - 1;
12967 while (section_len > 0)
12970 unsigned int namelen;
12971 bfd_boolean public_section;
12972 bfd_boolean gnu_section;
12974 if (section_len <= 4)
12976 error (_("Tag section ends prematurely\n"));
12979 attr_len = byte_get (p, 4);
12982 if (attr_len > section_len)
12984 error (_("Bad attribute length (%u > %u)\n"),
12985 (unsigned) attr_len, (unsigned) section_len);
12986 attr_len = section_len;
12988 /* PR 17531: file: 001-101425-0.004 */
12989 else if (attr_len < 5)
12991 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
12995 section_len -= attr_len;
12998 namelen = strnlen ((char *) p, attr_len) + 1;
12999 if (namelen == 0 || namelen >= attr_len)
13001 error (_("Corrupt attribute section name\n"));
13005 printf (_("Attribute Section: "));
13006 print_symbol (INT_MAX, (const char *) p);
13009 if (public_name && streq ((char *) p, public_name))
13010 public_section = TRUE;
13012 public_section = FALSE;
13014 if (streq ((char *) p, "gnu"))
13015 gnu_section = TRUE;
13017 gnu_section = FALSE;
13020 attr_len -= namelen;
13022 while (attr_len > 0 && p < contents + sect->sh_size)
13027 unsigned char * end;
13029 /* PR binutils/17531: Safe handling of corrupt files. */
13032 error (_("Unused bytes at end of section\n"));
13038 size = byte_get (p, 4);
13039 if (size > attr_len)
13041 error (_("Bad subsection length (%u > %u)\n"),
13042 (unsigned) size, (unsigned) attr_len);
13045 /* PR binutils/17531: Safe handling of corrupt files. */
13048 error (_("Bad subsection length (%u < 6)\n"),
13055 end = p + size - 1;
13056 assert (end <= contents + sect->sh_size);
13062 printf (_("File Attributes\n"));
13065 printf (_("Section Attributes:"));
13068 printf (_("Symbol Attributes:"));
13074 val = read_uleb128 (p, &j, end);
13078 printf (" %d", val);
13083 printf (_("Unknown tag: %d\n"), tag);
13084 public_section = FALSE;
13088 if (public_section && display_pub_attribute != NULL)
13091 p = display_pub_attribute (p, end);
13094 else if (gnu_section && display_proc_gnu_attribute != NULL)
13097 p = display_gnu_attribute (p,
13098 display_proc_gnu_attribute,
13104 printf (_(" Unknown attribute:\n"));
13105 display_raw_attribute (p, end);
13114 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13122 process_arm_specific (FILE * file)
13124 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13125 display_arm_attribute, NULL);
13129 process_power_specific (FILE * file)
13131 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13132 display_power_gnu_attribute);
13136 process_sparc_specific (FILE * file)
13138 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13139 display_sparc_gnu_attribute);
13143 process_tic6x_specific (FILE * file)
13145 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13146 display_tic6x_attribute, NULL);
13150 process_msp430x_specific (FILE * file)
13152 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13153 display_msp430x_attribute, NULL);
13156 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13157 Print the Address, Access and Initial fields of an entry at VMA ADDR
13158 and return the VMA of the next entry. */
13161 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13164 print_vma (addr, LONG_HEX);
13166 if (addr < pltgot + 0xfff0)
13167 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13169 printf ("%10s", "");
13172 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13177 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13178 print_vma (entry, LONG_HEX);
13180 return addr + (is_32bit_elf ? 4 : 8);
13183 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13184 PLTGOT. Print the Address and Initial fields of an entry at VMA
13185 ADDR and return the VMA of the next entry. */
13188 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13191 print_vma (addr, LONG_HEX);
13194 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13199 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13200 print_vma (entry, LONG_HEX);
13202 return addr + (is_32bit_elf ? 4 : 8);
13206 print_mips_ases (unsigned int mask)
13208 if (mask & AFL_ASE_DSP)
13209 fputs ("\n\tDSP ASE", stdout);
13210 if (mask & AFL_ASE_DSPR2)
13211 fputs ("\n\tDSP R2 ASE", stdout);
13212 if (mask & AFL_ASE_EVA)
13213 fputs ("\n\tEnhanced VA Scheme", stdout);
13214 if (mask & AFL_ASE_MCU)
13215 fputs ("\n\tMCU (MicroController) ASE", stdout);
13216 if (mask & AFL_ASE_MDMX)
13217 fputs ("\n\tMDMX ASE", stdout);
13218 if (mask & AFL_ASE_MIPS3D)
13219 fputs ("\n\tMIPS-3D ASE", stdout);
13220 if (mask & AFL_ASE_MT)
13221 fputs ("\n\tMT ASE", stdout);
13222 if (mask & AFL_ASE_SMARTMIPS)
13223 fputs ("\n\tSmartMIPS ASE", stdout);
13224 if (mask & AFL_ASE_VIRT)
13225 fputs ("\n\tVZ ASE", stdout);
13226 if (mask & AFL_ASE_MSA)
13227 fputs ("\n\tMSA ASE", stdout);
13228 if (mask & AFL_ASE_MIPS16)
13229 fputs ("\n\tMIPS16 ASE", stdout);
13230 if (mask & AFL_ASE_MICROMIPS)
13231 fputs ("\n\tMICROMIPS ASE", stdout);
13232 if (mask & AFL_ASE_XPA)
13233 fputs ("\n\tXPA ASE", stdout);
13235 fprintf (stdout, "\n\t%s", _("None"));
13236 else if ((mask & ~AFL_ASE_MASK) != 0)
13237 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13241 print_mips_isa_ext (unsigned int isa_ext)
13246 fputs (_("None"), stdout);
13249 fputs ("RMI XLR", stdout);
13251 case AFL_EXT_OCTEON3:
13252 fputs ("Cavium Networks Octeon3", stdout);
13254 case AFL_EXT_OCTEON2:
13255 fputs ("Cavium Networks Octeon2", stdout);
13257 case AFL_EXT_OCTEONP:
13258 fputs ("Cavium Networks OcteonP", stdout);
13260 case AFL_EXT_LOONGSON_3A:
13261 fputs ("Loongson 3A", stdout);
13263 case AFL_EXT_OCTEON:
13264 fputs ("Cavium Networks Octeon", stdout);
13267 fputs ("Toshiba R5900", stdout);
13270 fputs ("MIPS R4650", stdout);
13273 fputs ("LSI R4010", stdout);
13276 fputs ("NEC VR4100", stdout);
13279 fputs ("Toshiba R3900", stdout);
13281 case AFL_EXT_10000:
13282 fputs ("MIPS R10000", stdout);
13285 fputs ("Broadcom SB-1", stdout);
13288 fputs ("NEC VR4111/VR4181", stdout);
13291 fputs ("NEC VR4120", stdout);
13294 fputs ("NEC VR5400", stdout);
13297 fputs ("NEC VR5500", stdout);
13299 case AFL_EXT_LOONGSON_2E:
13300 fputs ("ST Microelectronics Loongson 2E", stdout);
13302 case AFL_EXT_LOONGSON_2F:
13303 fputs ("ST Microelectronics Loongson 2F", stdout);
13306 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13311 get_mips_reg_size (int reg_size)
13313 return (reg_size == AFL_REG_NONE) ? 0
13314 : (reg_size == AFL_REG_32) ? 32
13315 : (reg_size == AFL_REG_64) ? 64
13316 : (reg_size == AFL_REG_128) ? 128
13321 process_mips_specific (FILE * file)
13323 Elf_Internal_Dyn * entry;
13324 Elf_Internal_Shdr *sect = NULL;
13325 size_t liblist_offset = 0;
13326 size_t liblistno = 0;
13327 size_t conflictsno = 0;
13328 size_t options_offset = 0;
13329 size_t conflicts_offset = 0;
13330 size_t pltrelsz = 0;
13332 bfd_vma pltgot = 0;
13333 bfd_vma mips_pltgot = 0;
13334 bfd_vma jmprel = 0;
13335 bfd_vma local_gotno = 0;
13336 bfd_vma gotsym = 0;
13337 bfd_vma symtabno = 0;
13339 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13340 display_mips_gnu_attribute);
13342 sect = find_section (".MIPS.abiflags");
13346 Elf_External_ABIFlags_v0 *abiflags_ext;
13347 Elf_Internal_ABIFlags_v0 abiflags_in;
13349 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13350 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13353 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13354 sect->sh_size, _("MIPS ABI Flags section"));
13357 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13358 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13359 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13360 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13361 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13362 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13363 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13364 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13365 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13366 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13367 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13369 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13370 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13371 if (abiflags_in.isa_rev > 1)
13372 printf ("r%d", abiflags_in.isa_rev);
13373 printf ("\nGPR size: %d",
13374 get_mips_reg_size (abiflags_in.gpr_size));
13375 printf ("\nCPR1 size: %d",
13376 get_mips_reg_size (abiflags_in.cpr1_size));
13377 printf ("\nCPR2 size: %d",
13378 get_mips_reg_size (abiflags_in.cpr2_size));
13379 fputs ("\nFP ABI: ", stdout);
13380 print_mips_fp_abi_value (abiflags_in.fp_abi);
13381 fputs ("ISA Extension: ", stdout);
13382 print_mips_isa_ext (abiflags_in.isa_ext);
13383 fputs ("\nASEs:", stdout);
13384 print_mips_ases (abiflags_in.ases);
13385 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13386 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13387 fputc ('\n', stdout);
13388 free (abiflags_ext);
13393 /* We have a lot of special sections. Thanks SGI! */
13394 if (dynamic_section == NULL)
13395 /* No information available. */
13398 for (entry = dynamic_section;
13399 /* PR 17531 file: 012-50589-0.004. */
13400 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13402 switch (entry->d_tag)
13404 case DT_MIPS_LIBLIST:
13406 = offset_from_vma (file, entry->d_un.d_val,
13407 liblistno * sizeof (Elf32_External_Lib));
13409 case DT_MIPS_LIBLISTNO:
13410 liblistno = entry->d_un.d_val;
13412 case DT_MIPS_OPTIONS:
13413 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13415 case DT_MIPS_CONFLICT:
13417 = offset_from_vma (file, entry->d_un.d_val,
13418 conflictsno * sizeof (Elf32_External_Conflict));
13420 case DT_MIPS_CONFLICTNO:
13421 conflictsno = entry->d_un.d_val;
13424 pltgot = entry->d_un.d_ptr;
13426 case DT_MIPS_LOCAL_GOTNO:
13427 local_gotno = entry->d_un.d_val;
13429 case DT_MIPS_GOTSYM:
13430 gotsym = entry->d_un.d_val;
13432 case DT_MIPS_SYMTABNO:
13433 symtabno = entry->d_un.d_val;
13435 case DT_MIPS_PLTGOT:
13436 mips_pltgot = entry->d_un.d_ptr;
13439 pltrel = entry->d_un.d_val;
13442 pltrelsz = entry->d_un.d_val;
13445 jmprel = entry->d_un.d_ptr;
13451 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13453 Elf32_External_Lib * elib;
13456 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13458 sizeof (Elf32_External_Lib),
13459 _("liblist section data"));
13462 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13463 (unsigned long) liblistno);
13464 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13467 for (cnt = 0; cnt < liblistno; ++cnt)
13474 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13475 atime = BYTE_GET (elib[cnt].l_time_stamp);
13476 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13477 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13478 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13480 tmp = gmtime (&atime);
13481 snprintf (timebuf, sizeof (timebuf),
13482 "%04u-%02u-%02uT%02u:%02u:%02u",
13483 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13484 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13486 printf ("%3lu: ", (unsigned long) cnt);
13487 if (VALID_DYNAMIC_NAME (liblist.l_name))
13488 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13490 printf (_("<corrupt: %9ld>"), liblist.l_name);
13491 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13492 liblist.l_version);
13494 if (liblist.l_flags == 0)
13498 static const struct
13505 { " EXACT_MATCH", LL_EXACT_MATCH },
13506 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13507 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13508 { " EXPORTS", LL_EXPORTS },
13509 { " DELAY_LOAD", LL_DELAY_LOAD },
13510 { " DELTA", LL_DELTA }
13512 int flags = liblist.l_flags;
13515 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13516 if ((flags & l_flags_vals[fcnt].bit) != 0)
13518 fputs (l_flags_vals[fcnt].name, stdout);
13519 flags ^= l_flags_vals[fcnt].bit;
13522 printf (" %#x", (unsigned int) flags);
13532 if (options_offset != 0)
13534 Elf_External_Options * eopt;
13535 Elf_Internal_Options * iopt;
13536 Elf_Internal_Options * option;
13539 sect = section_headers;
13541 /* Find the section header so that we get the size. */
13542 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13543 /* PR 17533 file: 012-277276-0.004. */
13546 error (_("No MIPS_OPTIONS header found\n"));
13550 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13551 sect->sh_size, _("options"));
13554 iopt = (Elf_Internal_Options *)
13555 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13558 error (_("Out of memory allocatinf space for MIPS options\n"));
13565 while (offset < sect->sh_size)
13567 Elf_External_Options * eoption;
13569 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13571 option->kind = BYTE_GET (eoption->kind);
13572 option->size = BYTE_GET (eoption->size);
13573 option->section = BYTE_GET (eoption->section);
13574 option->info = BYTE_GET (eoption->info);
13576 offset += option->size;
13582 printf (_("\nSection '%s' contains %d entries:\n"),
13583 printable_section_name (sect), cnt);
13591 switch (option->kind)
13594 /* This shouldn't happen. */
13595 printf (" NULL %d %lx", option->section, option->info);
13598 printf (" REGINFO ");
13599 if (elf_header.e_machine == EM_MIPS)
13602 Elf32_External_RegInfo * ereg;
13603 Elf32_RegInfo reginfo;
13605 ereg = (Elf32_External_RegInfo *) (option + 1);
13606 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13607 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13608 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13609 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13610 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13611 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13613 printf ("GPR %08lx GP 0x%lx\n",
13614 reginfo.ri_gprmask,
13615 (unsigned long) reginfo.ri_gp_value);
13616 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13617 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13618 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13623 Elf64_External_RegInfo * ereg;
13624 Elf64_Internal_RegInfo reginfo;
13626 ereg = (Elf64_External_RegInfo *) (option + 1);
13627 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13628 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13629 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13630 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13631 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13632 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13634 printf ("GPR %08lx GP 0x",
13635 reginfo.ri_gprmask);
13636 printf_vma (reginfo.ri_gp_value);
13639 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13640 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13641 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13645 case ODK_EXCEPTIONS:
13646 fputs (" EXCEPTIONS fpe_min(", stdout);
13647 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13648 fputs (") fpe_max(", stdout);
13649 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13650 fputs (")", stdout);
13652 if (option->info & OEX_PAGE0)
13653 fputs (" PAGE0", stdout);
13654 if (option->info & OEX_SMM)
13655 fputs (" SMM", stdout);
13656 if (option->info & OEX_FPDBUG)
13657 fputs (" FPDBUG", stdout);
13658 if (option->info & OEX_DISMISS)
13659 fputs (" DISMISS", stdout);
13662 fputs (" PAD ", stdout);
13663 if (option->info & OPAD_PREFIX)
13664 fputs (" PREFIX", stdout);
13665 if (option->info & OPAD_POSTFIX)
13666 fputs (" POSTFIX", stdout);
13667 if (option->info & OPAD_SYMBOL)
13668 fputs (" SYMBOL", stdout);
13671 fputs (" HWPATCH ", stdout);
13672 if (option->info & OHW_R4KEOP)
13673 fputs (" R4KEOP", stdout);
13674 if (option->info & OHW_R8KPFETCH)
13675 fputs (" R8KPFETCH", stdout);
13676 if (option->info & OHW_R5KEOP)
13677 fputs (" R5KEOP", stdout);
13678 if (option->info & OHW_R5KCVTL)
13679 fputs (" R5KCVTL", stdout);
13682 fputs (" FILL ", stdout);
13683 /* XXX Print content of info word? */
13686 fputs (" TAGS ", stdout);
13687 /* XXX Print content of info word? */
13690 fputs (" HWAND ", stdout);
13691 if (option->info & OHWA0_R4KEOP_CHECKED)
13692 fputs (" R4KEOP_CHECKED", stdout);
13693 if (option->info & OHWA0_R4KEOP_CLEAN)
13694 fputs (" R4KEOP_CLEAN", stdout);
13697 fputs (" HWOR ", stdout);
13698 if (option->info & OHWA0_R4KEOP_CHECKED)
13699 fputs (" R4KEOP_CHECKED", stdout);
13700 if (option->info & OHWA0_R4KEOP_CLEAN)
13701 fputs (" R4KEOP_CLEAN", stdout);
13704 printf (" GP_GROUP %#06lx self-contained %#06lx",
13705 option->info & OGP_GROUP,
13706 (option->info & OGP_SELF) >> 16);
13709 printf (" IDENT %#06lx self-contained %#06lx",
13710 option->info & OGP_GROUP,
13711 (option->info & OGP_SELF) >> 16);
13714 /* This shouldn't happen. */
13715 printf (" %3d ??? %d %lx",
13716 option->kind, option->section, option->info);
13720 len = sizeof (* eopt);
13721 while (len < option->size)
13722 if (((char *) option)[len] >= ' '
13723 && ((char *) option)[len] < 0x7f)
13724 printf ("%c", ((char *) option)[len++]);
13726 printf ("\\%03o", ((char *) option)[len++]);
13728 fputs ("\n", stdout);
13736 if (conflicts_offset != 0 && conflictsno != 0)
13738 Elf32_Conflict * iconf;
13741 if (dynamic_symbols == NULL)
13743 error (_("conflict list found without a dynamic symbol table\n"));
13747 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
13750 error (_("Out of memory allocating space for dynamic conflicts\n"));
13756 Elf32_External_Conflict * econf32;
13758 econf32 = (Elf32_External_Conflict *)
13759 get_data (NULL, file, conflicts_offset, conflictsno,
13760 sizeof (* econf32), _("conflict"));
13764 for (cnt = 0; cnt < conflictsno; ++cnt)
13765 iconf[cnt] = BYTE_GET (econf32[cnt]);
13771 Elf64_External_Conflict * econf64;
13773 econf64 = (Elf64_External_Conflict *)
13774 get_data (NULL, file, conflicts_offset, conflictsno,
13775 sizeof (* econf64), _("conflict"));
13779 for (cnt = 0; cnt < conflictsno; ++cnt)
13780 iconf[cnt] = BYTE_GET (econf64[cnt]);
13785 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13786 (unsigned long) conflictsno);
13787 puts (_(" Num: Index Value Name"));
13789 for (cnt = 0; cnt < conflictsno; ++cnt)
13791 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
13793 if (iconf[cnt] >= num_dynamic_syms)
13794 printf (_("<corrupt symbol index>"));
13797 Elf_Internal_Sym * psym;
13799 psym = & dynamic_symbols[iconf[cnt]];
13800 print_vma (psym->st_value, FULL_HEX);
13802 if (VALID_DYNAMIC_NAME (psym->st_name))
13803 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13805 printf (_("<corrupt: %14ld>"), psym->st_name);
13813 if (pltgot != 0 && local_gotno != 0)
13815 bfd_vma ent, local_end, global_end;
13817 unsigned char * data;
13821 addr_size = (is_32bit_elf ? 4 : 8);
13822 local_end = pltgot + local_gotno * addr_size;
13824 /* PR binutils/17533 file: 012-111227-0.004 */
13825 if (symtabno < gotsym)
13827 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13828 (long) gotsym, (long) symtabno);
13832 global_end = local_end + (symtabno - gotsym) * addr_size;
13833 assert (global_end >= local_end);
13834 offset = offset_from_vma (file, pltgot, global_end - pltgot);
13835 data = (unsigned char *) get_data (NULL, file, offset,
13836 global_end - pltgot, 1,
13837 _("Global Offset Table data"));
13841 printf (_("\nPrimary GOT:\n"));
13842 printf (_(" Canonical gp value: "));
13843 print_vma (pltgot + 0x7ff0, LONG_HEX);
13846 printf (_(" Reserved entries:\n"));
13847 printf (_(" %*s %10s %*s Purpose\n"),
13848 addr_size * 2, _("Address"), _("Access"),
13849 addr_size * 2, _("Initial"));
13850 ent = print_mips_got_entry (data, pltgot, ent);
13851 printf (_(" Lazy resolver\n"));
13853 && (byte_get (data + ent - pltgot, addr_size)
13854 >> (addr_size * 8 - 1)) != 0)
13856 ent = print_mips_got_entry (data, pltgot, ent);
13857 printf (_(" Module pointer (GNU extension)\n"));
13861 if (ent < local_end)
13863 printf (_(" Local entries:\n"));
13864 printf (" %*s %10s %*s\n",
13865 addr_size * 2, _("Address"), _("Access"),
13866 addr_size * 2, _("Initial"));
13867 while (ent < local_end)
13869 ent = print_mips_got_entry (data, pltgot, ent);
13875 if (gotsym < symtabno)
13879 printf (_(" Global entries:\n"));
13880 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13881 addr_size * 2, _("Address"),
13883 addr_size * 2, _("Initial"),
13884 addr_size * 2, _("Sym.Val."),
13886 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13887 _("Ndx"), _("Name"));
13889 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13891 for (i = gotsym; i < symtabno; i++)
13893 ent = print_mips_got_entry (data, pltgot, ent);
13896 if (dynamic_symbols == NULL)
13897 printf (_("<no dynamic symbols>"));
13898 else if (i < num_dynamic_syms)
13900 Elf_Internal_Sym * psym = dynamic_symbols + i;
13902 print_vma (psym->st_value, LONG_HEX);
13903 printf (" %-7s %3s ",
13904 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13905 get_symbol_index_type (psym->st_shndx));
13907 if (VALID_DYNAMIC_NAME (psym->st_name))
13908 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13910 printf (_("<corrupt: %14ld>"), psym->st_name);
13913 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13914 (unsigned long) i);
13925 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13928 size_t offset, rel_offset;
13929 unsigned long count, i;
13930 unsigned char * data;
13931 int addr_size, sym_width;
13932 Elf_Internal_Rela * rels;
13934 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13935 if (pltrel == DT_RELA)
13937 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13942 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13947 addr_size = (is_32bit_elf ? 4 : 8);
13948 end = mips_pltgot + (2 + count) * addr_size;
13950 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13951 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13952 1, _("Procedure Linkage Table data"));
13956 printf ("\nPLT GOT:\n\n");
13957 printf (_(" Reserved entries:\n"));
13958 printf (_(" %*s %*s Purpose\n"),
13959 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13960 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13961 printf (_(" PLT lazy resolver\n"));
13962 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13963 printf (_(" Module pointer\n"));
13966 printf (_(" Entries:\n"));
13967 printf (" %*s %*s %*s %-7s %3s %s\n",
13968 addr_size * 2, _("Address"),
13969 addr_size * 2, _("Initial"),
13970 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13971 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13972 for (i = 0; i < count; i++)
13974 unsigned long idx = get_reloc_symindex (rels[i].r_info);
13976 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13979 if (idx >= num_dynamic_syms)
13980 printf (_("<corrupt symbol index: %lu>"), idx);
13983 Elf_Internal_Sym * psym = dynamic_symbols + idx;
13985 print_vma (psym->st_value, LONG_HEX);
13986 printf (" %-7s %3s ",
13987 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13988 get_symbol_index_type (psym->st_shndx));
13989 if (VALID_DYNAMIC_NAME (psym->st_name))
13990 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13992 printf (_("<corrupt: %14ld>"), psym->st_name);
14007 process_nds32_specific (FILE * file)
14009 Elf_Internal_Shdr *sect = NULL;
14011 sect = find_section (".nds32_e_flags");
14014 unsigned int *flag;
14016 printf ("\nNDS32 elf flags section:\n");
14017 flag = get_data (NULL, file, sect->sh_offset, 1,
14018 sect->sh_size, _("NDS32 elf flags section"));
14020 switch ((*flag) & 0x3)
14023 printf ("(VEC_SIZE):\tNo entry.\n");
14026 printf ("(VEC_SIZE):\t4 bytes\n");
14029 printf ("(VEC_SIZE):\t16 bytes\n");
14032 printf ("(VEC_SIZE):\treserved\n");
14041 process_gnu_liblist (FILE * file)
14043 Elf_Internal_Shdr * section;
14044 Elf_Internal_Shdr * string_sec;
14045 Elf32_External_Lib * elib;
14047 size_t strtab_size;
14054 for (i = 0, section = section_headers;
14055 i < elf_header.e_shnum;
14058 switch (section->sh_type)
14060 case SHT_GNU_LIBLIST:
14061 if (section->sh_link >= elf_header.e_shnum)
14064 elib = (Elf32_External_Lib *)
14065 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14066 _("liblist section data"));
14070 string_sec = section_headers + section->sh_link;
14072 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14073 string_sec->sh_size,
14074 _("liblist string table"));
14076 || section->sh_entsize != sizeof (Elf32_External_Lib))
14082 strtab_size = string_sec->sh_size;
14084 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14085 printable_section_name (section),
14086 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14088 puts (_(" Library Time Stamp Checksum Version Flags"));
14090 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14098 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14099 atime = BYTE_GET (elib[cnt].l_time_stamp);
14100 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14101 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14102 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14104 tmp = gmtime (&atime);
14105 snprintf (timebuf, sizeof (timebuf),
14106 "%04u-%02u-%02uT%02u:%02u:%02u",
14107 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14108 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14110 printf ("%3lu: ", (unsigned long) cnt);
14112 printf ("%-20s", liblist.l_name < strtab_size
14113 ? strtab + liblist.l_name : _("<corrupt>"));
14115 printf ("%-20.20s", liblist.l_name < strtab_size
14116 ? strtab + liblist.l_name : _("<corrupt>"));
14117 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14118 liblist.l_version, liblist.l_flags);
14129 static const char *
14130 get_note_type (unsigned e_type)
14132 static char buff[64];
14134 if (elf_header.e_type == ET_CORE)
14138 return _("NT_AUXV (auxiliary vector)");
14140 return _("NT_PRSTATUS (prstatus structure)");
14142 return _("NT_FPREGSET (floating point registers)");
14144 return _("NT_PRPSINFO (prpsinfo structure)");
14145 case NT_TASKSTRUCT:
14146 return _("NT_TASKSTRUCT (task structure)");
14148 return _("NT_PRXFPREG (user_xfpregs structure)");
14150 return _("NT_PPC_VMX (ppc Altivec registers)");
14152 return _("NT_PPC_VSX (ppc VSX registers)");
14154 return _("NT_386_TLS (x86 TLS information)");
14155 case NT_386_IOPERM:
14156 return _("NT_386_IOPERM (x86 I/O permissions)");
14157 case NT_X86_XSTATE:
14158 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14159 case NT_S390_HIGH_GPRS:
14160 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14161 case NT_S390_TIMER:
14162 return _("NT_S390_TIMER (s390 timer register)");
14163 case NT_S390_TODCMP:
14164 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14165 case NT_S390_TODPREG:
14166 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14168 return _("NT_S390_CTRS (s390 control registers)");
14169 case NT_S390_PREFIX:
14170 return _("NT_S390_PREFIX (s390 prefix register)");
14171 case NT_S390_LAST_BREAK:
14172 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14173 case NT_S390_SYSTEM_CALL:
14174 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14176 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14178 return _("NT_ARM_VFP (arm VFP registers)");
14180 return _("NT_ARM_TLS (AArch TLS registers)");
14181 case NT_ARM_HW_BREAK:
14182 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14183 case NT_ARM_HW_WATCH:
14184 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14186 return _("NT_PSTATUS (pstatus structure)");
14188 return _("NT_FPREGS (floating point registers)");
14190 return _("NT_PSINFO (psinfo structure)");
14192 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14194 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14195 case NT_WIN32PSTATUS:
14196 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14198 return _("NT_SIGINFO (siginfo_t data)");
14200 return _("NT_FILE (mapped files)");
14208 return _("NT_VERSION (version)");
14210 return _("NT_ARCH (architecture)");
14215 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14220 print_core_note (Elf_Internal_Note *pnote)
14222 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14223 bfd_vma count, page_size;
14224 unsigned char *descdata, *filenames, *descend;
14226 if (pnote->type != NT_FILE)
14232 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14233 /* Still "successful". */
14238 if (pnote->descsz < 2 * addr_size)
14240 printf (_(" Malformed note - too short for header\n"));
14244 descdata = (unsigned char *) pnote->descdata;
14245 descend = descdata + pnote->descsz;
14247 if (descdata[pnote->descsz - 1] != '\0')
14249 printf (_(" Malformed note - does not end with \\0\n"));
14253 count = byte_get (descdata, addr_size);
14254 descdata += addr_size;
14256 page_size = byte_get (descdata, addr_size);
14257 descdata += addr_size;
14259 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14261 printf (_(" Malformed note - too short for supplied file count\n"));
14265 printf (_(" Page size: "));
14266 print_vma (page_size, DEC);
14269 printf (_(" %*s%*s%*s\n"),
14270 (int) (2 + 2 * addr_size), _("Start"),
14271 (int) (4 + 2 * addr_size), _("End"),
14272 (int) (4 + 2 * addr_size), _("Page Offset"));
14273 filenames = descdata + count * 3 * addr_size;
14274 while (--count > 0)
14276 bfd_vma start, end, file_ofs;
14278 if (filenames == descend)
14280 printf (_(" Malformed note - filenames end too early\n"));
14284 start = byte_get (descdata, addr_size);
14285 descdata += addr_size;
14286 end = byte_get (descdata, addr_size);
14287 descdata += addr_size;
14288 file_ofs = byte_get (descdata, addr_size);
14289 descdata += addr_size;
14292 print_vma (start, FULL_HEX);
14294 print_vma (end, FULL_HEX);
14296 print_vma (file_ofs, FULL_HEX);
14297 printf ("\n %s\n", filenames);
14299 filenames += 1 + strlen ((char *) filenames);
14305 static const char *
14306 get_gnu_elf_note_type (unsigned e_type)
14308 static char buff[64];
14312 case NT_GNU_ABI_TAG:
14313 return _("NT_GNU_ABI_TAG (ABI version tag)");
14315 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14316 case NT_GNU_BUILD_ID:
14317 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14318 case NT_GNU_GOLD_VERSION:
14319 return _("NT_GNU_GOLD_VERSION (gold version)");
14324 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14329 print_gnu_note (Elf_Internal_Note *pnote)
14331 switch (pnote->type)
14333 case NT_GNU_BUILD_ID:
14337 printf (_(" Build ID: "));
14338 for (i = 0; i < pnote->descsz; ++i)
14339 printf ("%02x", pnote->descdata[i] & 0xff);
14344 case NT_GNU_ABI_TAG:
14346 unsigned long os, major, minor, subminor;
14347 const char *osname;
14349 /* PR 17531: file: 030-599401-0.004. */
14350 if (pnote->descsz < 16)
14352 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14356 os = byte_get ((unsigned char *) pnote->descdata, 4);
14357 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14358 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14359 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14363 case GNU_ABI_TAG_LINUX:
14366 case GNU_ABI_TAG_HURD:
14369 case GNU_ABI_TAG_SOLARIS:
14370 osname = "Solaris";
14372 case GNU_ABI_TAG_FREEBSD:
14373 osname = "FreeBSD";
14375 case GNU_ABI_TAG_NETBSD:
14379 osname = "Unknown";
14383 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14384 major, minor, subminor);
14388 case NT_GNU_GOLD_VERSION:
14392 printf (_(" Version: "));
14393 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14394 printf ("%c", pnote->descdata[i]);
14403 static const char *
14404 get_netbsd_elfcore_note_type (unsigned e_type)
14406 static char buff[64];
14408 if (e_type == NT_NETBSDCORE_PROCINFO)
14410 /* NetBSD core "procinfo" structure. */
14411 return _("NetBSD procinfo structure");
14414 /* As of Jan 2002 there are no other machine-independent notes
14415 defined for NetBSD core files. If the note type is less
14416 than the start of the machine-dependent note types, we don't
14419 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14421 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14425 switch (elf_header.e_machine)
14427 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14428 and PT_GETFPREGS == mach+2. */
14433 case EM_SPARC32PLUS:
14437 case NT_NETBSDCORE_FIRSTMACH + 0:
14438 return _("PT_GETREGS (reg structure)");
14439 case NT_NETBSDCORE_FIRSTMACH + 2:
14440 return _("PT_GETFPREGS (fpreg structure)");
14446 /* On all other arch's, PT_GETREGS == mach+1 and
14447 PT_GETFPREGS == mach+3. */
14451 case NT_NETBSDCORE_FIRSTMACH + 1:
14452 return _("PT_GETREGS (reg structure)");
14453 case NT_NETBSDCORE_FIRSTMACH + 3:
14454 return _("PT_GETFPREGS (fpreg structure)");
14460 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14461 e_type - NT_NETBSDCORE_FIRSTMACH);
14465 static const char *
14466 get_stapsdt_note_type (unsigned e_type)
14468 static char buff[64];
14473 return _("NT_STAPSDT (SystemTap probe descriptors)");
14479 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14484 print_stapsdt_note (Elf_Internal_Note *pnote)
14486 int addr_size = is_32bit_elf ? 4 : 8;
14487 char *data = pnote->descdata;
14488 char *data_end = pnote->descdata + pnote->descsz;
14489 bfd_vma pc, base_addr, semaphore;
14490 char *provider, *probe, *arg_fmt;
14492 pc = byte_get ((unsigned char *) data, addr_size);
14494 base_addr = byte_get ((unsigned char *) data, addr_size);
14496 semaphore = byte_get ((unsigned char *) data, addr_size);
14500 data += strlen (data) + 1;
14502 data += strlen (data) + 1;
14504 data += strlen (data) + 1;
14506 printf (_(" Provider: %s\n"), provider);
14507 printf (_(" Name: %s\n"), probe);
14508 printf (_(" Location: "));
14509 print_vma (pc, FULL_HEX);
14510 printf (_(", Base: "));
14511 print_vma (base_addr, FULL_HEX);
14512 printf (_(", Semaphore: "));
14513 print_vma (semaphore, FULL_HEX);
14515 printf (_(" Arguments: %s\n"), arg_fmt);
14517 return data == data_end;
14520 static const char *
14521 get_ia64_vms_note_type (unsigned e_type)
14523 static char buff[64];
14528 return _("NT_VMS_MHD (module header)");
14530 return _("NT_VMS_LNM (language name)");
14532 return _("NT_VMS_SRC (source files)");
14534 return "NT_VMS_TITLE";
14536 return _("NT_VMS_EIDC (consistency check)");
14537 case NT_VMS_FPMODE:
14538 return _("NT_VMS_FPMODE (FP mode)");
14539 case NT_VMS_LINKTIME:
14540 return "NT_VMS_LINKTIME";
14541 case NT_VMS_IMGNAM:
14542 return _("NT_VMS_IMGNAM (image name)");
14544 return _("NT_VMS_IMGID (image id)");
14545 case NT_VMS_LINKID:
14546 return _("NT_VMS_LINKID (link id)");
14547 case NT_VMS_IMGBID:
14548 return _("NT_VMS_IMGBID (build id)");
14549 case NT_VMS_GSTNAM:
14550 return _("NT_VMS_GSTNAM (sym table name)");
14551 case NT_VMS_ORIG_DYN:
14552 return "NT_VMS_ORIG_DYN";
14553 case NT_VMS_PATCHTIME:
14554 return "NT_VMS_PATCHTIME";
14556 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14562 print_ia64_vms_note (Elf_Internal_Note * pnote)
14564 switch (pnote->type)
14567 if (pnote->descsz > 36)
14569 size_t l = strlen (pnote->descdata + 34);
14570 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14571 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14572 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14573 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14576 printf (_(" Invalid size\n"));
14579 printf (_(" Language: %s\n"), pnote->descdata);
14582 case NT_VMS_FPMODE:
14583 printf (_(" Floating Point mode: "));
14584 printf ("0x%016" BFD_VMA_FMT "x\n",
14585 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14587 case NT_VMS_LINKTIME:
14588 printf (_(" Link time: "));
14590 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14593 case NT_VMS_PATCHTIME:
14594 printf (_(" Patch time: "));
14596 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14599 case NT_VMS_ORIG_DYN:
14600 printf (_(" Major id: %u, minor id: %u\n"),
14601 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14602 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14603 printf (_(" Last modified : "));
14605 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14606 printf (_("\n Link flags : "));
14607 printf ("0x%016" BFD_VMA_FMT "x\n",
14608 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14609 printf (_(" Header flags: 0x%08x\n"),
14610 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14611 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14614 case NT_VMS_IMGNAM:
14615 printf (_(" Image name: %s\n"), pnote->descdata);
14617 case NT_VMS_GSTNAM:
14618 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14621 printf (_(" Image id: %s\n"), pnote->descdata);
14623 case NT_VMS_LINKID:
14624 printf (_(" Linker id: %s\n"), pnote->descdata);
14632 /* Note that by the ELF standard, the name field is already null byte
14633 terminated, and namesz includes the terminating null byte.
14634 I.E. the value of namesz for the name "FSF" is 4.
14636 If the value of namesz is zero, there is no name present. */
14638 process_note (Elf_Internal_Note * pnote)
14640 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14643 if (pnote->namesz == 0)
14644 /* If there is no note name, then use the default set of
14645 note type strings. */
14646 nt = get_note_type (pnote->type);
14648 else if (const_strneq (pnote->namedata, "GNU"))
14649 /* GNU-specific object file notes. */
14650 nt = get_gnu_elf_note_type (pnote->type);
14652 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14653 /* NetBSD-specific core file notes. */
14654 nt = get_netbsd_elfcore_note_type (pnote->type);
14656 else if (strneq (pnote->namedata, "SPU/", 4))
14658 /* SPU-specific core file notes. */
14659 nt = pnote->namedata + 4;
14663 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14664 /* VMS/ia64-specific file notes. */
14665 nt = get_ia64_vms_note_type (pnote->type);
14667 else if (const_strneq (pnote->namedata, "stapsdt"))
14668 nt = get_stapsdt_note_type (pnote->type);
14671 /* Don't recognize this note name; just use the default set of
14672 note type strings. */
14673 nt = get_note_type (pnote->type);
14675 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
14677 if (const_strneq (pnote->namedata, "IPF/VMS"))
14678 return print_ia64_vms_note (pnote);
14679 else if (const_strneq (pnote->namedata, "GNU"))
14680 return print_gnu_note (pnote);
14681 else if (const_strneq (pnote->namedata, "stapsdt"))
14682 return print_stapsdt_note (pnote);
14683 else if (const_strneq (pnote->namedata, "CORE"))
14684 return print_core_note (pnote);
14691 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
14693 Elf_External_Note * pnotes;
14694 Elf_External_Note * external;
14700 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
14702 if (pnotes == NULL)
14707 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14708 (unsigned long) offset, (unsigned long) length);
14709 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14711 while ((char *) external < (char *) pnotes + length)
14713 Elf_Internal_Note inote;
14716 char * temp = NULL;
14717 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
14719 if (!is_ia64_vms ())
14721 /* PR binutils/15191
14722 Make sure that there is enough data to read. */
14723 min_notesz = offsetof (Elf_External_Note, name);
14724 if (data_remaining < min_notesz)
14726 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14727 (int) data_remaining);
14730 inote.type = BYTE_GET (external->type);
14731 inote.namesz = BYTE_GET (external->namesz);
14732 inote.namedata = external->name;
14733 inote.descsz = BYTE_GET (external->descsz);
14734 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
14735 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14736 next = inote.descdata + align_power (inote.descsz, 2);
14740 Elf64_External_VMS_Note *vms_external;
14742 /* PR binutils/15191
14743 Make sure that there is enough data to read. */
14744 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14745 if (data_remaining < min_notesz)
14747 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14748 (int) data_remaining);
14752 vms_external = (Elf64_External_VMS_Note *) external;
14753 inote.type = BYTE_GET (vms_external->type);
14754 inote.namesz = BYTE_GET (vms_external->namesz);
14755 inote.namedata = vms_external->name;
14756 inote.descsz = BYTE_GET (vms_external->descsz);
14757 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14758 inote.descpos = offset + (inote.descdata - (char *) pnotes);
14759 next = inote.descdata + align_power (inote.descsz, 3);
14762 if (inote.descdata < (char *) external + min_notesz
14763 || next < (char *) external + min_notesz
14764 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14765 || inote.namedata + inote.namesz < inote.namedata
14766 || inote.descdata + inote.descsz < inote.descdata
14767 || data_remaining < (size_t)(next - (char *) external))
14769 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14770 (unsigned long) ((char *) external - (char *) pnotes));
14771 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14772 inote.type, inote.namesz, inote.descsz);
14776 external = (Elf_External_Note *) next;
14778 /* Verify that name is null terminated. It appears that at least
14779 one version of Linux (RedHat 6.0) generates corefiles that don't
14780 comply with the ELF spec by failing to include the null byte in
14782 if (inote.namedata[inote.namesz - 1] != '\0')
14784 temp = (char *) malloc (inote.namesz + 1);
14787 error (_("Out of memory allocating space for inote name\n"));
14792 strncpy (temp, inote.namedata, inote.namesz);
14793 temp[inote.namesz] = 0;
14795 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14796 inote.namedata = temp;
14799 res &= process_note (& inote);
14814 process_corefile_note_segments (FILE * file)
14816 Elf_Internal_Phdr * segment;
14820 if (! get_program_headers (file))
14823 for (i = 0, segment = program_headers;
14824 i < elf_header.e_phnum;
14827 if (segment->p_type == PT_NOTE)
14828 res &= process_corefile_note_segment (file,
14829 (bfd_vma) segment->p_offset,
14830 (bfd_vma) segment->p_filesz);
14837 process_note_sections (FILE * file)
14839 Elf_Internal_Shdr * section;
14844 for (i = 0, section = section_headers;
14845 i < elf_header.e_shnum && section != NULL;
14847 if (section->sh_type == SHT_NOTE)
14849 res &= process_corefile_note_segment (file,
14850 (bfd_vma) section->sh_offset,
14851 (bfd_vma) section->sh_size);
14856 /* Try processing NOTE segments instead. */
14857 return process_corefile_note_segments (file);
14863 process_notes (FILE * file)
14865 /* If we have not been asked to display the notes then do nothing. */
14869 if (elf_header.e_type != ET_CORE)
14870 return process_note_sections (file);
14872 /* No program headers means no NOTE segment. */
14873 if (elf_header.e_phnum > 0)
14874 return process_corefile_note_segments (file);
14876 printf (_("No note segments present in the core file.\n"));
14881 process_arch_specific (FILE * file)
14886 switch (elf_header.e_machine)
14889 return process_arm_specific (file);
14891 case EM_MIPS_RS3_LE:
14892 return process_mips_specific (file);
14895 return process_nds32_specific (file);
14898 return process_power_specific (file);
14901 case EM_SPARC32PLUS:
14903 return process_sparc_specific (file);
14906 return process_tic6x_specific (file);
14909 return process_msp430x_specific (file);
14917 get_file_header (FILE * file)
14919 /* Read in the identity array. */
14920 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14923 /* Determine how to read the rest of the header. */
14924 switch (elf_header.e_ident[EI_DATA])
14926 default: /* fall through */
14927 case ELFDATANONE: /* fall through */
14929 byte_get = byte_get_little_endian;
14930 byte_put = byte_put_little_endian;
14933 byte_get = byte_get_big_endian;
14934 byte_put = byte_put_big_endian;
14938 /* For now we only support 32 bit and 64 bit ELF files. */
14939 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14941 /* Read in the rest of the header. */
14944 Elf32_External_Ehdr ehdr32;
14946 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14949 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14950 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14951 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14952 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14953 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14954 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14955 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14956 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14957 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14958 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14959 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14960 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14961 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14965 Elf64_External_Ehdr ehdr64;
14967 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14968 we will not be able to cope with the 64bit data found in
14969 64 ELF files. Detect this now and abort before we start
14970 overwriting things. */
14971 if (sizeof (bfd_vma) < 8)
14973 error (_("This instance of readelf has been built without support for a\n\
14974 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14978 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14981 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14982 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14983 elf_header.e_version = BYTE_GET (ehdr64.e_version);
14984 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14985 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14986 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
14987 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14988 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14989 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14990 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14991 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14992 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14993 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14996 if (elf_header.e_shoff)
14998 /* There may be some extensions in the first section header. Don't
14999 bomb if we can't read it. */
15001 get_32bit_section_headers (file, TRUE);
15003 get_64bit_section_headers (file, TRUE);
15009 /* Process one ELF object file according to the command line options.
15010 This file may actually be stored in an archive. The file is
15011 positioned at the start of the ELF object. */
15014 process_object (char * file_name, FILE * file)
15018 if (! get_file_header (file))
15020 error (_("%s: Failed to read file header\n"), file_name);
15024 /* Initialise per file variables. */
15025 for (i = ARRAY_SIZE (version_info); i--;)
15026 version_info[i] = 0;
15028 for (i = ARRAY_SIZE (dynamic_info); i--;)
15029 dynamic_info[i] = 0;
15030 dynamic_info_DT_GNU_HASH = 0;
15032 /* Process the file. */
15034 printf (_("\nFile: %s\n"), file_name);
15036 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15037 Note we do this even if cmdline_dump_sects is empty because we
15038 must make sure that the dump_sets array is zeroed out before each
15039 object file is processed. */
15040 if (num_dump_sects > num_cmdline_dump_sects)
15041 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15043 if (num_cmdline_dump_sects > 0)
15045 if (num_dump_sects == 0)
15046 /* A sneaky way of allocating the dump_sects array. */
15047 request_dump_bynumber (num_cmdline_dump_sects, 0);
15049 assert (num_dump_sects >= num_cmdline_dump_sects);
15050 memcpy (dump_sects, cmdline_dump_sects,
15051 num_cmdline_dump_sects * sizeof (* dump_sects));
15054 if (! process_file_header ())
15057 if (! process_section_headers (file))
15059 /* Without loaded section headers we cannot process lots of
15061 do_unwind = do_version = do_dump = do_arch = 0;
15063 if (! do_using_dynamic)
15064 do_syms = do_dyn_syms = do_reloc = 0;
15067 if (! process_section_groups (file))
15069 /* Without loaded section groups we cannot process unwind. */
15073 if (process_program_headers (file))
15074 process_dynamic_section (file);
15076 process_relocs (file);
15078 process_unwind (file);
15080 process_symbol_table (file);
15082 process_syminfo (file);
15084 process_version_sections (file);
15086 process_section_contents (file);
15088 process_notes (file);
15090 process_gnu_liblist (file);
15092 process_arch_specific (file);
15094 if (program_headers)
15096 free (program_headers);
15097 program_headers = NULL;
15100 if (section_headers)
15102 free (section_headers);
15103 section_headers = NULL;
15108 free (string_table);
15109 string_table = NULL;
15110 string_table_length = 0;
15113 if (dynamic_strings)
15115 free (dynamic_strings);
15116 dynamic_strings = NULL;
15117 dynamic_strings_length = 0;
15120 if (dynamic_symbols)
15122 free (dynamic_symbols);
15123 dynamic_symbols = NULL;
15124 num_dynamic_syms = 0;
15127 if (dynamic_syminfo)
15129 free (dynamic_syminfo);
15130 dynamic_syminfo = NULL;
15133 if (dynamic_section)
15135 free (dynamic_section);
15136 dynamic_section = NULL;
15139 if (section_headers_groups)
15141 free (section_headers_groups);
15142 section_headers_groups = NULL;
15145 if (section_groups)
15147 struct group_list * g;
15148 struct group_list * next;
15150 for (i = 0; i < group_count; i++)
15152 for (g = section_groups [i].root; g != NULL; g = next)
15159 free (section_groups);
15160 section_groups = NULL;
15163 free_debug_memory ();
15168 /* Process an ELF archive.
15169 On entry the file is positioned just after the ARMAG string. */
15172 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15174 struct archive_info arch;
15175 struct archive_info nested_arch;
15181 /* The ARCH structure is used to hold information about this archive. */
15182 arch.file_name = NULL;
15184 arch.index_array = NULL;
15185 arch.sym_table = NULL;
15186 arch.longnames = NULL;
15188 /* The NESTED_ARCH structure is used as a single-item cache of information
15189 about a nested archive (when members of a thin archive reside within
15190 another regular archive file). */
15191 nested_arch.file_name = NULL;
15192 nested_arch.file = NULL;
15193 nested_arch.index_array = NULL;
15194 nested_arch.sym_table = NULL;
15195 nested_arch.longnames = NULL;
15197 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15203 if (do_archive_index)
15205 if (arch.sym_table == NULL)
15206 error (_("%s: unable to dump the index as none was found\n"), file_name);
15210 unsigned long current_pos;
15212 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
15213 file_name, (long) arch.index_num, arch.sym_size);
15214 current_pos = ftell (file);
15216 for (i = l = 0; i < arch.index_num; i++)
15218 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15220 char * member_name;
15222 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15224 if (member_name != NULL)
15226 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15228 if (qualified_name != NULL)
15230 printf (_("Contents of binary %s at offset "), qualified_name);
15231 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15233 free (qualified_name);
15238 if (l >= arch.sym_size)
15240 error (_("%s: end of the symbol table reached before the end of the index\n"),
15244 printf ("\t%s\n", arch.sym_table + l);
15245 l += strlen (arch.sym_table + l) + 1;
15248 if (arch.uses_64bit_indicies)
15253 if (l < arch.sym_size)
15254 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15255 file_name, arch.sym_size - l);
15257 if (fseek (file, current_pos, SEEK_SET) != 0)
15259 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15265 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15266 && !do_segments && !do_header && !do_dump && !do_version
15267 && !do_histogram && !do_debugging && !do_arch && !do_notes
15268 && !do_section_groups && !do_dyn_syms)
15270 ret = 0; /* Archive index only. */
15281 char * qualified_name;
15283 /* Read the next archive header. */
15284 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15286 error (_("%s: failed to seek to next archive header\n"), file_name);
15289 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15290 if (got != sizeof arch.arhdr)
15294 error (_("%s: failed to read archive header\n"), file_name);
15298 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15300 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15305 arch.next_arhdr_offset += sizeof arch.arhdr;
15307 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15308 if (archive_file_size & 01)
15309 ++archive_file_size;
15311 name = get_archive_member_name (&arch, &nested_arch);
15314 error (_("%s: bad archive file name\n"), file_name);
15318 namelen = strlen (name);
15320 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15321 if (qualified_name == NULL)
15323 error (_("%s: bad archive file name\n"), file_name);
15328 if (is_thin_archive && arch.nested_member_origin == 0)
15330 /* This is a proxy for an external member of a thin archive. */
15331 FILE * member_file;
15332 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15333 if (member_file_name == NULL)
15339 member_file = fopen (member_file_name, "rb");
15340 if (member_file == NULL)
15342 error (_("Input file '%s' is not readable.\n"), member_file_name);
15343 free (member_file_name);
15348 archive_file_offset = arch.nested_member_origin;
15350 ret |= process_object (qualified_name, member_file);
15352 fclose (member_file);
15353 free (member_file_name);
15355 else if (is_thin_archive)
15357 /* PR 15140: Allow for corrupt thin archives. */
15358 if (nested_arch.file == NULL)
15360 error (_("%s: contains corrupt thin archive: %s\n"),
15366 /* This is a proxy for a member of a nested archive. */
15367 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15369 /* The nested archive file will have been opened and setup by
15370 get_archive_member_name. */
15371 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15373 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15378 ret |= process_object (qualified_name, nested_arch.file);
15382 archive_file_offset = arch.next_arhdr_offset;
15383 arch.next_arhdr_offset += archive_file_size;
15385 ret |= process_object (qualified_name, file);
15388 if (dump_sects != NULL)
15392 num_dump_sects = 0;
15395 free (qualified_name);
15399 if (nested_arch.file != NULL)
15400 fclose (nested_arch.file);
15401 release_archive (&nested_arch);
15402 release_archive (&arch);
15408 process_file (char * file_name)
15411 struct stat statbuf;
15412 char armag[SARMAG];
15415 if (stat (file_name, &statbuf) < 0)
15417 if (errno == ENOENT)
15418 error (_("'%s': No such file\n"), file_name);
15420 error (_("Could not locate '%s'. System error message: %s\n"),
15421 file_name, strerror (errno));
15425 if (! S_ISREG (statbuf.st_mode))
15427 error (_("'%s' is not an ordinary file\n"), file_name);
15431 file = fopen (file_name, "rb");
15434 error (_("Input file '%s' is not readable.\n"), file_name);
15438 if (fread (armag, SARMAG, 1, file) != 1)
15440 error (_("%s: Failed to read file's magic number\n"), file_name);
15445 current_file_size = (bfd_size_type) statbuf.st_size;
15447 if (memcmp (armag, ARMAG, SARMAG) == 0)
15448 ret = process_archive (file_name, file, FALSE);
15449 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15450 ret = process_archive (file_name, file, TRUE);
15453 if (do_archive_index)
15454 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15458 archive_file_size = archive_file_offset = 0;
15459 ret = process_object (file_name, file);
15464 current_file_size = 0;
15468 #ifdef SUPPORT_DISASSEMBLY
15469 /* Needed by the i386 disassembler. For extra credit, someone could
15470 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15474 print_address (unsigned int addr, FILE * outfile)
15476 fprintf (outfile,"0x%8.8x", addr);
15479 /* Needed by the i386 disassembler. */
15481 db_task_printsym (unsigned int addr)
15483 print_address (addr, stderr);
15488 main (int argc, char ** argv)
15492 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15493 setlocale (LC_MESSAGES, "");
15495 #if defined (HAVE_SETLOCALE)
15496 setlocale (LC_CTYPE, "");
15498 bindtextdomain (PACKAGE, LOCALEDIR);
15499 textdomain (PACKAGE);
15501 expandargv (&argc, &argv);
15503 parse_args (argc, argv);
15505 if (num_dump_sects > 0)
15507 /* Make a copy of the dump_sects array. */
15508 cmdline_dump_sects = (dump_type *)
15509 malloc (num_dump_sects * sizeof (* dump_sects));
15510 if (cmdline_dump_sects == NULL)
15511 error (_("Out of memory allocating dump request table.\n"));
15514 memcpy (cmdline_dump_sects, dump_sects,
15515 num_dump_sects * sizeof (* dump_sects));
15516 num_cmdline_dump_sects = num_dump_sects;
15520 if (optind < (argc - 1))
15524 while (optind < argc)
15525 err |= process_file (argv[optind++]);
15527 if (dump_sects != NULL)
15529 if (cmdline_dump_sects != NULL)
15530 free (cmdline_dump_sects);