1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/epiphany.h"
106 #include "elf/fr30.h"
108 #include "elf/ft32.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/visium.h"
153 #include "elf/x86-64.h"
154 #include "elf/xc16x.h"
155 #include "elf/xgate.h"
156 #include "elf/xstormy16.h"
157 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
162 #include "filenames.h"
165 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168 typedef struct elf_section_list
170 Elf_Internal_Shdr * hdr;
171 struct elf_section_list * next;
174 char * program_name = "readelf";
175 static unsigned long archive_file_offset;
176 static unsigned long archive_file_size;
177 static bfd_size_type current_file_size;
178 static unsigned long dynamic_addr;
179 static bfd_size_type dynamic_size;
180 static size_t dynamic_nent;
181 static char * dynamic_strings;
182 static unsigned long dynamic_strings_length;
183 static char * string_table;
184 static unsigned long string_table_length;
185 static unsigned long num_dynamic_syms;
186 static Elf_Internal_Sym * dynamic_symbols;
187 static Elf_Internal_Syminfo * dynamic_syminfo;
188 static unsigned long dynamic_syminfo_offset;
189 static unsigned int dynamic_syminfo_nent;
190 static char program_interpreter[PATH_MAX];
191 static bfd_vma dynamic_info[DT_ENCODING];
192 static bfd_vma dynamic_info_DT_GNU_HASH;
193 static bfd_vma version_info[16];
194 static Elf_Internal_Ehdr elf_header;
195 static Elf_Internal_Shdr * section_headers;
196 static Elf_Internal_Phdr * program_headers;
197 static Elf_Internal_Dyn * dynamic_section;
198 static elf_section_list * symtab_shndx_list;
199 static int show_name;
200 static int do_dynamic;
202 static int do_dyn_syms;
204 static int do_sections;
205 static int do_section_groups;
206 static int do_section_details;
207 static int do_segments;
208 static int do_unwind;
209 static int do_using_dynamic;
210 static int do_header;
212 static int do_version;
213 static int do_histogram;
214 static int do_debugging;
217 static int do_archive_index;
218 static int is_32bit_elf;
219 static int decompress_dumps;
223 struct group_list * next;
224 unsigned int section_index;
229 struct group_list * root;
230 unsigned int group_index;
233 static size_t group_count;
234 static struct group * section_groups;
235 static struct group ** section_headers_groups;
238 /* Flag bits indicating particular types of dump. */
239 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
240 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
241 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
242 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
243 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
245 typedef unsigned char dump_type;
247 /* A linked list of the section names for which dumps were requested. */
248 struct dump_list_entry
252 struct dump_list_entry * next;
254 static struct dump_list_entry * dump_sects_byname;
256 /* A dynamic array of flags indicating for which sections a dump
257 has been requested via command line switches. */
258 static dump_type * cmdline_dump_sects = NULL;
259 static unsigned int num_cmdline_dump_sects = 0;
261 /* A dynamic array of flags indicating for which sections a dump of
262 some kind has been requested. It is reset on a per-object file
263 basis and then initialised from the cmdline_dump_sects array,
264 the results of interpreting the -w switch, and the
265 dump_sects_byname list. */
266 static dump_type * dump_sects = NULL;
267 static unsigned int num_dump_sects = 0;
270 /* How to print a vma value. */
271 typedef enum print_mode
283 /* Versioned symbol info. */
284 enum versioned_symbol_info
291 static const char * get_symbol_version_string
292 (FILE *file, int is_dynsym, const char *strtab,
293 unsigned long int strtab_size, unsigned int si,
294 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
295 unsigned short *vna_other);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
334 bfd_size_type nmemb, const char * reason)
337 bfd_size_type amt = size * nmemb;
339 if (size == 0 || nmemb == 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type)
346 && ( (bfd_size_type) ((size_t) size) != size
347 || (bfd_size_type) ((size_t) nmemb) != nmemb))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
351 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
352 nmemb, size, reason);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
361 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
362 nmemb, size, reason);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt > current_file_size
369 || offset + archive_file_offset + amt > current_file_size)
372 error (_("Reading 0x%" BFD_VMA_FMT "x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file, archive_file_offset + offset, SEEK_SET))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset + offset, reason);
389 /* Check for overflow. */
390 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar = malloc ((size_t) amt + 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
403 ((char *) mvar)[amt] = '\0';
406 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
419 /* Print a VMA value. */
422 print_vma (bfd_vma vma, print_mode mode)
435 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
442 return printf ("%5" BFD_VMA_FMT "d", vma);
450 return nc + printf ("%" BFD_VMA_FMT "x", vma);
453 return printf ("%" BFD_VMA_FMT "d", vma);
456 return printf ("%" BFD_VMA_FMT "u", vma);
461 /* Display a symbol on stdout. Handles the display of control characters and
462 multibye characters (assuming the host environment supports them).
464 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
466 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
467 padding as necessary.
469 Returns the number of emitted characters. */
472 print_symbol (int width, const char *symbol)
474 bfd_boolean extra_padding = FALSE;
476 #ifdef HAVE_MBSTATE_T
483 /* Keep the width positive. This helps the code below. */
485 extra_padding = TRUE;
490 /* Set the remaining width to a very large value.
491 This simplifies the code below. */
492 width_remaining = INT_MAX;
494 width_remaining = width;
496 #ifdef HAVE_MBSTATE_T
497 /* Initialise the multibyte conversion state. */
498 memset (& state, 0, sizeof (state));
501 while (width_remaining)
504 const char c = *symbol++;
509 /* Do not print control characters directly as they can affect terminal
510 settings. Such characters usually appear in the names generated
511 by the assembler for local labels. */
514 if (width_remaining < 2)
517 printf ("^%c", c + 0x40);
518 width_remaining -= 2;
521 else if (ISPRINT (c))
529 #ifdef HAVE_MBSTATE_T
532 /* Let printf do the hard work of displaying multibyte characters. */
533 printf ("%.1s", symbol - 1);
537 #ifdef HAVE_MBSTATE_T
538 /* Try to find out how many bytes made up the character that was
539 just printed. Advance the symbol pointer past the bytes that
541 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
545 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
550 if (extra_padding && num_printed < width)
552 /* Fill in the remaining spaces. */
553 printf ("%-*s", width - num_printed, " ");
560 /* Returns a pointer to a static buffer containing a printable version of
561 the given section's name. Like print_symbol, except that it does not try
562 to print multibyte characters, it just interprets them as hex values. */
565 printable_section_name (const Elf_Internal_Shdr * sec)
567 #define MAX_PRINT_SEC_NAME_LEN 128
568 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
569 const char * name = SECTION_NAME (sec);
570 char * buf = sec_name_buf;
572 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
574 while ((c = * name ++) != 0)
585 else if (ISPRINT (c))
592 static char hex[17] = "0123456789ABCDEF";
597 * buf ++ = hex[(c & 0xf0) >> 4];
598 * buf ++ = hex[c & 0x0f];
612 printable_section_name_from_index (unsigned long ndx)
614 if (ndx >= elf_header.e_shnum)
615 return _("<corrupt>");
617 return printable_section_name (section_headers + ndx);
620 /* Return a pointer to section NAME, or NULL if no such section exists. */
622 static Elf_Internal_Shdr *
623 find_section (const char * name)
627 for (i = 0; i < elf_header.e_shnum; i++)
628 if (streq (SECTION_NAME (section_headers + i), name))
629 return section_headers + i;
634 /* Return a pointer to a section containing ADDR, or NULL if no such
637 static Elf_Internal_Shdr *
638 find_section_by_address (bfd_vma addr)
642 for (i = 0; i < elf_header.e_shnum; i++)
644 Elf_Internal_Shdr *sec = section_headers + i;
645 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
652 static Elf_Internal_Shdr *
653 find_section_by_type (unsigned int type)
657 for (i = 0; i < elf_header.e_shnum; i++)
659 Elf_Internal_Shdr *sec = section_headers + i;
660 if (sec->sh_type == type)
667 /* Return a pointer to section NAME, or NULL if no such section exists,
668 restricted to the list of sections given in SET. */
670 static Elf_Internal_Shdr *
671 find_section_in_set (const char * name, unsigned int * set)
677 while ((i = *set++) > 0)
678 if (streq (SECTION_NAME (section_headers + i), name))
679 return section_headers + i;
682 return find_section (name);
685 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
688 static inline unsigned long
689 read_uleb128 (unsigned char *data,
690 unsigned int *length_return,
691 const unsigned char * const end)
693 return read_leb128 (data, length_return, FALSE, end);
696 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
697 This OS has so many departures from the ELF standard that we test it at
703 return elf_header.e_machine == EM_IA_64
704 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
707 /* Guess the relocation size commonly used by the specific machines. */
710 guess_is_rela (unsigned int e_machine)
714 /* Targets that use REL relocations. */
729 /* Targets that use RELA relocations. */
733 case EM_ADAPTEVA_EPIPHANY:
735 case EM_ALTERA_NIOS2:
738 case EM_ARC_COMPACT2:
758 case EM_LATTICEMICO32:
767 case EM_CYGNUS_MN10200:
769 case EM_CYGNUS_MN10300:
803 case EM_MICROBLAZE_OLD:
824 warn (_("Don't know about relocations on this machine architecture\n"));
830 slurp_rela_relocs (FILE * file,
831 unsigned long rel_offset,
832 unsigned long rel_size,
833 Elf_Internal_Rela ** relasp,
834 unsigned long * nrelasp)
836 Elf_Internal_Rela * relas;
842 Elf32_External_Rela * erelas;
844 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
845 rel_size, _("32-bit relocation data"));
849 nrelas = rel_size / sizeof (Elf32_External_Rela);
851 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
852 sizeof (Elf_Internal_Rela));
857 error (_("out of memory parsing relocs\n"));
861 for (i = 0; i < nrelas; i++)
863 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
864 relas[i].r_info = BYTE_GET (erelas[i].r_info);
865 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
872 Elf64_External_Rela * erelas;
874 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
875 rel_size, _("64-bit relocation data"));
879 nrelas = rel_size / sizeof (Elf64_External_Rela);
881 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
882 sizeof (Elf_Internal_Rela));
887 error (_("out of memory parsing relocs\n"));
891 for (i = 0; i < nrelas; i++)
893 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
894 relas[i].r_info = BYTE_GET (erelas[i].r_info);
895 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
897 /* The #ifdef BFD64 below is to prevent a compile time
898 warning. We know that if we do not have a 64 bit data
899 type that we will never execute this code anyway. */
901 if (elf_header.e_machine == EM_MIPS
902 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
904 /* In little-endian objects, r_info isn't really a
905 64-bit little-endian value: it has a 32-bit
906 little-endian symbol index followed by four
907 individual byte fields. Reorder INFO
909 bfd_vma inf = relas[i].r_info;
910 inf = (((inf & 0xffffffff) << 32)
911 | ((inf >> 56) & 0xff)
912 | ((inf >> 40) & 0xff00)
913 | ((inf >> 24) & 0xff0000)
914 | ((inf >> 8) & 0xff000000));
915 relas[i].r_info = inf;
928 slurp_rel_relocs (FILE * file,
929 unsigned long rel_offset,
930 unsigned long rel_size,
931 Elf_Internal_Rela ** relsp,
932 unsigned long * nrelsp)
934 Elf_Internal_Rela * rels;
940 Elf32_External_Rel * erels;
942 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
943 rel_size, _("32-bit relocation data"));
947 nrels = rel_size / sizeof (Elf32_External_Rel);
949 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
954 error (_("out of memory parsing relocs\n"));
958 for (i = 0; i < nrels; i++)
960 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
961 rels[i].r_info = BYTE_GET (erels[i].r_info);
962 rels[i].r_addend = 0;
969 Elf64_External_Rel * erels;
971 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
972 rel_size, _("64-bit relocation data"));
976 nrels = rel_size / sizeof (Elf64_External_Rel);
978 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
983 error (_("out of memory parsing relocs\n"));
987 for (i = 0; i < nrels; i++)
989 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
990 rels[i].r_info = BYTE_GET (erels[i].r_info);
991 rels[i].r_addend = 0;
993 /* The #ifdef BFD64 below is to prevent a compile time
994 warning. We know that if we do not have a 64 bit data
995 type that we will never execute this code anyway. */
997 if (elf_header.e_machine == EM_MIPS
998 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1000 /* In little-endian objects, r_info isn't really a
1001 64-bit little-endian value: it has a 32-bit
1002 little-endian symbol index followed by four
1003 individual byte fields. Reorder INFO
1005 bfd_vma inf = rels[i].r_info;
1006 inf = (((inf & 0xffffffff) << 32)
1007 | ((inf >> 56) & 0xff)
1008 | ((inf >> 40) & 0xff00)
1009 | ((inf >> 24) & 0xff0000)
1010 | ((inf >> 8) & 0xff000000));
1011 rels[i].r_info = inf;
1023 /* Returns the reloc type extracted from the reloc info field. */
1026 get_reloc_type (bfd_vma reloc_info)
1029 return ELF32_R_TYPE (reloc_info);
1031 switch (elf_header.e_machine)
1034 /* Note: We assume that reloc_info has already been adjusted for us. */
1035 return ELF64_MIPS_R_TYPE (reloc_info);
1038 return ELF64_R_TYPE_ID (reloc_info);
1041 return ELF64_R_TYPE (reloc_info);
1045 /* Return the symbol index extracted from the reloc info field. */
1048 get_reloc_symindex (bfd_vma reloc_info)
1050 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1053 static inline bfd_boolean
1054 uses_msp430x_relocs (void)
1057 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1058 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1059 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1060 /* TI compiler uses ELFOSABI_NONE. */
1061 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1064 /* Display the contents of the relocation data found at the specified
1068 dump_relocations (FILE * file,
1069 unsigned long rel_offset,
1070 unsigned long rel_size,
1071 Elf_Internal_Sym * symtab,
1072 unsigned long nsyms,
1074 unsigned long strtablen,
1079 Elf_Internal_Rela * rels;
1081 if (is_rela == UNKNOWN)
1082 is_rela = guess_is_rela (elf_header.e_machine);
1086 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1091 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1100 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1102 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1107 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1109 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1117 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1119 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1124 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1126 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1130 for (i = 0; i < rel_size; i++)
1135 bfd_vma symtab_index;
1138 offset = rels[i].r_offset;
1139 inf = rels[i].r_info;
1141 type = get_reloc_type (inf);
1142 symtab_index = get_reloc_symindex (inf);
1146 printf ("%8.8lx %8.8lx ",
1147 (unsigned long) offset & 0xffffffff,
1148 (unsigned long) inf & 0xffffffff);
1152 #if BFD_HOST_64BIT_LONG
1154 ? "%16.16lx %16.16lx "
1155 : "%12.12lx %12.12lx ",
1157 #elif BFD_HOST_64BIT_LONG_LONG
1160 ? "%16.16llx %16.16llx "
1161 : "%12.12llx %12.12llx ",
1165 ? "%16.16I64x %16.16I64x "
1166 : "%12.12I64x %12.12I64x ",
1171 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1172 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1173 _bfd_int64_high (offset),
1174 _bfd_int64_low (offset),
1175 _bfd_int64_high (inf),
1176 _bfd_int64_low (inf));
1180 switch (elf_header.e_machine)
1187 rtype = elf_aarch64_reloc_type (type);
1191 case EM_CYGNUS_M32R:
1192 rtype = elf_m32r_reloc_type (type);
1197 rtype = elf_i386_reloc_type (type);
1202 rtype = elf_m68hc11_reloc_type (type);
1206 rtype = elf_m68k_reloc_type (type);
1210 rtype = elf_i960_reloc_type (type);
1215 rtype = elf_avr_reloc_type (type);
1218 case EM_OLD_SPARCV9:
1219 case EM_SPARC32PLUS:
1222 rtype = elf_sparc_reloc_type (type);
1226 rtype = elf_spu_reloc_type (type);
1230 rtype = v800_reloc_type (type);
1233 case EM_CYGNUS_V850:
1234 rtype = v850_reloc_type (type);
1238 case EM_CYGNUS_D10V:
1239 rtype = elf_d10v_reloc_type (type);
1243 case EM_CYGNUS_D30V:
1244 rtype = elf_d30v_reloc_type (type);
1248 rtype = elf_dlx_reloc_type (type);
1252 rtype = elf_sh_reloc_type (type);
1256 case EM_CYGNUS_MN10300:
1257 rtype = elf_mn10300_reloc_type (type);
1261 case EM_CYGNUS_MN10200:
1262 rtype = elf_mn10200_reloc_type (type);
1266 case EM_CYGNUS_FR30:
1267 rtype = elf_fr30_reloc_type (type);
1271 rtype = elf_frv_reloc_type (type);
1275 rtype = elf_ft32_reloc_type (type);
1279 rtype = elf_mcore_reloc_type (type);
1283 rtype = elf_mmix_reloc_type (type);
1287 rtype = elf_moxie_reloc_type (type);
1291 if (uses_msp430x_relocs ())
1293 rtype = elf_msp430x_reloc_type (type);
1297 rtype = elf_msp430_reloc_type (type);
1301 rtype = elf_nds32_reloc_type (type);
1305 rtype = elf_ppc_reloc_type (type);
1309 rtype = elf_ppc64_reloc_type (type);
1313 case EM_MIPS_RS3_LE:
1314 rtype = elf_mips_reloc_type (type);
1318 rtype = elf_alpha_reloc_type (type);
1322 rtype = elf_arm_reloc_type (type);
1326 case EM_ARC_COMPACT:
1327 case EM_ARC_COMPACT2:
1328 rtype = elf_arc_reloc_type (type);
1332 rtype = elf_hppa_reloc_type (type);
1338 rtype = elf_h8_reloc_type (type);
1342 rtype = elf_or1k_reloc_type (type);
1347 rtype = elf_pj_reloc_type (type);
1350 rtype = elf_ia64_reloc_type (type);
1354 rtype = elf_cris_reloc_type (type);
1358 rtype = elf_i860_reloc_type (type);
1364 rtype = elf_x86_64_reloc_type (type);
1368 rtype = i370_reloc_type (type);
1373 rtype = elf_s390_reloc_type (type);
1377 rtype = elf_score_reloc_type (type);
1381 rtype = elf_xstormy16_reloc_type (type);
1385 rtype = elf_crx_reloc_type (type);
1389 rtype = elf_vax_reloc_type (type);
1393 rtype = elf_visium_reloc_type (type);
1396 case EM_ADAPTEVA_EPIPHANY:
1397 rtype = elf_epiphany_reloc_type (type);
1402 rtype = elf_ip2k_reloc_type (type);
1406 rtype = elf_iq2000_reloc_type (type);
1411 rtype = elf_xtensa_reloc_type (type);
1414 case EM_LATTICEMICO32:
1415 rtype = elf_lm32_reloc_type (type);
1420 rtype = elf_m32c_reloc_type (type);
1424 rtype = elf_mt_reloc_type (type);
1428 rtype = elf_bfin_reloc_type (type);
1432 rtype = elf_mep_reloc_type (type);
1436 rtype = elf_cr16_reloc_type (type);
1440 case EM_MICROBLAZE_OLD:
1441 rtype = elf_microblaze_reloc_type (type);
1445 rtype = elf_rl78_reloc_type (type);
1449 rtype = elf_rx_reloc_type (type);
1453 rtype = elf_metag_reloc_type (type);
1458 rtype = elf_xc16x_reloc_type (type);
1462 rtype = elf_tic6x_reloc_type (type);
1466 rtype = elf_tilegx_reloc_type (type);
1470 rtype = elf_tilepro_reloc_type (type);
1474 rtype = elf_xgate_reloc_type (type);
1477 case EM_ALTERA_NIOS2:
1478 rtype = elf_nios2_reloc_type (type);
1483 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1485 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1487 if (elf_header.e_machine == EM_ALPHA
1489 && streq (rtype, "R_ALPHA_LITUSE")
1492 switch (rels[i].r_addend)
1494 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1495 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1496 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1497 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1498 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1499 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1500 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1501 default: rtype = NULL;
1504 printf (" (%s)", rtype);
1508 printf (_("<unknown addend: %lx>"),
1509 (unsigned long) rels[i].r_addend);
1512 else if (symtab_index)
1514 if (symtab == NULL || symtab_index >= nsyms)
1515 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1518 Elf_Internal_Sym * psym;
1519 const char * version_string;
1520 enum versioned_symbol_info sym_info;
1521 unsigned short vna_other;
1523 psym = symtab + symtab_index;
1526 = get_symbol_version_string (file, is_dynsym,
1535 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1539 unsigned int width = is_32bit_elf ? 8 : 14;
1541 /* Relocations against GNU_IFUNC symbols do not use the value
1542 of the symbol as the address to relocate against. Instead
1543 they invoke the function named by the symbol and use its
1544 result as the address for relocation.
1546 To indicate this to the user, do not display the value of
1547 the symbol in the "Symbols's Value" field. Instead show
1548 its name followed by () as a hint that the symbol is
1552 || psym->st_name == 0
1553 || psym->st_name >= strtablen)
1556 name = strtab + psym->st_name;
1558 len = print_symbol (width, name);
1560 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1562 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1566 print_vma (psym->st_value, LONG_HEX);
1568 printf (is_32bit_elf ? " " : " ");
1571 if (psym->st_name == 0)
1573 const char * sec_name = "<null>";
1576 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1578 if (psym->st_shndx < elf_header.e_shnum)
1579 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1580 else if (psym->st_shndx == SHN_ABS)
1582 else if (psym->st_shndx == SHN_COMMON)
1583 sec_name = "COMMON";
1584 else if ((elf_header.e_machine == EM_MIPS
1585 && psym->st_shndx == SHN_MIPS_SCOMMON)
1586 || (elf_header.e_machine == EM_TI_C6000
1587 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1588 sec_name = "SCOMMON";
1589 else if (elf_header.e_machine == EM_MIPS
1590 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1591 sec_name = "SUNDEF";
1592 else if ((elf_header.e_machine == EM_X86_64
1593 || elf_header.e_machine == EM_L1OM
1594 || elf_header.e_machine == EM_K1OM)
1595 && psym->st_shndx == SHN_X86_64_LCOMMON)
1596 sec_name = "LARGE_COMMON";
1597 else if (elf_header.e_machine == EM_IA_64
1598 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1599 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1600 sec_name = "ANSI_COM";
1601 else if (is_ia64_vms ()
1602 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1603 sec_name = "VMS_SYMVEC";
1606 sprintf (name_buf, "<section 0x%x>",
1607 (unsigned int) psym->st_shndx);
1608 sec_name = name_buf;
1611 print_symbol (22, sec_name);
1613 else if (strtab == NULL)
1614 printf (_("<string table index: %3ld>"), psym->st_name);
1615 else if (psym->st_name >= strtablen)
1616 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1619 print_symbol (22, strtab + psym->st_name);
1621 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1627 bfd_vma off = rels[i].r_addend;
1629 if ((bfd_signed_vma) off < 0)
1630 printf (" - %" BFD_VMA_FMT "x", - off);
1632 printf (" + %" BFD_VMA_FMT "x", off);
1638 bfd_vma off = rels[i].r_addend;
1640 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1641 if ((bfd_signed_vma) off < 0)
1642 printf ("-%" BFD_VMA_FMT "x", - off);
1644 printf ("%" BFD_VMA_FMT "x", off);
1647 if (elf_header.e_machine == EM_SPARCV9
1649 && streq (rtype, "R_SPARC_OLO10"))
1650 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1655 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1657 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1658 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1659 const char * rtype2 = elf_mips_reloc_type (type2);
1660 const char * rtype3 = elf_mips_reloc_type (type3);
1662 printf (" Type2: ");
1665 printf (_("unrecognized: %-7lx"),
1666 (unsigned long) type2 & 0xffffffff);
1668 printf ("%-17.17s", rtype2);
1670 printf ("\n Type3: ");
1673 printf (_("unrecognized: %-7lx"),
1674 (unsigned long) type3 & 0xffffffff);
1676 printf ("%-17.17s", rtype3);
1687 get_mips_dynamic_type (unsigned long type)
1691 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1692 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1693 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1694 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1695 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1696 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1697 case DT_MIPS_MSYM: return "MIPS_MSYM";
1698 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1699 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1700 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1701 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1702 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1703 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1704 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1705 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1706 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1707 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1708 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1709 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1710 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1711 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1712 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1713 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1714 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1715 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1716 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1717 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1718 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1719 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1720 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1721 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1722 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1723 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1724 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1725 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1726 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1727 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1728 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1729 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1730 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1731 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1732 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1733 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1734 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1735 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1736 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1743 get_sparc64_dynamic_type (unsigned long type)
1747 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1754 get_ppc_dynamic_type (unsigned long type)
1758 case DT_PPC_GOT: return "PPC_GOT";
1759 case DT_PPC_OPT: return "PPC_OPT";
1766 get_ppc64_dynamic_type (unsigned long type)
1770 case DT_PPC64_GLINK: return "PPC64_GLINK";
1771 case DT_PPC64_OPD: return "PPC64_OPD";
1772 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1773 case DT_PPC64_OPT: return "PPC64_OPT";
1780 get_parisc_dynamic_type (unsigned long type)
1784 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1785 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1786 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1787 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1788 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1789 case DT_HP_PREINIT: return "HP_PREINIT";
1790 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1791 case DT_HP_NEEDED: return "HP_NEEDED";
1792 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1793 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1794 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1795 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1796 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1797 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1798 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1799 case DT_HP_FILTERED: return "HP_FILTERED";
1800 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1801 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1802 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1803 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1804 case DT_PLT: return "PLT";
1805 case DT_PLT_SIZE: return "PLT_SIZE";
1806 case DT_DLT: return "DLT";
1807 case DT_DLT_SIZE: return "DLT_SIZE";
1814 get_ia64_dynamic_type (unsigned long type)
1818 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1819 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1820 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1821 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1822 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1823 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1824 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1825 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1826 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1828 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1829 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1830 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1831 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1832 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1833 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1834 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1835 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1836 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1837 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1838 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1839 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1840 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1841 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1842 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1843 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1844 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1845 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1846 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1847 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1848 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1855 get_solaris_section_type (unsigned long type)
1859 case 0x6fffffee: return "SUNW_ancillary";
1860 case 0x6fffffef: return "SUNW_capchain";
1861 case 0x6ffffff0: return "SUNW_capinfo";
1862 case 0x6ffffff1: return "SUNW_symsort";
1863 case 0x6ffffff2: return "SUNW_tlssort";
1864 case 0x6ffffff3: return "SUNW_LDYNSYM";
1865 case 0x6ffffff4: return "SUNW_dof";
1866 case 0x6ffffff5: return "SUNW_cap";
1867 case 0x6ffffff6: return "SUNW_SIGNATURE";
1868 case 0x6ffffff7: return "SUNW_ANNOTATE";
1869 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1870 case 0x6ffffff9: return "SUNW_DEBUG";
1871 case 0x6ffffffa: return "SUNW_move";
1872 case 0x6ffffffb: return "SUNW_COMDAT";
1873 case 0x6ffffffc: return "SUNW_syminfo";
1874 case 0x6ffffffd: return "SUNW_verdef";
1875 case 0x6ffffffe: return "SUNW_verneed";
1876 case 0x6fffffff: return "SUNW_versym";
1877 case 0x70000000: return "SPARC_GOTDATA";
1878 default: return NULL;
1883 get_alpha_dynamic_type (unsigned long type)
1887 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1894 get_score_dynamic_type (unsigned long type)
1898 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1899 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1900 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1901 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1902 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1903 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1910 get_tic6x_dynamic_type (unsigned long type)
1914 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1915 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1916 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1917 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1918 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1919 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1926 get_nios2_dynamic_type (unsigned long type)
1930 case DT_NIOS2_GP: return "NIOS2_GP";
1937 get_solaris_dynamic_type (unsigned long type)
1941 case 0x6000000d: return "SUNW_AUXILIARY";
1942 case 0x6000000e: return "SUNW_RTLDINF";
1943 case 0x6000000f: return "SUNW_FILTER";
1944 case 0x60000010: return "SUNW_CAP";
1945 case 0x60000011: return "SUNW_SYMTAB";
1946 case 0x60000012: return "SUNW_SYMSZ";
1947 case 0x60000013: return "SUNW_SORTENT";
1948 case 0x60000014: return "SUNW_SYMSORT";
1949 case 0x60000015: return "SUNW_SYMSORTSZ";
1950 case 0x60000016: return "SUNW_TLSSORT";
1951 case 0x60000017: return "SUNW_TLSSORTSZ";
1952 case 0x60000018: return "SUNW_CAPINFO";
1953 case 0x60000019: return "SUNW_STRPAD";
1954 case 0x6000001a: return "SUNW_CAPCHAIN";
1955 case 0x6000001b: return "SUNW_LDMACH";
1956 case 0x6000001d: return "SUNW_CAPCHAINENT";
1957 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1958 case 0x60000021: return "SUNW_PARENT";
1959 case 0x60000023: return "SUNW_ASLR";
1960 case 0x60000025: return "SUNW_RELAX";
1961 case 0x60000029: return "SUNW_NXHEAP";
1962 case 0x6000002b: return "SUNW_NXSTACK";
1964 case 0x70000001: return "SPARC_REGISTER";
1965 case 0x7ffffffd: return "AUXILIARY";
1966 case 0x7ffffffe: return "USED";
1967 case 0x7fffffff: return "FILTER";
1969 default: return NULL;
1974 get_dynamic_type (unsigned long type)
1976 static char buff[64];
1980 case DT_NULL: return "NULL";
1981 case DT_NEEDED: return "NEEDED";
1982 case DT_PLTRELSZ: return "PLTRELSZ";
1983 case DT_PLTGOT: return "PLTGOT";
1984 case DT_HASH: return "HASH";
1985 case DT_STRTAB: return "STRTAB";
1986 case DT_SYMTAB: return "SYMTAB";
1987 case DT_RELA: return "RELA";
1988 case DT_RELASZ: return "RELASZ";
1989 case DT_RELAENT: return "RELAENT";
1990 case DT_STRSZ: return "STRSZ";
1991 case DT_SYMENT: return "SYMENT";
1992 case DT_INIT: return "INIT";
1993 case DT_FINI: return "FINI";
1994 case DT_SONAME: return "SONAME";
1995 case DT_RPATH: return "RPATH";
1996 case DT_SYMBOLIC: return "SYMBOLIC";
1997 case DT_REL: return "REL";
1998 case DT_RELSZ: return "RELSZ";
1999 case DT_RELENT: return "RELENT";
2000 case DT_PLTREL: return "PLTREL";
2001 case DT_DEBUG: return "DEBUG";
2002 case DT_TEXTREL: return "TEXTREL";
2003 case DT_JMPREL: return "JMPREL";
2004 case DT_BIND_NOW: return "BIND_NOW";
2005 case DT_INIT_ARRAY: return "INIT_ARRAY";
2006 case DT_FINI_ARRAY: return "FINI_ARRAY";
2007 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2008 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2009 case DT_RUNPATH: return "RUNPATH";
2010 case DT_FLAGS: return "FLAGS";
2012 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2013 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2015 case DT_CHECKSUM: return "CHECKSUM";
2016 case DT_PLTPADSZ: return "PLTPADSZ";
2017 case DT_MOVEENT: return "MOVEENT";
2018 case DT_MOVESZ: return "MOVESZ";
2019 case DT_FEATURE: return "FEATURE";
2020 case DT_POSFLAG_1: return "POSFLAG_1";
2021 case DT_SYMINSZ: return "SYMINSZ";
2022 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2024 case DT_ADDRRNGLO: return "ADDRRNGLO";
2025 case DT_CONFIG: return "CONFIG";
2026 case DT_DEPAUDIT: return "DEPAUDIT";
2027 case DT_AUDIT: return "AUDIT";
2028 case DT_PLTPAD: return "PLTPAD";
2029 case DT_MOVETAB: return "MOVETAB";
2030 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2032 case DT_VERSYM: return "VERSYM";
2034 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2035 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2036 case DT_RELACOUNT: return "RELACOUNT";
2037 case DT_RELCOUNT: return "RELCOUNT";
2038 case DT_FLAGS_1: return "FLAGS_1";
2039 case DT_VERDEF: return "VERDEF";
2040 case DT_VERDEFNUM: return "VERDEFNUM";
2041 case DT_VERNEED: return "VERNEED";
2042 case DT_VERNEEDNUM: return "VERNEEDNUM";
2044 case DT_AUXILIARY: return "AUXILIARY";
2045 case DT_USED: return "USED";
2046 case DT_FILTER: return "FILTER";
2048 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2049 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2050 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2051 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2052 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2053 case DT_GNU_HASH: return "GNU_HASH";
2056 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2058 const char * result;
2060 switch (elf_header.e_machine)
2063 case EM_MIPS_RS3_LE:
2064 result = get_mips_dynamic_type (type);
2067 result = get_sparc64_dynamic_type (type);
2070 result = get_ppc_dynamic_type (type);
2073 result = get_ppc64_dynamic_type (type);
2076 result = get_ia64_dynamic_type (type);
2079 result = get_alpha_dynamic_type (type);
2082 result = get_score_dynamic_type (type);
2085 result = get_tic6x_dynamic_type (type);
2087 case EM_ALTERA_NIOS2:
2088 result = get_nios2_dynamic_type (type);
2091 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2092 result = get_solaris_dynamic_type (type);
2101 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2103 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2104 || (elf_header.e_machine == EM_PARISC
2105 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2107 const char * result;
2109 switch (elf_header.e_machine)
2112 result = get_parisc_dynamic_type (type);
2115 result = get_ia64_dynamic_type (type);
2118 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2119 result = get_solaris_dynamic_type (type);
2128 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2132 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2139 get_file_type (unsigned e_type)
2141 static char buff[32];
2145 case ET_NONE: return _("NONE (None)");
2146 case ET_REL: return _("REL (Relocatable file)");
2147 case ET_EXEC: return _("EXEC (Executable file)");
2148 case ET_DYN: return _("DYN (Shared object file)");
2149 case ET_CORE: return _("CORE (Core file)");
2152 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2153 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2154 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2155 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2157 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2163 get_machine_name (unsigned e_machine)
2165 static char buff[64]; /* XXX */
2169 case EM_NONE: return _("None");
2170 case EM_AARCH64: return "AArch64";
2171 case EM_M32: return "WE32100";
2172 case EM_SPARC: return "Sparc";
2173 case EM_SPU: return "SPU";
2174 case EM_386: return "Intel 80386";
2175 case EM_68K: return "MC68000";
2176 case EM_88K: return "MC88000";
2177 case EM_IAMCU: return "Intel MCU";
2178 case EM_860: return "Intel 80860";
2179 case EM_MIPS: return "MIPS R3000";
2180 case EM_S370: return "IBM System/370";
2181 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2182 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2183 case EM_PARISC: return "HPPA";
2184 case EM_PPC_OLD: return "Power PC (old)";
2185 case EM_SPARC32PLUS: return "Sparc v8+" ;
2186 case EM_960: return "Intel 90860";
2187 case EM_PPC: return "PowerPC";
2188 case EM_PPC64: return "PowerPC64";
2189 case EM_FR20: return "Fujitsu FR20";
2190 case EM_FT32: return "FTDI FT32";
2191 case EM_RH32: return "TRW RH32";
2192 case EM_MCORE: return "MCORE";
2193 case EM_ARM: return "ARM";
2194 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2195 case EM_SH: return "Renesas / SuperH SH";
2196 case EM_SPARCV9: return "Sparc v9";
2197 case EM_TRICORE: return "Siemens Tricore";
2198 case EM_ARC: return "ARC";
2199 case EM_ARC_COMPACT: return "ARCompact";
2200 case EM_ARC_COMPACT2: return "ARCv2";
2201 case EM_H8_300: return "Renesas H8/300";
2202 case EM_H8_300H: return "Renesas H8/300H";
2203 case EM_H8S: return "Renesas H8S";
2204 case EM_H8_500: return "Renesas H8/500";
2205 case EM_IA_64: return "Intel IA-64";
2206 case EM_MIPS_X: return "Stanford MIPS-X";
2207 case EM_COLDFIRE: return "Motorola Coldfire";
2208 case EM_ALPHA: return "Alpha";
2209 case EM_CYGNUS_D10V:
2210 case EM_D10V: return "d10v";
2211 case EM_CYGNUS_D30V:
2212 case EM_D30V: return "d30v";
2213 case EM_CYGNUS_M32R:
2214 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2215 case EM_CYGNUS_V850:
2216 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2217 case EM_V850: return "Renesas V850";
2218 case EM_CYGNUS_MN10300:
2219 case EM_MN10300: return "mn10300";
2220 case EM_CYGNUS_MN10200:
2221 case EM_MN10200: return "mn10200";
2222 case EM_MOXIE: return "Moxie";
2223 case EM_CYGNUS_FR30:
2224 case EM_FR30: return "Fujitsu FR30";
2225 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2227 case EM_PJ: return "picoJava";
2228 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2229 case EM_PCP: return "Siemens PCP";
2230 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2231 case EM_NDR1: return "Denso NDR1 microprocesspr";
2232 case EM_STARCORE: return "Motorola Star*Core processor";
2233 case EM_ME16: return "Toyota ME16 processor";
2234 case EM_ST100: return "STMicroelectronics ST100 processor";
2235 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2236 case EM_PDSP: return "Sony DSP processor";
2237 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2238 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2239 case EM_FX66: return "Siemens FX66 microcontroller";
2240 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2241 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2242 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2243 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2244 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2245 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2246 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2247 case EM_SVX: return "Silicon Graphics SVx";
2248 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2249 case EM_VAX: return "Digital VAX";
2250 case EM_VISIUM: return "CDS VISIUMcore processor";
2252 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2253 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2254 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2255 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2256 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2257 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2258 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2259 case EM_PRISM: return "Vitesse Prism";
2260 case EM_X86_64: return "Advanced Micro Devices X86-64";
2261 case EM_L1OM: return "Intel L1OM";
2262 case EM_K1OM: return "Intel K1OM";
2264 case EM_S390: return "IBM S/390";
2265 case EM_SCORE: return "SUNPLUS S+Core";
2266 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2267 case EM_OR1K: return "OpenRISC 1000";
2268 case EM_CRX: return "National Semiconductor CRX microprocessor";
2269 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2270 case EM_DLX: return "OpenDLX";
2272 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2273 case EM_IQ2000: return "Vitesse IQ2000";
2275 case EM_XTENSA: return "Tensilica Xtensa Processor";
2276 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2277 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2278 case EM_NS32K: return "National Semiconductor 32000 series";
2279 case EM_TPC: return "Tenor Network TPC processor";
2280 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2281 case EM_MAX: return "MAX Processor";
2282 case EM_CR: return "National Semiconductor CompactRISC";
2283 case EM_F2MC16: return "Fujitsu F2MC16";
2284 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2285 case EM_LATTICEMICO32: return "Lattice Mico32";
2287 case EM_M32C: return "Renesas M32c";
2288 case EM_MT: return "Morpho Techologies MT processor";
2289 case EM_BLACKFIN: return "Analog Devices Blackfin";
2290 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2291 case EM_SEP: return "Sharp embedded microprocessor";
2292 case EM_ARCA: return "Arca RISC microprocessor";
2293 case EM_UNICORE: return "Unicore";
2294 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2295 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2296 case EM_NIOS32: return "Altera Nios";
2297 case EM_ALTERA_NIOS2: return "Altera Nios II";
2299 case EM_XC16X: return "Infineon Technologies xc16x";
2300 case EM_M16C: return "Renesas M16C series microprocessors";
2301 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2302 case EM_CE: return "Freescale Communication Engine RISC core";
2303 case EM_TSK3000: return "Altium TSK3000 core";
2304 case EM_RS08: return "Freescale RS08 embedded processor";
2305 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2306 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2307 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2308 case EM_SE_C17: return "Seiko Epson C17 family";
2309 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2310 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2311 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2312 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2313 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2314 case EM_R32C: return "Renesas R32C series microprocessors";
2315 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2316 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2317 case EM_8051: return "Intel 8051 and variants";
2318 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2319 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2320 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2321 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2322 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2323 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2324 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2325 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2328 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2329 case EM_RL78: return "Renesas RL78";
2330 case EM_RX: return "Renesas RX";
2331 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2332 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2333 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2334 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2335 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2336 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2337 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2338 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2339 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2340 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2341 case EM_CUDA: return "NVIDIA CUDA architecture";
2342 case EM_XGATE: return "Motorola XGATE embedded processor";
2344 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2350 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2352 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2353 other compilers don't a specific architecture type in the e_flags, and
2354 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2355 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2358 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2359 but also sets a specific architecture type in the e_flags field.
2361 However, when decoding the flags we don't worry if we see an
2362 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2363 ARCEM architecture type. */
2365 switch (e_flags & EF_ARC_MACH_MSK)
2367 /* We only expect these to occur for EM_ARC_COMPACT2. */
2368 case EF_ARC_CPU_ARCV2EM:
2369 strcat (buf, ", ARC EM");
2371 case EF_ARC_CPU_ARCV2HS:
2372 strcat (buf, ", ARC HS");
2375 /* We only expect these to occur for EM_ARC_COMPACT. */
2376 case E_ARC_MACH_ARC600:
2377 strcat (buf, ", ARC600");
2379 case E_ARC_MACH_ARC601:
2380 strcat (buf, ", ARC601");
2382 case E_ARC_MACH_ARC700:
2383 strcat (buf, ", ARC700");
2386 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2387 new ELF with new architecture being read by an old version of
2388 readelf, or (c) An ELF built with non-GNU compiler that does not
2389 set the architecture in the e_flags. */
2391 if (e_machine == EM_ARC_COMPACT)
2392 strcat (buf, ", Unknown ARCompact");
2394 strcat (buf, ", Unknown ARC");
2398 switch (e_flags & EF_ARC_OSABI_MSK)
2400 case E_ARC_OSABI_ORIG:
2401 strcat (buf, ", (ABI:legacy)");
2403 case E_ARC_OSABI_V2:
2404 strcat (buf, ", (ABI:v2)");
2406 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2407 case E_ARC_OSABI_V3:
2408 strcat (buf, ", v3 no-legacy-syscalls ABI");
2411 strcat (buf, ", unrecognised ARC OSABI flag");
2417 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2422 eabi = EF_ARM_EABI_VERSION (e_flags);
2423 e_flags &= ~ EF_ARM_EABIMASK;
2425 /* Handle "generic" ARM flags. */
2426 if (e_flags & EF_ARM_RELEXEC)
2428 strcat (buf, ", relocatable executable");
2429 e_flags &= ~ EF_ARM_RELEXEC;
2432 /* Now handle EABI specific flags. */
2436 strcat (buf, ", <unrecognized EABI>");
2441 case EF_ARM_EABI_VER1:
2442 strcat (buf, ", Version1 EABI");
2447 /* Process flags one bit at a time. */
2448 flag = e_flags & - e_flags;
2453 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2454 strcat (buf, ", sorted symbol tables");
2464 case EF_ARM_EABI_VER2:
2465 strcat (buf, ", Version2 EABI");
2470 /* Process flags one bit at a time. */
2471 flag = e_flags & - e_flags;
2476 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2477 strcat (buf, ", sorted symbol tables");
2480 case EF_ARM_DYNSYMSUSESEGIDX:
2481 strcat (buf, ", dynamic symbols use segment index");
2484 case EF_ARM_MAPSYMSFIRST:
2485 strcat (buf, ", mapping symbols precede others");
2495 case EF_ARM_EABI_VER3:
2496 strcat (buf, ", Version3 EABI");
2499 case EF_ARM_EABI_VER4:
2500 strcat (buf, ", Version4 EABI");
2505 /* Process flags one bit at a time. */
2506 flag = e_flags & - e_flags;
2512 strcat (buf, ", BE8");
2516 strcat (buf, ", LE8");
2527 case EF_ARM_EABI_VER5:
2528 strcat (buf, ", Version5 EABI");
2533 /* Process flags one bit at a time. */
2534 flag = e_flags & - e_flags;
2540 strcat (buf, ", BE8");
2544 strcat (buf, ", LE8");
2547 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2548 strcat (buf, ", soft-float ABI");
2551 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2552 strcat (buf, ", hard-float ABI");
2562 case EF_ARM_EABI_UNKNOWN:
2563 strcat (buf, ", GNU EABI");
2568 /* Process flags one bit at a time. */
2569 flag = e_flags & - e_flags;
2574 case EF_ARM_INTERWORK:
2575 strcat (buf, ", interworking enabled");
2578 case EF_ARM_APCS_26:
2579 strcat (buf, ", uses APCS/26");
2582 case EF_ARM_APCS_FLOAT:
2583 strcat (buf, ", uses APCS/float");
2587 strcat (buf, ", position independent");
2591 strcat (buf, ", 8 bit structure alignment");
2594 case EF_ARM_NEW_ABI:
2595 strcat (buf, ", uses new ABI");
2598 case EF_ARM_OLD_ABI:
2599 strcat (buf, ", uses old ABI");
2602 case EF_ARM_SOFT_FLOAT:
2603 strcat (buf, ", software FP");
2606 case EF_ARM_VFP_FLOAT:
2607 strcat (buf, ", VFP");
2610 case EF_ARM_MAVERICK_FLOAT:
2611 strcat (buf, ", Maverick FP");
2622 strcat (buf,_(", <unknown>"));
2626 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2628 --size; /* Leave space for null terminator. */
2630 switch (e_flags & EF_AVR_MACH)
2632 case E_AVR_MACH_AVR1:
2633 strncat (buf, ", avr:1", size);
2635 case E_AVR_MACH_AVR2:
2636 strncat (buf, ", avr:2", size);
2638 case E_AVR_MACH_AVR25:
2639 strncat (buf, ", avr:25", size);
2641 case E_AVR_MACH_AVR3:
2642 strncat (buf, ", avr:3", size);
2644 case E_AVR_MACH_AVR31:
2645 strncat (buf, ", avr:31", size);
2647 case E_AVR_MACH_AVR35:
2648 strncat (buf, ", avr:35", size);
2650 case E_AVR_MACH_AVR4:
2651 strncat (buf, ", avr:4", size);
2653 case E_AVR_MACH_AVR5:
2654 strncat (buf, ", avr:5", size);
2656 case E_AVR_MACH_AVR51:
2657 strncat (buf, ", avr:51", size);
2659 case E_AVR_MACH_AVR6:
2660 strncat (buf, ", avr:6", size);
2662 case E_AVR_MACH_AVRTINY:
2663 strncat (buf, ", avr:100", size);
2665 case E_AVR_MACH_XMEGA1:
2666 strncat (buf, ", avr:101", size);
2668 case E_AVR_MACH_XMEGA2:
2669 strncat (buf, ", avr:102", size);
2671 case E_AVR_MACH_XMEGA3:
2672 strncat (buf, ", avr:103", size);
2674 case E_AVR_MACH_XMEGA4:
2675 strncat (buf, ", avr:104", size);
2677 case E_AVR_MACH_XMEGA5:
2678 strncat (buf, ", avr:105", size);
2680 case E_AVR_MACH_XMEGA6:
2681 strncat (buf, ", avr:106", size);
2683 case E_AVR_MACH_XMEGA7:
2684 strncat (buf, ", avr:107", size);
2687 strncat (buf, ", avr:<unknown>", size);
2691 size -= strlen (buf);
2692 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2693 strncat (buf, ", link-relax", size);
2697 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2706 static const char *ABI_STRINGS[] =
2708 "ABI v0", /* use r5 as return register; only used in N1213HC */
2709 "ABI v1", /* use r0 as return register */
2710 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2711 "ABI v2fp", /* for FPU */
2715 static const char *VER_STRINGS[] =
2717 "Andes ELF V1.3 or older",
2721 static const char *ARCH_STRINGS[] =
2730 abi = EF_NDS_ABI & e_flags;
2731 arch = EF_NDS_ARCH & e_flags;
2732 config = EF_NDS_INST & e_flags;
2733 version = EF_NDS32_ELF_VERSION & e_flags;
2735 memset (buf, 0, size);
2742 case E_NDS_ABI_V2FP:
2743 case E_NDS_ABI_AABI:
2744 case E_NDS_ABI_V2FP_PLUS:
2745 /* In case there are holes in the array. */
2746 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2750 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2756 case E_NDS32_ELF_VER_1_2:
2757 case E_NDS32_ELF_VER_1_3:
2758 case E_NDS32_ELF_VER_1_4:
2759 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2763 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2767 if (E_NDS_ABI_V0 == abi)
2769 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2770 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2771 if (arch == E_NDS_ARCH_STAR_V1_0)
2772 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2778 case E_NDS_ARCH_STAR_V1_0:
2779 case E_NDS_ARCH_STAR_V2_0:
2780 case E_NDS_ARCH_STAR_V3_0:
2781 case E_NDS_ARCH_STAR_V3_M:
2782 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2786 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2787 /* ARCH version determines how the e_flags are interpreted.
2788 If it is unknown, we cannot proceed. */
2792 /* Newer ABI; Now handle architecture specific flags. */
2793 if (arch == E_NDS_ARCH_STAR_V1_0)
2795 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2796 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2798 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2799 r += snprintf (buf + r, size -r, ", MAC");
2801 if (config & E_NDS32_HAS_DIV_INST)
2802 r += snprintf (buf + r, size -r, ", DIV");
2804 if (config & E_NDS32_HAS_16BIT_INST)
2805 r += snprintf (buf + r, size -r, ", 16b");
2809 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2811 if (version <= E_NDS32_ELF_VER_1_3)
2812 r += snprintf (buf + r, size -r, ", [B8]");
2814 r += snprintf (buf + r, size -r, ", EX9");
2817 if (config & E_NDS32_HAS_MAC_DX_INST)
2818 r += snprintf (buf + r, size -r, ", MAC_DX");
2820 if (config & E_NDS32_HAS_DIV_DX_INST)
2821 r += snprintf (buf + r, size -r, ", DIV_DX");
2823 if (config & E_NDS32_HAS_16BIT_INST)
2825 if (version <= E_NDS32_ELF_VER_1_3)
2826 r += snprintf (buf + r, size -r, ", 16b");
2828 r += snprintf (buf + r, size -r, ", IFC");
2832 if (config & E_NDS32_HAS_EXT_INST)
2833 r += snprintf (buf + r, size -r, ", PERF1");
2835 if (config & E_NDS32_HAS_EXT2_INST)
2836 r += snprintf (buf + r, size -r, ", PERF2");
2838 if (config & E_NDS32_HAS_FPU_INST)
2841 r += snprintf (buf + r, size -r, ", FPU_SP");
2844 if (config & E_NDS32_HAS_FPU_DP_INST)
2847 r += snprintf (buf + r, size -r, ", FPU_DP");
2850 if (config & E_NDS32_HAS_FPU_MAC_INST)
2853 r += snprintf (buf + r, size -r, ", FPU_MAC");
2858 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2860 case E_NDS32_FPU_REG_8SP_4DP:
2861 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2863 case E_NDS32_FPU_REG_16SP_8DP:
2864 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2866 case E_NDS32_FPU_REG_32SP_16DP:
2867 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2869 case E_NDS32_FPU_REG_32SP_32DP:
2870 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2875 if (config & E_NDS32_HAS_AUDIO_INST)
2876 r += snprintf (buf + r, size -r, ", AUDIO");
2878 if (config & E_NDS32_HAS_STRING_INST)
2879 r += snprintf (buf + r, size -r, ", STR");
2881 if (config & E_NDS32_HAS_REDUCED_REGS)
2882 r += snprintf (buf + r, size -r, ", 16REG");
2884 if (config & E_NDS32_HAS_VIDEO_INST)
2886 if (version <= E_NDS32_ELF_VER_1_3)
2887 r += snprintf (buf + r, size -r, ", VIDEO");
2889 r += snprintf (buf + r, size -r, ", SATURATION");
2892 if (config & E_NDS32_HAS_ENCRIPT_INST)
2893 r += snprintf (buf + r, size -r, ", ENCRP");
2895 if (config & E_NDS32_HAS_L2C_INST)
2896 r += snprintf (buf + r, size -r, ", L2C");
2900 get_machine_flags (unsigned e_flags, unsigned e_machine)
2902 static char buf[1024];
2913 case EM_ARC_COMPACT2:
2914 case EM_ARC_COMPACT:
2915 decode_ARC_machine_flags (e_flags, e_machine, buf);
2919 decode_ARM_machine_flags (e_flags, buf);
2923 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2927 if (e_flags & EF_BFIN_PIC)
2928 strcat (buf, ", PIC");
2930 if (e_flags & EF_BFIN_FDPIC)
2931 strcat (buf, ", FDPIC");
2933 if (e_flags & EF_BFIN_CODE_IN_L1)
2934 strcat (buf, ", code in L1");
2936 if (e_flags & EF_BFIN_DATA_IN_L1)
2937 strcat (buf, ", data in L1");
2942 switch (e_flags & EF_FRV_CPU_MASK)
2944 case EF_FRV_CPU_GENERIC:
2948 strcat (buf, ", fr???");
2951 case EF_FRV_CPU_FR300:
2952 strcat (buf, ", fr300");
2955 case EF_FRV_CPU_FR400:
2956 strcat (buf, ", fr400");
2958 case EF_FRV_CPU_FR405:
2959 strcat (buf, ", fr405");
2962 case EF_FRV_CPU_FR450:
2963 strcat (buf, ", fr450");
2966 case EF_FRV_CPU_FR500:
2967 strcat (buf, ", fr500");
2969 case EF_FRV_CPU_FR550:
2970 strcat (buf, ", fr550");
2973 case EF_FRV_CPU_SIMPLE:
2974 strcat (buf, ", simple");
2976 case EF_FRV_CPU_TOMCAT:
2977 strcat (buf, ", tomcat");
2983 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2984 strcat (buf, ", m68000");
2985 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2986 strcat (buf, ", cpu32");
2987 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2988 strcat (buf, ", fido_a");
2991 char const * isa = _("unknown");
2992 char const * mac = _("unknown mac");
2993 char const * additional = NULL;
2995 switch (e_flags & EF_M68K_CF_ISA_MASK)
2997 case EF_M68K_CF_ISA_A_NODIV:
2999 additional = ", nodiv";
3001 case EF_M68K_CF_ISA_A:
3004 case EF_M68K_CF_ISA_A_PLUS:
3007 case EF_M68K_CF_ISA_B_NOUSP:
3009 additional = ", nousp";
3011 case EF_M68K_CF_ISA_B:
3014 case EF_M68K_CF_ISA_C:
3017 case EF_M68K_CF_ISA_C_NODIV:
3019 additional = ", nodiv";
3022 strcat (buf, ", cf, isa ");
3025 strcat (buf, additional);
3026 if (e_flags & EF_M68K_CF_FLOAT)
3027 strcat (buf, ", float");
3028 switch (e_flags & EF_M68K_CF_MAC_MASK)
3033 case EF_M68K_CF_MAC:
3036 case EF_M68K_CF_EMAC:
3039 case EF_M68K_CF_EMAC_B:
3052 switch (e_flags & EF_MEP_CPU_MASK)
3054 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3055 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3056 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3057 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3058 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3059 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3060 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3063 switch (e_flags & EF_MEP_COP_MASK)
3065 case EF_MEP_COP_NONE: break;
3066 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3067 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3068 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3069 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3070 default: strcat (buf, _("<unknown MeP copro type>")); break;
3073 if (e_flags & EF_MEP_LIBRARY)
3074 strcat (buf, ", Built for Library");
3076 if (e_flags & EF_MEP_INDEX_MASK)
3077 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3078 e_flags & EF_MEP_INDEX_MASK);
3080 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3081 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3082 e_flags & ~ EF_MEP_ALL_FLAGS);
3086 if (e_flags & EF_PPC_EMB)
3087 strcat (buf, ", emb");
3089 if (e_flags & EF_PPC_RELOCATABLE)
3090 strcat (buf, _(", relocatable"));
3092 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3093 strcat (buf, _(", relocatable-lib"));
3097 if (e_flags & EF_PPC64_ABI)
3099 char abi[] = ", abiv0";
3101 abi[6] += e_flags & EF_PPC64_ABI;
3107 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3108 strcat (buf, ", RH850 ABI");
3110 if (e_flags & EF_V800_850E3)
3111 strcat (buf, ", V3 architecture");
3113 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3114 strcat (buf, ", FPU not used");
3116 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3117 strcat (buf, ", regmode: COMMON");
3119 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3120 strcat (buf, ", r4 not used");
3122 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3123 strcat (buf, ", r30 not used");
3125 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3126 strcat (buf, ", r5 not used");
3128 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3129 strcat (buf, ", r2 not used");
3131 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3133 switch (e_flags & - e_flags)
3135 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3136 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3137 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3138 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3139 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3140 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3141 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3142 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3143 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3144 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3145 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3146 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3153 case EM_CYGNUS_V850:
3154 switch (e_flags & EF_V850_ARCH)
3156 case E_V850E3V5_ARCH:
3157 strcat (buf, ", v850e3v5");
3159 case E_V850E2V3_ARCH:
3160 strcat (buf, ", v850e2v3");
3163 strcat (buf, ", v850e2");
3166 strcat (buf, ", v850e1");
3169 strcat (buf, ", v850e");
3172 strcat (buf, ", v850");
3175 strcat (buf, _(", unknown v850 architecture variant"));
3181 case EM_CYGNUS_M32R:
3182 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3183 strcat (buf, ", m32r");
3187 case EM_MIPS_RS3_LE:
3188 if (e_flags & EF_MIPS_NOREORDER)
3189 strcat (buf, ", noreorder");
3191 if (e_flags & EF_MIPS_PIC)
3192 strcat (buf, ", pic");
3194 if (e_flags & EF_MIPS_CPIC)
3195 strcat (buf, ", cpic");
3197 if (e_flags & EF_MIPS_UCODE)
3198 strcat (buf, ", ugen_reserved");
3200 if (e_flags & EF_MIPS_ABI2)
3201 strcat (buf, ", abi2");
3203 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3204 strcat (buf, ", odk first");
3206 if (e_flags & EF_MIPS_32BITMODE)
3207 strcat (buf, ", 32bitmode");
3209 if (e_flags & EF_MIPS_NAN2008)
3210 strcat (buf, ", nan2008");
3212 if (e_flags & EF_MIPS_FP64)
3213 strcat (buf, ", fp64");
3215 switch ((e_flags & EF_MIPS_MACH))
3217 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3218 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3219 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3220 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3221 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3222 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3223 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3224 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3225 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3226 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3227 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3228 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3229 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3230 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3231 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3232 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3233 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3235 /* We simply ignore the field in this case to avoid confusion:
3236 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3239 default: strcat (buf, _(", unknown CPU")); break;
3242 switch ((e_flags & EF_MIPS_ABI))
3244 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3245 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3246 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3247 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3249 /* We simply ignore the field in this case to avoid confusion:
3250 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3251 This means it is likely to be an o32 file, but not for
3254 default: strcat (buf, _(", unknown ABI")); break;
3257 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3258 strcat (buf, ", mdmx");
3260 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3261 strcat (buf, ", mips16");
3263 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3264 strcat (buf, ", micromips");
3266 switch ((e_flags & EF_MIPS_ARCH))
3268 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3269 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3270 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3271 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3272 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3273 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3274 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3275 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3276 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3277 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3278 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3279 default: strcat (buf, _(", unknown ISA")); break;
3284 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3288 switch ((e_flags & EF_SH_MACH_MASK))
3290 case EF_SH1: strcat (buf, ", sh1"); break;
3291 case EF_SH2: strcat (buf, ", sh2"); break;
3292 case EF_SH3: strcat (buf, ", sh3"); break;
3293 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3294 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3295 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3296 case EF_SH3E: strcat (buf, ", sh3e"); break;
3297 case EF_SH4: strcat (buf, ", sh4"); break;
3298 case EF_SH5: strcat (buf, ", sh5"); break;
3299 case EF_SH2E: strcat (buf, ", sh2e"); break;
3300 case EF_SH4A: strcat (buf, ", sh4a"); break;
3301 case EF_SH2A: strcat (buf, ", sh2a"); break;
3302 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3303 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3304 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3305 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3306 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3307 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3308 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3309 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3310 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3311 default: strcat (buf, _(", unknown ISA")); break;
3314 if (e_flags & EF_SH_PIC)
3315 strcat (buf, ", pic");
3317 if (e_flags & EF_SH_FDPIC)
3318 strcat (buf, ", fdpic");
3322 if (e_flags & EF_OR1K_NODELAY)
3323 strcat (buf, ", no delay");
3327 if (e_flags & EF_SPARC_32PLUS)
3328 strcat (buf, ", v8+");
3330 if (e_flags & EF_SPARC_SUN_US1)
3331 strcat (buf, ", ultrasparcI");
3333 if (e_flags & EF_SPARC_SUN_US3)
3334 strcat (buf, ", ultrasparcIII");
3336 if (e_flags & EF_SPARC_HAL_R1)
3337 strcat (buf, ", halr1");
3339 if (e_flags & EF_SPARC_LEDATA)
3340 strcat (buf, ", ledata");
3342 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3343 strcat (buf, ", tso");
3345 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3346 strcat (buf, ", pso");
3348 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3349 strcat (buf, ", rmo");
3353 switch (e_flags & EF_PARISC_ARCH)
3355 case EFA_PARISC_1_0:
3356 strcpy (buf, ", PA-RISC 1.0");
3358 case EFA_PARISC_1_1:
3359 strcpy (buf, ", PA-RISC 1.1");
3361 case EFA_PARISC_2_0:
3362 strcpy (buf, ", PA-RISC 2.0");
3367 if (e_flags & EF_PARISC_TRAPNIL)
3368 strcat (buf, ", trapnil");
3369 if (e_flags & EF_PARISC_EXT)
3370 strcat (buf, ", ext");
3371 if (e_flags & EF_PARISC_LSB)
3372 strcat (buf, ", lsb");
3373 if (e_flags & EF_PARISC_WIDE)
3374 strcat (buf, ", wide");
3375 if (e_flags & EF_PARISC_NO_KABP)
3376 strcat (buf, ", no kabp");
3377 if (e_flags & EF_PARISC_LAZYSWAP)
3378 strcat (buf, ", lazyswap");
3383 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3384 strcat (buf, ", new calling convention");
3386 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3387 strcat (buf, ", gnu calling convention");
3391 if ((e_flags & EF_IA_64_ABI64))
3392 strcat (buf, ", 64-bit");
3394 strcat (buf, ", 32-bit");
3395 if ((e_flags & EF_IA_64_REDUCEDFP))
3396 strcat (buf, ", reduced fp model");
3397 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3398 strcat (buf, ", no function descriptors, constant gp");
3399 else if ((e_flags & EF_IA_64_CONS_GP))
3400 strcat (buf, ", constant gp");
3401 if ((e_flags & EF_IA_64_ABSOLUTE))
3402 strcat (buf, ", absolute");
3403 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3405 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3406 strcat (buf, ", vms_linkages");
3407 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3409 case EF_IA_64_VMS_COMCOD_SUCCESS:
3411 case EF_IA_64_VMS_COMCOD_WARNING:
3412 strcat (buf, ", warning");
3414 case EF_IA_64_VMS_COMCOD_ERROR:
3415 strcat (buf, ", error");
3417 case EF_IA_64_VMS_COMCOD_ABORT:
3418 strcat (buf, ", abort");
3421 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3422 e_flags & EF_IA_64_VMS_COMCOD);
3423 strcat (buf, ", <unknown>");
3429 if ((e_flags & EF_VAX_NONPIC))
3430 strcat (buf, ", non-PIC");
3431 if ((e_flags & EF_VAX_DFLOAT))
3432 strcat (buf, ", D-Float");
3433 if ((e_flags & EF_VAX_GFLOAT))
3434 strcat (buf, ", G-Float");
3438 if (e_flags & EF_VISIUM_ARCH_MCM)
3439 strcat (buf, ", mcm");
3440 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3441 strcat (buf, ", mcm24");
3442 if (e_flags & EF_VISIUM_ARCH_GR6)
3443 strcat (buf, ", gr6");
3447 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3449 case E_FLAG_RL78_ANY_CPU: break;
3450 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3451 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3452 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3454 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3455 strcat (buf, ", 64-bit doubles");
3459 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3460 strcat (buf, ", 64-bit doubles");
3461 if (e_flags & E_FLAG_RX_DSP)
3462 strcat (buf, ", dsp");
3463 if (e_flags & E_FLAG_RX_PID)
3464 strcat (buf, ", pid");
3465 if (e_flags & E_FLAG_RX_ABI)
3466 strcat (buf, ", RX ABI");
3467 if (e_flags & E_FLAG_RX_SINSNS_SET)
3468 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3469 ? ", uses String instructions" : ", bans String instructions");
3470 if (e_flags & E_FLAG_RX_V2)
3471 strcat (buf, ", V2");
3475 if (e_flags & EF_S390_HIGH_GPRS)
3476 strcat (buf, ", highgprs");
3480 if ((e_flags & EF_C6000_REL))
3481 strcat (buf, ", relocatable module");
3485 strcat (buf, _(": architecture variant: "));
3486 switch (e_flags & EF_MSP430_MACH)
3488 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3489 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3490 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3491 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3492 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3493 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3494 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3495 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3496 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3497 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3498 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3499 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3500 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3501 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3502 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3504 strcat (buf, _(": unknown")); break;
3507 if (e_flags & ~ EF_MSP430_MACH)
3508 strcat (buf, _(": unknown extra flag bits also present"));
3516 get_osabi_name (unsigned int osabi)
3518 static char buff[32];
3522 case ELFOSABI_NONE: return "UNIX - System V";
3523 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3524 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3525 case ELFOSABI_GNU: return "UNIX - GNU";
3526 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3527 case ELFOSABI_AIX: return "UNIX - AIX";
3528 case ELFOSABI_IRIX: return "UNIX - IRIX";
3529 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3530 case ELFOSABI_TRU64: return "UNIX - TRU64";
3531 case ELFOSABI_MODESTO: return "Novell - Modesto";
3532 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3533 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3534 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3535 case ELFOSABI_AROS: return "AROS";
3536 case ELFOSABI_FENIXOS: return "FenixOS";
3539 switch (elf_header.e_machine)
3544 case ELFOSABI_ARM: return "ARM";
3555 case ELFOSABI_STANDALONE: return _("Standalone App");
3564 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3565 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3574 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3580 get_aarch64_segment_type (unsigned long type)
3584 case PT_AARCH64_ARCHEXT:
3585 return "AARCH64_ARCHEXT";
3594 get_arm_segment_type (unsigned long type)
3608 get_mips_segment_type (unsigned long type)
3612 case PT_MIPS_REGINFO:
3614 case PT_MIPS_RTPROC:
3616 case PT_MIPS_OPTIONS:
3618 case PT_MIPS_ABIFLAGS:
3628 get_parisc_segment_type (unsigned long type)
3632 case PT_HP_TLS: return "HP_TLS";
3633 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3634 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3635 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3636 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3637 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3638 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3639 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3640 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3641 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3642 case PT_HP_PARALLEL: return "HP_PARALLEL";
3643 case PT_HP_FASTBIND: return "HP_FASTBIND";
3644 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3645 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3646 case PT_HP_STACK: return "HP_STACK";
3647 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3648 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3649 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3650 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3659 get_ia64_segment_type (unsigned long type)
3663 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3664 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3665 case PT_HP_TLS: return "HP_TLS";
3666 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3667 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3668 case PT_IA_64_HP_STACK: return "HP_STACK";
3677 get_tic6x_segment_type (unsigned long type)
3681 case PT_C6000_PHATTR: return "C6000_PHATTR";
3690 get_solaris_segment_type (unsigned long type)
3694 case 0x6464e550: return "PT_SUNW_UNWIND";
3695 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3696 case 0x6ffffff7: return "PT_LOSUNW";
3697 case 0x6ffffffa: return "PT_SUNWBSS";
3698 case 0x6ffffffb: return "PT_SUNWSTACK";
3699 case 0x6ffffffc: return "PT_SUNWDTRACE";
3700 case 0x6ffffffd: return "PT_SUNWCAP";
3701 case 0x6fffffff: return "PT_HISUNW";
3702 default: return NULL;
3707 get_segment_type (unsigned long p_type)
3709 static char buff[32];
3713 case PT_NULL: return "NULL";
3714 case PT_LOAD: return "LOAD";
3715 case PT_DYNAMIC: return "DYNAMIC";
3716 case PT_INTERP: return "INTERP";
3717 case PT_NOTE: return "NOTE";
3718 case PT_SHLIB: return "SHLIB";
3719 case PT_PHDR: return "PHDR";
3720 case PT_TLS: return "TLS";
3722 case PT_GNU_EH_FRAME:
3723 return "GNU_EH_FRAME";
3724 case PT_GNU_STACK: return "GNU_STACK";
3725 case PT_GNU_RELRO: return "GNU_RELRO";
3728 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3730 const char * result;
3732 switch (elf_header.e_machine)
3735 result = get_aarch64_segment_type (p_type);
3738 result = get_arm_segment_type (p_type);
3741 case EM_MIPS_RS3_LE:
3742 result = get_mips_segment_type (p_type);
3745 result = get_parisc_segment_type (p_type);
3748 result = get_ia64_segment_type (p_type);
3751 result = get_tic6x_segment_type (p_type);
3761 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3763 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3765 const char * result;
3767 switch (elf_header.e_machine)
3770 result = get_parisc_segment_type (p_type);
3773 result = get_ia64_segment_type (p_type);
3776 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3777 result = get_solaris_segment_type (p_type);
3786 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3789 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3796 get_mips_section_type_name (unsigned int sh_type)
3800 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3801 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3802 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3803 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3804 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3805 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3806 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3807 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3808 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3809 case SHT_MIPS_RELD: return "MIPS_RELD";
3810 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3811 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3812 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3813 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3814 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3815 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3816 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3817 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3818 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3819 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3820 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3821 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3822 case SHT_MIPS_LINE: return "MIPS_LINE";
3823 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3824 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3825 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3826 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3827 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3828 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3829 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3830 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3831 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3832 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3833 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3834 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3835 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3836 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3837 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3838 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3839 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3847 get_parisc_section_type_name (unsigned int sh_type)
3851 case SHT_PARISC_EXT: return "PARISC_EXT";
3852 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3853 case SHT_PARISC_DOC: return "PARISC_DOC";
3854 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3855 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3856 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3857 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3865 get_ia64_section_type_name (unsigned int sh_type)
3867 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3868 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3869 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3873 case SHT_IA_64_EXT: return "IA_64_EXT";
3874 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3875 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3876 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3877 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3878 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3879 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3880 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3881 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3882 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3890 get_x86_64_section_type_name (unsigned int sh_type)
3894 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3902 get_aarch64_section_type_name (unsigned int sh_type)
3906 case SHT_AARCH64_ATTRIBUTES:
3907 return "AARCH64_ATTRIBUTES";
3915 get_arm_section_type_name (unsigned int sh_type)
3919 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3920 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3921 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3922 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3923 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3931 get_tic6x_section_type_name (unsigned int sh_type)
3935 case SHT_C6000_UNWIND:
3936 return "C6000_UNWIND";
3937 case SHT_C6000_PREEMPTMAP:
3938 return "C6000_PREEMPTMAP";
3939 case SHT_C6000_ATTRIBUTES:
3940 return "C6000_ATTRIBUTES";
3945 case SHT_TI_HANDLER:
3946 return "TI_HANDLER";
3947 case SHT_TI_INITINFO:
3948 return "TI_INITINFO";
3949 case SHT_TI_PHATTRS:
3950 return "TI_PHATTRS";
3958 get_msp430x_section_type_name (unsigned int sh_type)
3962 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3963 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3964 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3965 default: return NULL;
3970 get_v850_section_type_name (unsigned int sh_type)
3974 case SHT_V850_SCOMMON: return "V850 Small Common";
3975 case SHT_V850_TCOMMON: return "V850 Tiny Common";
3976 case SHT_V850_ZCOMMON: return "V850 Zero Common";
3977 case SHT_RENESAS_IOP: return "RENESAS IOP";
3978 case SHT_RENESAS_INFO: return "RENESAS INFO";
3979 default: return NULL;
3984 get_section_type_name (unsigned int sh_type)
3986 static char buff[32];
3987 const char * result;
3991 case SHT_NULL: return "NULL";
3992 case SHT_PROGBITS: return "PROGBITS";
3993 case SHT_SYMTAB: return "SYMTAB";
3994 case SHT_STRTAB: return "STRTAB";
3995 case SHT_RELA: return "RELA";
3996 case SHT_HASH: return "HASH";
3997 case SHT_DYNAMIC: return "DYNAMIC";
3998 case SHT_NOTE: return "NOTE";
3999 case SHT_NOBITS: return "NOBITS";
4000 case SHT_REL: return "REL";
4001 case SHT_SHLIB: return "SHLIB";
4002 case SHT_DYNSYM: return "DYNSYM";
4003 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4004 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4005 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4006 case SHT_GNU_HASH: return "GNU_HASH";
4007 case SHT_GROUP: return "GROUP";
4008 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
4009 case SHT_GNU_verdef: return "VERDEF";
4010 case SHT_GNU_verneed: return "VERNEED";
4011 case SHT_GNU_versym: return "VERSYM";
4012 case 0x6ffffff0: return "VERSYM";
4013 case 0x6ffffffc: return "VERDEF";
4014 case 0x7ffffffd: return "AUXILIARY";
4015 case 0x7fffffff: return "FILTER";
4016 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4019 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4021 switch (elf_header.e_machine)
4024 case EM_MIPS_RS3_LE:
4025 result = get_mips_section_type_name (sh_type);
4028 result = get_parisc_section_type_name (sh_type);
4031 result = get_ia64_section_type_name (sh_type);
4036 result = get_x86_64_section_type_name (sh_type);
4039 result = get_aarch64_section_type_name (sh_type);
4042 result = get_arm_section_type_name (sh_type);
4045 result = get_tic6x_section_type_name (sh_type);
4048 result = get_msp430x_section_type_name (sh_type);
4052 case EM_CYGNUS_V850:
4053 result = get_v850_section_type_name (sh_type);
4063 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4065 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4067 switch (elf_header.e_machine)
4070 result = get_ia64_section_type_name (sh_type);
4073 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4074 result = get_solaris_section_type (sh_type);
4083 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4085 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4087 switch (elf_header.e_machine)
4091 case EM_CYGNUS_V850:
4092 result = get_v850_section_type_name (sh_type);
4102 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4105 /* This message is probably going to be displayed in a 15
4106 character wide field, so put the hex value first. */
4107 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4113 #define OPTION_DEBUG_DUMP 512
4114 #define OPTION_DYN_SYMS 513
4115 #define OPTION_DWARF_DEPTH 514
4116 #define OPTION_DWARF_START 515
4117 #define OPTION_DWARF_CHECK 516
4119 static struct option options[] =
4121 {"all", no_argument, 0, 'a'},
4122 {"file-header", no_argument, 0, 'h'},
4123 {"program-headers", no_argument, 0, 'l'},
4124 {"headers", no_argument, 0, 'e'},
4125 {"histogram", no_argument, 0, 'I'},
4126 {"segments", no_argument, 0, 'l'},
4127 {"sections", no_argument, 0, 'S'},
4128 {"section-headers", no_argument, 0, 'S'},
4129 {"section-groups", no_argument, 0, 'g'},
4130 {"section-details", no_argument, 0, 't'},
4131 {"full-section-name",no_argument, 0, 'N'},
4132 {"symbols", no_argument, 0, 's'},
4133 {"syms", no_argument, 0, 's'},
4134 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4135 {"relocs", no_argument, 0, 'r'},
4136 {"notes", no_argument, 0, 'n'},
4137 {"dynamic", no_argument, 0, 'd'},
4138 {"arch-specific", no_argument, 0, 'A'},
4139 {"version-info", no_argument, 0, 'V'},
4140 {"use-dynamic", no_argument, 0, 'D'},
4141 {"unwind", no_argument, 0, 'u'},
4142 {"archive-index", no_argument, 0, 'c'},
4143 {"hex-dump", required_argument, 0, 'x'},
4144 {"relocated-dump", required_argument, 0, 'R'},
4145 {"string-dump", required_argument, 0, 'p'},
4146 {"decompress", no_argument, 0, 'z'},
4147 #ifdef SUPPORT_DISASSEMBLY
4148 {"instruction-dump", required_argument, 0, 'i'},
4150 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4152 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4153 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4154 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4156 {"version", no_argument, 0, 'v'},
4157 {"wide", no_argument, 0, 'W'},
4158 {"help", no_argument, 0, 'H'},
4159 {0, no_argument, 0, 0}
4163 usage (FILE * stream)
4165 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4166 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4167 fprintf (stream, _(" Options are:\n\
4168 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4169 -h --file-header Display the ELF file header\n\
4170 -l --program-headers Display the program headers\n\
4171 --segments An alias for --program-headers\n\
4172 -S --section-headers Display the sections' header\n\
4173 --sections An alias for --section-headers\n\
4174 -g --section-groups Display the section groups\n\
4175 -t --section-details Display the section details\n\
4176 -e --headers Equivalent to: -h -l -S\n\
4177 -s --syms Display the symbol table\n\
4178 --symbols An alias for --syms\n\
4179 --dyn-syms Display the dynamic symbol table\n\
4180 -n --notes Display the core notes (if present)\n\
4181 -r --relocs Display the relocations (if present)\n\
4182 -u --unwind Display the unwind info (if present)\n\
4183 -d --dynamic Display the dynamic section (if present)\n\
4184 -V --version-info Display the version sections (if present)\n\
4185 -A --arch-specific Display architecture specific information (if any)\n\
4186 -c --archive-index Display the symbol/file index in an archive\n\
4187 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4188 -x --hex-dump=<number|name>\n\
4189 Dump the contents of section <number|name> as bytes\n\
4190 -p --string-dump=<number|name>\n\
4191 Dump the contents of section <number|name> as strings\n\
4192 -R --relocated-dump=<number|name>\n\
4193 Dump the contents of section <number|name> as relocated bytes\n\
4194 -z --decompress Decompress section before dumping it\n\
4195 -w[lLiaprmfFsoRt] or\n\
4196 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4197 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4198 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4200 Display the contents of DWARF2 debug sections\n"));
4201 fprintf (stream, _("\
4202 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4203 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4205 #ifdef SUPPORT_DISASSEMBLY
4206 fprintf (stream, _("\
4207 -i --instruction-dump=<number|name>\n\
4208 Disassemble the contents of section <number|name>\n"));
4210 fprintf (stream, _("\
4211 -I --histogram Display histogram of bucket list lengths\n\
4212 -W --wide Allow output width to exceed 80 characters\n\
4213 @<file> Read options from <file>\n\
4214 -H --help Display this information\n\
4215 -v --version Display the version number of readelf\n"));
4217 if (REPORT_BUGS_TO[0] && stream == stdout)
4218 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4220 exit (stream == stdout ? 0 : 1);
4223 /* Record the fact that the user wants the contents of section number
4224 SECTION to be displayed using the method(s) encoded as flags bits
4225 in TYPE. Note, TYPE can be zero if we are creating the array for
4229 request_dump_bynumber (unsigned int section, dump_type type)
4231 if (section >= num_dump_sects)
4233 dump_type * new_dump_sects;
4235 new_dump_sects = (dump_type *) calloc (section + 1,
4236 sizeof (* dump_sects));
4238 if (new_dump_sects == NULL)
4239 error (_("Out of memory allocating dump request table.\n"));
4242 /* Copy current flag settings. */
4243 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4247 dump_sects = new_dump_sects;
4248 num_dump_sects = section + 1;
4253 dump_sects[section] |= type;
4258 /* Request a dump by section name. */
4261 request_dump_byname (const char * section, dump_type type)
4263 struct dump_list_entry * new_request;
4265 new_request = (struct dump_list_entry *)
4266 malloc (sizeof (struct dump_list_entry));
4268 error (_("Out of memory allocating dump request table.\n"));
4270 new_request->name = strdup (section);
4271 if (!new_request->name)
4272 error (_("Out of memory allocating dump request table.\n"));
4274 new_request->type = type;
4276 new_request->next = dump_sects_byname;
4277 dump_sects_byname = new_request;
4281 request_dump (dump_type type)
4287 section = strtoul (optarg, & cp, 0);
4289 if (! *cp && section >= 0)
4290 request_dump_bynumber (section, type);
4292 request_dump_byname (optarg, type);
4297 parse_args (int argc, char ** argv)
4304 while ((c = getopt_long
4305 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4323 do_section_groups++;
4331 do_section_groups++;
4336 do_section_details++;
4380 request_dump (HEX_DUMP);
4383 request_dump (STRING_DUMP);
4386 request_dump (RELOC_DUMP);
4396 dwarf_select_sections_all ();
4401 dwarf_select_sections_by_letters (optarg);
4404 case OPTION_DEBUG_DUMP:
4411 dwarf_select_sections_by_names (optarg);
4414 case OPTION_DWARF_DEPTH:
4418 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4421 case OPTION_DWARF_START:
4425 dwarf_start_die = strtoul (optarg, & cp, 0);
4428 case OPTION_DWARF_CHECK:
4431 case OPTION_DYN_SYMS:
4434 #ifdef SUPPORT_DISASSEMBLY
4436 request_dump (DISASS_DUMP);
4440 print_version (program_name);
4449 /* xgettext:c-format */
4450 error (_("Invalid option '-%c'\n"), c);
4457 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4458 && !do_segments && !do_header && !do_dump && !do_version
4459 && !do_histogram && !do_debugging && !do_arch && !do_notes
4460 && !do_section_groups && !do_archive_index
4466 get_elf_class (unsigned int elf_class)
4468 static char buff[32];
4472 case ELFCLASSNONE: return _("none");
4473 case ELFCLASS32: return "ELF32";
4474 case ELFCLASS64: return "ELF64";
4476 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4482 get_data_encoding (unsigned int encoding)
4484 static char buff[32];
4488 case ELFDATANONE: return _("none");
4489 case ELFDATA2LSB: return _("2's complement, little endian");
4490 case ELFDATA2MSB: return _("2's complement, big endian");
4492 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4497 /* Decode the data held in 'elf_header'. */
4500 process_file_header (void)
4502 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4503 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4504 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4505 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4508 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4512 init_dwarf_regnames (elf_header.e_machine);
4518 printf (_("ELF Header:\n"));
4519 printf (_(" Magic: "));
4520 for (i = 0; i < EI_NIDENT; i++)
4521 printf ("%2.2x ", elf_header.e_ident[i]);
4523 printf (_(" Class: %s\n"),
4524 get_elf_class (elf_header.e_ident[EI_CLASS]));
4525 printf (_(" Data: %s\n"),
4526 get_data_encoding (elf_header.e_ident[EI_DATA]));
4527 printf (_(" Version: %d %s\n"),
4528 elf_header.e_ident[EI_VERSION],
4529 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4531 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4532 ? _("<unknown: %lx>")
4534 printf (_(" OS/ABI: %s\n"),
4535 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4536 printf (_(" ABI Version: %d\n"),
4537 elf_header.e_ident[EI_ABIVERSION]);
4538 printf (_(" Type: %s\n"),
4539 get_file_type (elf_header.e_type));
4540 printf (_(" Machine: %s\n"),
4541 get_machine_name (elf_header.e_machine));
4542 printf (_(" Version: 0x%lx\n"),
4543 (unsigned long) elf_header.e_version);
4545 printf (_(" Entry point address: "));
4546 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4547 printf (_("\n Start of program headers: "));
4548 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4549 printf (_(" (bytes into file)\n Start of section headers: "));
4550 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4551 printf (_(" (bytes into file)\n"));
4553 printf (_(" Flags: 0x%lx%s\n"),
4554 (unsigned long) elf_header.e_flags,
4555 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4556 printf (_(" Size of this header: %ld (bytes)\n"),
4557 (long) elf_header.e_ehsize);
4558 printf (_(" Size of program headers: %ld (bytes)\n"),
4559 (long) elf_header.e_phentsize);
4560 printf (_(" Number of program headers: %ld"),
4561 (long) elf_header.e_phnum);
4562 if (section_headers != NULL
4563 && elf_header.e_phnum == PN_XNUM
4564 && section_headers[0].sh_info != 0)
4565 printf (" (%ld)", (long) section_headers[0].sh_info);
4566 putc ('\n', stdout);
4567 printf (_(" Size of section headers: %ld (bytes)\n"),
4568 (long) elf_header.e_shentsize);
4569 printf (_(" Number of section headers: %ld"),
4570 (long) elf_header.e_shnum);
4571 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4572 printf (" (%ld)", (long) section_headers[0].sh_size);
4573 putc ('\n', stdout);
4574 printf (_(" Section header string table index: %ld"),
4575 (long) elf_header.e_shstrndx);
4576 if (section_headers != NULL
4577 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4578 printf (" (%u)", section_headers[0].sh_link);
4579 else if (elf_header.e_shstrndx != SHN_UNDEF
4580 && elf_header.e_shstrndx >= elf_header.e_shnum)
4581 printf (_(" <corrupt: out of range>"));
4582 putc ('\n', stdout);
4585 if (section_headers != NULL)
4587 if (elf_header.e_phnum == PN_XNUM
4588 && section_headers[0].sh_info != 0)
4589 elf_header.e_phnum = section_headers[0].sh_info;
4590 if (elf_header.e_shnum == SHN_UNDEF)
4591 elf_header.e_shnum = section_headers[0].sh_size;
4592 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4593 elf_header.e_shstrndx = section_headers[0].sh_link;
4594 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4595 elf_header.e_shstrndx = SHN_UNDEF;
4596 free (section_headers);
4597 section_headers = NULL;
4604 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4606 Elf32_External_Phdr * phdrs;
4607 Elf32_External_Phdr * external;
4608 Elf_Internal_Phdr * internal;
4610 unsigned int size = elf_header.e_phentsize;
4611 unsigned int num = elf_header.e_phnum;
4613 /* PR binutils/17531: Cope with unexpected section header sizes. */
4614 if (size == 0 || num == 0)
4616 if (size < sizeof * phdrs)
4618 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4621 if (size > sizeof * phdrs)
4622 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4624 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4625 size, num, _("program headers"));
4629 for (i = 0, internal = pheaders, external = phdrs;
4630 i < elf_header.e_phnum;
4631 i++, internal++, external++)
4633 internal->p_type = BYTE_GET (external->p_type);
4634 internal->p_offset = BYTE_GET (external->p_offset);
4635 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4636 internal->p_paddr = BYTE_GET (external->p_paddr);
4637 internal->p_filesz = BYTE_GET (external->p_filesz);
4638 internal->p_memsz = BYTE_GET (external->p_memsz);
4639 internal->p_flags = BYTE_GET (external->p_flags);
4640 internal->p_align = BYTE_GET (external->p_align);
4648 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4650 Elf64_External_Phdr * phdrs;
4651 Elf64_External_Phdr * external;
4652 Elf_Internal_Phdr * internal;
4654 unsigned int size = elf_header.e_phentsize;
4655 unsigned int num = elf_header.e_phnum;
4657 /* PR binutils/17531: Cope with unexpected section header sizes. */
4658 if (size == 0 || num == 0)
4660 if (size < sizeof * phdrs)
4662 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4665 if (size > sizeof * phdrs)
4666 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4668 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4669 size, num, _("program headers"));
4673 for (i = 0, internal = pheaders, external = phdrs;
4674 i < elf_header.e_phnum;
4675 i++, internal++, external++)
4677 internal->p_type = BYTE_GET (external->p_type);
4678 internal->p_flags = BYTE_GET (external->p_flags);
4679 internal->p_offset = BYTE_GET (external->p_offset);
4680 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4681 internal->p_paddr = BYTE_GET (external->p_paddr);
4682 internal->p_filesz = BYTE_GET (external->p_filesz);
4683 internal->p_memsz = BYTE_GET (external->p_memsz);
4684 internal->p_align = BYTE_GET (external->p_align);
4691 /* Returns 1 if the program headers were read into `program_headers'. */
4694 get_program_headers (FILE * file)
4696 Elf_Internal_Phdr * phdrs;
4698 /* Check cache of prior read. */
4699 if (program_headers != NULL)
4702 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4703 sizeof (Elf_Internal_Phdr));
4707 error (_("Out of memory reading %u program headers\n"),
4708 elf_header.e_phnum);
4713 ? get_32bit_program_headers (file, phdrs)
4714 : get_64bit_program_headers (file, phdrs))
4716 program_headers = phdrs;
4724 /* Returns 1 if the program headers were loaded. */
4727 process_program_headers (FILE * file)
4729 Elf_Internal_Phdr * segment;
4732 if (elf_header.e_phnum == 0)
4734 /* PR binutils/12467. */
4735 if (elf_header.e_phoff != 0)
4736 warn (_("possibly corrupt ELF header - it has a non-zero program"
4737 " header offset, but no program headers\n"));
4738 else if (do_segments)
4739 printf (_("\nThere are no program headers in this file.\n"));
4743 if (do_segments && !do_header)
4745 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4746 printf (_("Entry point "));
4747 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4748 printf (_("\nThere are %d program headers, starting at offset "),
4749 elf_header.e_phnum);
4750 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4754 if (! get_program_headers (file))
4759 if (elf_header.e_phnum > 1)
4760 printf (_("\nProgram Headers:\n"));
4762 printf (_("\nProgram Headers:\n"));
4766 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4769 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4773 (_(" Type Offset VirtAddr PhysAddr\n"));
4775 (_(" FileSiz MemSiz Flags Align\n"));
4782 for (i = 0, segment = program_headers;
4783 i < elf_header.e_phnum;
4788 printf (" %-14.14s ", get_segment_type (segment->p_type));
4792 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4793 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4794 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4795 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4796 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4798 (segment->p_flags & PF_R ? 'R' : ' '),
4799 (segment->p_flags & PF_W ? 'W' : ' '),
4800 (segment->p_flags & PF_X ? 'E' : ' '));
4801 printf ("%#lx", (unsigned long) segment->p_align);
4805 if ((unsigned long) segment->p_offset == segment->p_offset)
4806 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4809 print_vma (segment->p_offset, FULL_HEX);
4813 print_vma (segment->p_vaddr, FULL_HEX);
4815 print_vma (segment->p_paddr, FULL_HEX);
4818 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4819 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4822 print_vma (segment->p_filesz, FULL_HEX);
4826 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4827 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4830 print_vma (segment->p_memsz, FULL_HEX);
4834 (segment->p_flags & PF_R ? 'R' : ' '),
4835 (segment->p_flags & PF_W ? 'W' : ' '),
4836 (segment->p_flags & PF_X ? 'E' : ' '));
4838 if ((unsigned long) segment->p_align == segment->p_align)
4839 printf ("%#lx", (unsigned long) segment->p_align);
4842 print_vma (segment->p_align, PREFIX_HEX);
4847 print_vma (segment->p_offset, FULL_HEX);
4849 print_vma (segment->p_vaddr, FULL_HEX);
4851 print_vma (segment->p_paddr, FULL_HEX);
4853 print_vma (segment->p_filesz, FULL_HEX);
4855 print_vma (segment->p_memsz, FULL_HEX);
4857 (segment->p_flags & PF_R ? 'R' : ' '),
4858 (segment->p_flags & PF_W ? 'W' : ' '),
4859 (segment->p_flags & PF_X ? 'E' : ' '));
4860 print_vma (segment->p_align, HEX);
4865 putc ('\n', stdout);
4867 switch (segment->p_type)
4871 error (_("more than one dynamic segment\n"));
4873 /* By default, assume that the .dynamic section is the first
4874 section in the DYNAMIC segment. */
4875 dynamic_addr = segment->p_offset;
4876 dynamic_size = segment->p_filesz;
4877 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4878 if (dynamic_addr + dynamic_size >= current_file_size)
4880 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4881 dynamic_addr = dynamic_size = 0;
4884 /* Try to locate the .dynamic section. If there is
4885 a section header table, we can easily locate it. */
4886 if (section_headers != NULL)
4888 Elf_Internal_Shdr * sec;
4890 sec = find_section (".dynamic");
4891 if (sec == NULL || sec->sh_size == 0)
4893 /* A corresponding .dynamic section is expected, but on
4894 IA-64/OpenVMS it is OK for it to be missing. */
4895 if (!is_ia64_vms ())
4896 error (_("no .dynamic section in the dynamic segment\n"));
4900 if (sec->sh_type == SHT_NOBITS)
4906 dynamic_addr = sec->sh_offset;
4907 dynamic_size = sec->sh_size;
4909 if (dynamic_addr < segment->p_offset
4910 || dynamic_addr > segment->p_offset + segment->p_filesz)
4911 warn (_("the .dynamic section is not contained"
4912 " within the dynamic segment\n"));
4913 else if (dynamic_addr > segment->p_offset)
4914 warn (_("the .dynamic section is not the first section"
4915 " in the dynamic segment.\n"));
4920 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4922 error (_("Unable to find program interpreter name\n"));
4926 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4928 if (ret >= (int) sizeof (fmt) || ret < 0)
4929 error (_("Internal error: failed to create format string to display program interpreter\n"));
4931 program_interpreter[0] = 0;
4932 if (fscanf (file, fmt, program_interpreter) <= 0)
4933 error (_("Unable to read program interpreter name\n"));
4936 printf (_(" [Requesting program interpreter: %s]\n"),
4937 program_interpreter);
4943 if (do_segments && section_headers != NULL && string_table != NULL)
4945 printf (_("\n Section to Segment mapping:\n"));
4946 printf (_(" Segment Sections...\n"));
4948 for (i = 0; i < elf_header.e_phnum; i++)
4951 Elf_Internal_Shdr * section;
4953 segment = program_headers + i;
4954 section = section_headers + 1;
4956 printf (" %2.2d ", i);
4958 for (j = 1; j < elf_header.e_shnum; j++, section++)
4960 if (!ELF_TBSS_SPECIAL (section, segment)
4961 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4962 printf ("%s ", printable_section_name (section));
4973 /* Find the file offset corresponding to VMA by using the program headers. */
4976 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4978 Elf_Internal_Phdr * seg;
4980 if (! get_program_headers (file))
4982 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4986 for (seg = program_headers;
4987 seg < program_headers + elf_header.e_phnum;
4990 if (seg->p_type != PT_LOAD)
4993 if (vma >= (seg->p_vaddr & -seg->p_align)
4994 && vma + size <= seg->p_vaddr + seg->p_filesz)
4995 return vma - seg->p_vaddr + seg->p_offset;
4998 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4999 (unsigned long) vma);
5004 /* Allocate memory and load the sections headers into the global pointer
5005 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5006 generate any error messages if the load fails. */
5009 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5011 Elf32_External_Shdr * shdrs;
5012 Elf_Internal_Shdr * internal;
5014 unsigned int size = elf_header.e_shentsize;
5015 unsigned int num = probe ? 1 : elf_header.e_shnum;
5017 /* PR binutils/17531: Cope with unexpected section header sizes. */
5018 if (size == 0 || num == 0)
5020 if (size < sizeof * shdrs)
5023 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5026 if (!probe && size > sizeof * shdrs)
5027 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5029 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5031 probe ? NULL : _("section headers"));
5035 if (section_headers != NULL)
5036 free (section_headers);
5037 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5038 sizeof (Elf_Internal_Shdr));
5039 if (section_headers == NULL)
5042 error (_("Out of memory reading %u section headers\n"), num);
5046 for (i = 0, internal = section_headers;
5050 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5051 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5052 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5053 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5054 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5055 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5056 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5057 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5058 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5059 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5060 if (!probe && internal->sh_link > num)
5061 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5062 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5063 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5071 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5073 Elf64_External_Shdr * shdrs;
5074 Elf_Internal_Shdr * internal;
5076 unsigned int size = elf_header.e_shentsize;
5077 unsigned int num = probe ? 1 : elf_header.e_shnum;
5079 /* PR binutils/17531: Cope with unexpected section header sizes. */
5080 if (size == 0 || num == 0)
5082 if (size < sizeof * shdrs)
5085 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5088 if (! probe && size > sizeof * shdrs)
5089 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5091 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5093 probe ? NULL : _("section headers"));
5097 if (section_headers != NULL)
5098 free (section_headers);
5099 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5100 sizeof (Elf_Internal_Shdr));
5101 if (section_headers == NULL)
5104 error (_("Out of memory reading %u section headers\n"), num);
5108 for (i = 0, internal = section_headers;
5112 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5113 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5114 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5115 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5116 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5117 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5118 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5119 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5120 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5121 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5122 if (!probe && internal->sh_link > num)
5123 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5124 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5125 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5132 static Elf_Internal_Sym *
5133 get_32bit_elf_symbols (FILE * file,
5134 Elf_Internal_Shdr * section,
5135 unsigned long * num_syms_return)
5137 unsigned long number = 0;
5138 Elf32_External_Sym * esyms = NULL;
5139 Elf_External_Sym_Shndx * shndx = NULL;
5140 Elf_Internal_Sym * isyms = NULL;
5141 Elf_Internal_Sym * psym;
5144 if (section->sh_size == 0)
5146 if (num_syms_return != NULL)
5147 * num_syms_return = 0;
5151 /* Run some sanity checks first. */
5152 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5154 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5155 printable_section_name (section), (unsigned long) section->sh_entsize);
5159 if (section->sh_size > current_file_size)
5161 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5162 printable_section_name (section), (unsigned long) section->sh_size);
5166 number = section->sh_size / section->sh_entsize;
5168 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5170 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5171 (unsigned long) section->sh_size,
5172 printable_section_name (section),
5173 (unsigned long) section->sh_entsize);
5177 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5178 section->sh_size, _("symbols"));
5183 elf_section_list * entry;
5186 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5187 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5189 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5190 entry->hdr->sh_offset,
5191 1, entry->hdr->sh_size,
5192 _("symbol table section indicies"));
5195 /* PR17531: file: heap-buffer-overflow */
5196 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5198 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5199 printable_section_name (entry->hdr),
5200 (unsigned long) entry->hdr->sh_size,
5201 (unsigned long) section->sh_size);
5207 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5211 error (_("Out of memory reading %lu symbols\n"),
5212 (unsigned long) number);
5216 for (j = 0, psym = isyms; j < number; j++, psym++)
5218 psym->st_name = BYTE_GET (esyms[j].st_name);
5219 psym->st_value = BYTE_GET (esyms[j].st_value);
5220 psym->st_size = BYTE_GET (esyms[j].st_size);
5221 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5222 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5224 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5225 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5226 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5227 psym->st_info = BYTE_GET (esyms[j].st_info);
5228 psym->st_other = BYTE_GET (esyms[j].st_other);
5237 if (num_syms_return != NULL)
5238 * num_syms_return = isyms == NULL ? 0 : number;
5243 static Elf_Internal_Sym *
5244 get_64bit_elf_symbols (FILE * file,
5245 Elf_Internal_Shdr * section,
5246 unsigned long * num_syms_return)
5248 unsigned long number = 0;
5249 Elf64_External_Sym * esyms = NULL;
5250 Elf_External_Sym_Shndx * shndx = NULL;
5251 Elf_Internal_Sym * isyms = NULL;
5252 Elf_Internal_Sym * psym;
5255 if (section->sh_size == 0)
5257 if (num_syms_return != NULL)
5258 * num_syms_return = 0;
5262 /* Run some sanity checks first. */
5263 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5265 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5266 printable_section_name (section),
5267 (unsigned long) section->sh_entsize);
5271 if (section->sh_size > current_file_size)
5273 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5274 printable_section_name (section),
5275 (unsigned long) section->sh_size);
5279 number = section->sh_size / section->sh_entsize;
5281 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5283 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5284 (unsigned long) section->sh_size,
5285 printable_section_name (section),
5286 (unsigned long) section->sh_entsize);
5290 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5291 section->sh_size, _("symbols"));
5296 elf_section_list * entry;
5299 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5300 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5302 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5303 entry->hdr->sh_offset,
5304 1, entry->hdr->sh_size,
5305 _("symbol table section indicies"));
5308 /* PR17531: file: heap-buffer-overflow */
5309 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5311 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5312 printable_section_name (entry->hdr),
5313 (unsigned long) entry->hdr->sh_size,
5314 (unsigned long) section->sh_size);
5320 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5324 error (_("Out of memory reading %lu symbols\n"),
5325 (unsigned long) number);
5329 for (j = 0, psym = isyms; j < number; j++, psym++)
5331 psym->st_name = BYTE_GET (esyms[j].st_name);
5332 psym->st_info = BYTE_GET (esyms[j].st_info);
5333 psym->st_other = BYTE_GET (esyms[j].st_other);
5334 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5336 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5338 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5339 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5340 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5342 psym->st_value = BYTE_GET (esyms[j].st_value);
5343 psym->st_size = BYTE_GET (esyms[j].st_size);
5352 if (num_syms_return != NULL)
5353 * num_syms_return = isyms == NULL ? 0 : number;
5359 get_elf_section_flags (bfd_vma sh_flags)
5361 static char buff[1024];
5363 int field_size = is_32bit_elf ? 8 : 16;
5365 int size = sizeof (buff) - (field_size + 4 + 1);
5366 bfd_vma os_flags = 0;
5367 bfd_vma proc_flags = 0;
5368 bfd_vma unknown_flags = 0;
5376 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5377 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5378 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5379 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5380 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5381 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5382 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5383 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5384 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5385 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5386 /* IA-64 specific. */
5387 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5388 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5389 /* IA-64 OpenVMS specific. */
5390 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5391 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5392 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5393 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5394 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5395 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5397 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5398 /* SPARC specific. */
5399 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5400 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5402 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5403 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5404 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5407 if (do_section_details)
5409 sprintf (buff, "[%*.*lx]: ",
5410 field_size, field_size, (unsigned long) sh_flags);
5411 p += field_size + 4;
5418 flag = sh_flags & - sh_flags;
5421 if (do_section_details)
5425 case SHF_WRITE: sindex = 0; break;
5426 case SHF_ALLOC: sindex = 1; break;
5427 case SHF_EXECINSTR: sindex = 2; break;
5428 case SHF_MERGE: sindex = 3; break;
5429 case SHF_STRINGS: sindex = 4; break;
5430 case SHF_INFO_LINK: sindex = 5; break;
5431 case SHF_LINK_ORDER: sindex = 6; break;
5432 case SHF_OS_NONCONFORMING: sindex = 7; break;
5433 case SHF_GROUP: sindex = 8; break;
5434 case SHF_TLS: sindex = 9; break;
5435 case SHF_EXCLUDE: sindex = 18; break;
5436 case SHF_COMPRESSED: sindex = 20; break;
5440 switch (elf_header.e_machine)
5443 if (flag == SHF_IA_64_SHORT)
5445 else if (flag == SHF_IA_64_NORECOV)
5448 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5451 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5452 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5453 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5454 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5455 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5456 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5467 case EM_OLD_SPARCV9:
5468 case EM_SPARC32PLUS:
5471 if (flag == SHF_ORDERED)
5478 case SHF_ENTRYSECT: sindex = 21; break;
5479 case SHF_ARM_NOREAD: sindex = 22; break;
5480 case SHF_COMDEF: sindex = 23; break;
5492 if (p != buff + field_size + 4)
5494 if (size < (10 + 2))
5496 warn (_("Internal error: not enough buffer room for section flag info"));
5497 return _("<unknown>");
5504 size -= flags [sindex].len;
5505 p = stpcpy (p, flags [sindex].str);
5507 else if (flag & SHF_MASKOS)
5509 else if (flag & SHF_MASKPROC)
5512 unknown_flags |= flag;
5518 case SHF_WRITE: *p = 'W'; break;
5519 case SHF_ALLOC: *p = 'A'; break;
5520 case SHF_EXECINSTR: *p = 'X'; break;
5521 case SHF_MERGE: *p = 'M'; break;
5522 case SHF_STRINGS: *p = 'S'; break;
5523 case SHF_INFO_LINK: *p = 'I'; break;
5524 case SHF_LINK_ORDER: *p = 'L'; break;
5525 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5526 case SHF_GROUP: *p = 'G'; break;
5527 case SHF_TLS: *p = 'T'; break;
5528 case SHF_EXCLUDE: *p = 'E'; break;
5529 case SHF_COMPRESSED: *p = 'C'; break;
5532 if ((elf_header.e_machine == EM_X86_64
5533 || elf_header.e_machine == EM_L1OM
5534 || elf_header.e_machine == EM_K1OM)
5535 && flag == SHF_X86_64_LARGE)
5537 else if (elf_header.e_machine == EM_ARM
5538 && flag == SHF_ARM_NOREAD)
5540 else if (flag & SHF_MASKOS)
5543 sh_flags &= ~ SHF_MASKOS;
5545 else if (flag & SHF_MASKPROC)
5548 sh_flags &= ~ SHF_MASKPROC;
5558 if (do_section_details)
5562 size -= 5 + field_size;
5563 if (p != buff + field_size + 4)
5567 warn (_("Internal error: not enough buffer room for section flag info"));
5568 return _("<unknown>");
5574 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5575 (unsigned long) os_flags);
5576 p += 5 + field_size;
5580 size -= 7 + field_size;
5581 if (p != buff + field_size + 4)
5585 warn (_("Internal error: not enough buffer room for section flag info"));
5586 return _("<unknown>");
5592 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5593 (unsigned long) proc_flags);
5594 p += 7 + field_size;
5598 size -= 10 + field_size;
5599 if (p != buff + field_size + 4)
5603 warn (_("Internal error: not enough buffer room for section flag info"));
5604 return _("<unknown>");
5610 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5611 (unsigned long) unknown_flags);
5612 p += 10 + field_size;
5621 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
5625 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5626 chdr->ch_type = BYTE_GET (echdr->ch_type);
5627 chdr->ch_size = BYTE_GET (echdr->ch_size);
5628 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5629 return sizeof (*echdr);
5633 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5634 chdr->ch_type = BYTE_GET (echdr->ch_type);
5635 chdr->ch_size = BYTE_GET (echdr->ch_size);
5636 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5637 return sizeof (*echdr);
5642 process_section_headers (FILE * file)
5644 Elf_Internal_Shdr * section;
5647 section_headers = NULL;
5649 if (elf_header.e_shnum == 0)
5651 /* PR binutils/12467. */
5652 if (elf_header.e_shoff != 0)
5653 warn (_("possibly corrupt ELF file header - it has a non-zero"
5654 " section header offset, but no section headers\n"));
5655 else if (do_sections)
5656 printf (_("\nThere are no sections in this file.\n"));
5661 if (do_sections && !do_header)
5662 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5663 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5667 if (! get_32bit_section_headers (file, FALSE))
5670 else if (! get_64bit_section_headers (file, FALSE))
5673 /* Read in the string table, so that we have names to display. */
5674 if (elf_header.e_shstrndx != SHN_UNDEF
5675 && elf_header.e_shstrndx < elf_header.e_shnum)
5677 section = section_headers + elf_header.e_shstrndx;
5679 if (section->sh_size != 0)
5681 string_table = (char *) get_data (NULL, file, section->sh_offset,
5682 1, section->sh_size,
5685 string_table_length = string_table != NULL ? section->sh_size : 0;
5689 /* Scan the sections for the dynamic symbol table
5690 and dynamic string table and debug sections. */
5691 dynamic_symbols = NULL;
5692 dynamic_strings = NULL;
5693 dynamic_syminfo = NULL;
5694 symtab_shndx_list = NULL;
5696 eh_addr_size = is_32bit_elf ? 4 : 8;
5697 switch (elf_header.e_machine)
5700 case EM_MIPS_RS3_LE:
5701 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5702 FDE addresses. However, the ABI also has a semi-official ILP32
5703 variant for which the normal FDE address size rules apply.
5705 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5706 section, where XX is the size of longs in bits. Unfortunately,
5707 earlier compilers provided no way of distinguishing ILP32 objects
5708 from LP64 objects, so if there's any doubt, we should assume that
5709 the official LP64 form is being used. */
5710 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5711 && find_section (".gcc_compiled_long32") == NULL)
5717 switch (elf_header.e_flags & EF_H8_MACH)
5719 case E_H8_MACH_H8300:
5720 case E_H8_MACH_H8300HN:
5721 case E_H8_MACH_H8300SN:
5722 case E_H8_MACH_H8300SXN:
5725 case E_H8_MACH_H8300H:
5726 case E_H8_MACH_H8300S:
5727 case E_H8_MACH_H8300SX:
5735 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5737 case EF_M32C_CPU_M16C:
5744 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5747 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5748 if (section->sh_entsize != expected_entsize) \
5751 sprintf_vma (buf, section->sh_entsize); \
5752 /* Note: coded this way so that there is a single string for \
5754 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5755 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5756 (unsigned) expected_entsize); \
5757 section->sh_entsize = expected_entsize; \
5762 #define CHECK_ENTSIZE(section, i, type) \
5763 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5764 sizeof (Elf64_External_##type))
5766 for (i = 0, section = section_headers;
5767 i < elf_header.e_shnum;
5770 char * name = SECTION_NAME (section);
5772 if (section->sh_type == SHT_DYNSYM)
5774 if (dynamic_symbols != NULL)
5776 error (_("File contains multiple dynamic symbol tables\n"));
5780 CHECK_ENTSIZE (section, i, Sym);
5781 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5783 else if (section->sh_type == SHT_STRTAB
5784 && streq (name, ".dynstr"))
5786 if (dynamic_strings != NULL)
5788 error (_("File contains multiple dynamic string tables\n"));
5792 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5793 1, section->sh_size,
5794 _("dynamic strings"));
5795 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5797 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5799 elf_section_list * entry = xmalloc (sizeof * entry);
5800 entry->hdr = section;
5801 entry->next = symtab_shndx_list;
5802 symtab_shndx_list = entry;
5804 else if (section->sh_type == SHT_SYMTAB)
5805 CHECK_ENTSIZE (section, i, Sym);
5806 else if (section->sh_type == SHT_GROUP)
5807 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5808 else if (section->sh_type == SHT_REL)
5809 CHECK_ENTSIZE (section, i, Rel);
5810 else if (section->sh_type == SHT_RELA)
5811 CHECK_ENTSIZE (section, i, Rela);
5812 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5813 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5814 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5815 || do_debug_str || do_debug_loc || do_debug_ranges
5816 || do_debug_addr || do_debug_cu_index)
5817 && (const_strneq (name, ".debug_")
5818 || const_strneq (name, ".zdebug_")))
5821 name += sizeof (".zdebug_") - 1;
5823 name += sizeof (".debug_") - 1;
5826 || (do_debug_info && const_strneq (name, "info"))
5827 || (do_debug_info && const_strneq (name, "types"))
5828 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5829 || (do_debug_lines && strcmp (name, "line") == 0)
5830 || (do_debug_lines && const_strneq (name, "line."))
5831 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5832 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5833 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5834 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5835 || (do_debug_aranges && const_strneq (name, "aranges"))
5836 || (do_debug_ranges && const_strneq (name, "ranges"))
5837 || (do_debug_frames && const_strneq (name, "frame"))
5838 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5839 || (do_debug_macinfo && const_strneq (name, "macro"))
5840 || (do_debug_str && const_strneq (name, "str"))
5841 || (do_debug_loc && const_strneq (name, "loc"))
5842 || (do_debug_addr && const_strneq (name, "addr"))
5843 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5844 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5846 request_dump_bynumber (i, DEBUG_DUMP);
5848 /* Linkonce section to be combined with .debug_info at link time. */
5849 else if ((do_debugging || do_debug_info)
5850 && const_strneq (name, ".gnu.linkonce.wi."))
5851 request_dump_bynumber (i, DEBUG_DUMP);
5852 else if (do_debug_frames && streq (name, ".eh_frame"))
5853 request_dump_bynumber (i, DEBUG_DUMP);
5854 else if (do_gdb_index && streq (name, ".gdb_index"))
5855 request_dump_bynumber (i, DEBUG_DUMP);
5856 /* Trace sections for Itanium VMS. */
5857 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5858 || do_trace_aranges)
5859 && const_strneq (name, ".trace_"))
5861 name += sizeof (".trace_") - 1;
5864 || (do_trace_info && streq (name, "info"))
5865 || (do_trace_abbrevs && streq (name, "abbrev"))
5866 || (do_trace_aranges && streq (name, "aranges"))
5868 request_dump_bynumber (i, DEBUG_DUMP);
5875 if (elf_header.e_shnum > 1)
5876 printf (_("\nSection Headers:\n"));
5878 printf (_("\nSection Header:\n"));
5882 if (do_section_details)
5884 printf (_(" [Nr] Name\n"));
5885 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5889 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5893 if (do_section_details)
5895 printf (_(" [Nr] Name\n"));
5896 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5900 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5904 if (do_section_details)
5906 printf (_(" [Nr] Name\n"));
5907 printf (_(" Type Address Offset Link\n"));
5908 printf (_(" Size EntSize Info Align\n"));
5912 printf (_(" [Nr] Name Type Address Offset\n"));
5913 printf (_(" Size EntSize Flags Link Info Align\n"));
5917 if (do_section_details)
5918 printf (_(" Flags\n"));
5920 for (i = 0, section = section_headers;
5921 i < elf_header.e_shnum;
5924 /* Check the sh_size field. */
5925 if (section->sh_size > current_file_size
5926 && section->sh_type != SHT_NOBITS
5927 && section->sh_type != SHT_NULL
5928 && section->sh_type < SHT_LOOS)
5929 warn (_("Size of section %u is larger than the entire file!\n"), i);
5931 printf (" [%2u] ", i);
5932 if (do_section_details)
5933 printf ("%s\n ", printable_section_name (section));
5935 print_symbol (-17, SECTION_NAME (section));
5937 printf (do_wide ? " %-15s " : " %-15.15s ",
5938 get_section_type_name (section->sh_type));
5942 const char * link_too_big = NULL;
5944 print_vma (section->sh_addr, LONG_HEX);
5946 printf ( " %6.6lx %6.6lx %2.2lx",
5947 (unsigned long) section->sh_offset,
5948 (unsigned long) section->sh_size,
5949 (unsigned long) section->sh_entsize);
5951 if (do_section_details)
5952 fputs (" ", stdout);
5954 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5956 if (section->sh_link >= elf_header.e_shnum)
5959 /* The sh_link value is out of range. Normally this indicates
5960 an error but it can have special values in Solaris binaries. */
5961 switch (elf_header.e_machine)
5968 case EM_OLD_SPARCV9:
5969 case EM_SPARC32PLUS:
5972 if (section->sh_link == (SHN_BEFORE & 0xffff))
5973 link_too_big = "BEFORE";
5974 else if (section->sh_link == (SHN_AFTER & 0xffff))
5975 link_too_big = "AFTER";
5982 if (do_section_details)
5984 if (link_too_big != NULL && * link_too_big)
5985 printf ("<%s> ", link_too_big);
5987 printf ("%2u ", section->sh_link);
5988 printf ("%3u %2lu\n", section->sh_info,
5989 (unsigned long) section->sh_addralign);
5992 printf ("%2u %3u %2lu\n",
5995 (unsigned long) section->sh_addralign);
5997 if (link_too_big && ! * link_too_big)
5998 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5999 i, section->sh_link);
6003 print_vma (section->sh_addr, LONG_HEX);
6005 if ((long) section->sh_offset == section->sh_offset)
6006 printf (" %6.6lx", (unsigned long) section->sh_offset);
6010 print_vma (section->sh_offset, LONG_HEX);
6013 if ((unsigned long) section->sh_size == section->sh_size)
6014 printf (" %6.6lx", (unsigned long) section->sh_size);
6018 print_vma (section->sh_size, LONG_HEX);
6021 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6022 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6026 print_vma (section->sh_entsize, LONG_HEX);
6029 if (do_section_details)
6030 fputs (" ", stdout);
6032 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6034 printf ("%2u %3u ", section->sh_link, section->sh_info);
6036 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6037 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6040 print_vma (section->sh_addralign, DEC);
6044 else if (do_section_details)
6046 printf (" %-15.15s ",
6047 get_section_type_name (section->sh_type));
6048 print_vma (section->sh_addr, LONG_HEX);
6049 if ((long) section->sh_offset == section->sh_offset)
6050 printf (" %16.16lx", (unsigned long) section->sh_offset);
6054 print_vma (section->sh_offset, LONG_HEX);
6056 printf (" %u\n ", section->sh_link);
6057 print_vma (section->sh_size, LONG_HEX);
6059 print_vma (section->sh_entsize, LONG_HEX);
6061 printf (" %-16u %lu\n",
6063 (unsigned long) section->sh_addralign);
6068 print_vma (section->sh_addr, LONG_HEX);
6069 if ((long) section->sh_offset == section->sh_offset)
6070 printf (" %8.8lx", (unsigned long) section->sh_offset);
6074 print_vma (section->sh_offset, LONG_HEX);
6077 print_vma (section->sh_size, LONG_HEX);
6079 print_vma (section->sh_entsize, LONG_HEX);
6081 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6083 printf (" %2u %3u %lu\n",
6086 (unsigned long) section->sh_addralign);
6089 if (do_section_details)
6091 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6092 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6094 /* Minimum section size is 12 bytes for 32-bit compression
6095 header + 12 bytes for compressed data header. */
6096 unsigned char buf[24];
6097 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6098 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6099 sizeof (buf), _("compression header")))
6101 Elf_Internal_Chdr chdr;
6102 get_compression_header (&chdr, buf);
6103 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6106 printf (_(" [<unknown>: 0x%x], "),
6108 print_vma (chdr.ch_size, LONG_HEX);
6109 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6115 if (!do_section_details)
6117 /* The ordering of the letters shown here matches the ordering of the
6118 corresponding SHF_xxx values, and hence the order in which these
6119 letters will be displayed to the user. */
6120 printf (_("Key to Flags:\n\
6121 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6122 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6123 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6124 if (elf_header.e_machine == EM_X86_64
6125 || elf_header.e_machine == EM_L1OM
6126 || elf_header.e_machine == EM_K1OM)
6127 printf (_("l (large), "));
6128 else if (elf_header.e_machine == EM_ARM)
6129 printf (_("y (noread), "));
6130 printf ("p (processor specific)\n");
6137 get_group_flags (unsigned int flags)
6139 static char buff[128];
6149 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
6156 process_section_groups (FILE * file)
6158 Elf_Internal_Shdr * section;
6160 struct group * group;
6161 Elf_Internal_Shdr * symtab_sec;
6162 Elf_Internal_Shdr * strtab_sec;
6163 Elf_Internal_Sym * symtab;
6164 unsigned long num_syms;
6168 /* Don't process section groups unless needed. */
6169 if (!do_unwind && !do_section_groups)
6172 if (elf_header.e_shnum == 0)
6174 if (do_section_groups)
6175 printf (_("\nThere are no sections to group in this file.\n"));
6180 if (section_headers == NULL)
6182 error (_("Section headers are not available!\n"));
6183 /* PR 13622: This can happen with a corrupt ELF header. */
6187 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6188 sizeof (struct group *));
6190 if (section_headers_groups == NULL)
6192 error (_("Out of memory reading %u section group headers\n"),
6193 elf_header.e_shnum);
6197 /* Scan the sections for the group section. */
6199 for (i = 0, section = section_headers;
6200 i < elf_header.e_shnum;
6202 if (section->sh_type == SHT_GROUP)
6205 if (group_count == 0)
6207 if (do_section_groups)
6208 printf (_("\nThere are no section groups in this file.\n"));
6213 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6215 if (section_groups == NULL)
6217 error (_("Out of memory reading %lu groups\n"),
6218 (unsigned long) group_count);
6228 for (i = 0, section = section_headers, group = section_groups;
6229 i < elf_header.e_shnum;
6232 if (section->sh_type == SHT_GROUP)
6234 const char * name = printable_section_name (section);
6235 const char * group_name;
6236 unsigned char * start;
6237 unsigned char * indices;
6238 unsigned int entry, j, size;
6239 Elf_Internal_Shdr * sec;
6240 Elf_Internal_Sym * sym;
6242 /* Get the symbol table. */
6243 if (section->sh_link >= elf_header.e_shnum
6244 || ((sec = section_headers + section->sh_link)->sh_type
6247 error (_("Bad sh_link in group section `%s'\n"), name);
6251 if (symtab_sec != sec)
6256 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6261 error (_("Corrupt header in group section `%s'\n"), name);
6265 if (section->sh_info >= num_syms)
6267 error (_("Bad sh_info in group section `%s'\n"), name);
6271 sym = symtab + section->sh_info;
6273 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6275 if (sym->st_shndx == 0
6276 || sym->st_shndx >= elf_header.e_shnum)
6278 error (_("Bad sh_info in group section `%s'\n"), name);
6282 group_name = SECTION_NAME (section_headers + sym->st_shndx);
6291 /* Get the string table. */
6292 if (symtab_sec->sh_link >= elf_header.e_shnum)
6301 != (sec = section_headers + symtab_sec->sh_link))
6307 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6308 1, strtab_sec->sh_size,
6310 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6312 group_name = sym->st_name < strtab_size
6313 ? strtab + sym->st_name : _("<corrupt>");
6316 /* PR 17531: file: loop. */
6317 if (section->sh_entsize > section->sh_size)
6319 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6320 printable_section_name (section),
6321 (unsigned long) section->sh_entsize,
6322 (unsigned long) section->sh_size);
6326 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6327 1, section->sh_size,
6333 size = (section->sh_size / section->sh_entsize) - 1;
6334 entry = byte_get (indices, 4);
6337 if (do_section_groups)
6339 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6340 get_group_flags (entry), i, name, group_name, size);
6342 printf (_(" [Index] Name\n"));
6345 group->group_index = i;
6347 for (j = 0; j < size; j++)
6349 struct group_list * g;
6351 entry = byte_get (indices, 4);
6354 if (entry >= elf_header.e_shnum)
6356 static unsigned num_group_errors = 0;
6358 if (num_group_errors ++ < 10)
6360 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6361 entry, i, elf_header.e_shnum - 1);
6362 if (num_group_errors == 10)
6363 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6368 if (section_headers_groups [entry] != NULL)
6372 static unsigned num_errs = 0;
6374 if (num_errs ++ < 10)
6376 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6378 section_headers_groups [entry]->group_index);
6380 warn (_("Further error messages about already contained group sections suppressed\n"));
6386 /* Intel C/C++ compiler may put section 0 in a
6387 section group. We just warn it the first time
6388 and ignore it afterwards. */
6389 static int warned = 0;
6392 error (_("section 0 in group section [%5u]\n"),
6393 section_headers_groups [entry]->group_index);
6399 section_headers_groups [entry] = group;
6401 if (do_section_groups)
6403 sec = section_headers + entry;
6404 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6407 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6408 g->section_index = entry;
6409 g->next = group->root;
6427 /* Data used to display dynamic fixups. */
6429 struct ia64_vms_dynfixup
6431 bfd_vma needed_ident; /* Library ident number. */
6432 bfd_vma needed; /* Index in the dstrtab of the library name. */
6433 bfd_vma fixup_needed; /* Index of the library. */
6434 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6435 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6438 /* Data used to display dynamic relocations. */
6440 struct ia64_vms_dynimgrela
6442 bfd_vma img_rela_cnt; /* Number of relocations. */
6443 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6446 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6450 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6451 const char *strtab, unsigned int strtab_sz)
6453 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6455 const char *lib_name;
6457 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6458 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6459 _("dynamic section image fixups"));
6463 if (fixup->needed < strtab_sz)
6464 lib_name = strtab + fixup->needed;
6467 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6468 (unsigned long) fixup->needed);
6471 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6472 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6474 (_("Seg Offset Type SymVec DataType\n"));
6476 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6481 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6482 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6483 type = BYTE_GET (imfs [i].type);
6484 rtype = elf_ia64_reloc_type (type);
6486 printf (" 0x%08x ", type);
6488 printf (" %-32s ", rtype);
6489 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6490 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6496 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6499 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6501 Elf64_External_VMS_IMAGE_RELA *imrs;
6504 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6505 1, imgrela->img_rela_cnt * sizeof (*imrs),
6506 _("dynamic section image relocations"));
6510 printf (_("\nImage relocs\n"));
6512 (_("Seg Offset Type Addend Seg Sym Off\n"));
6514 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6519 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6520 printf ("%08" BFD_VMA_FMT "x ",
6521 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6522 type = BYTE_GET (imrs [i].type);
6523 rtype = elf_ia64_reloc_type (type);
6525 printf ("0x%08x ", type);
6527 printf ("%-31s ", rtype);
6528 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6529 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6530 printf ("%08" BFD_VMA_FMT "x\n",
6531 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6537 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6540 process_ia64_vms_dynamic_relocs (FILE *file)
6542 struct ia64_vms_dynfixup fixup;
6543 struct ia64_vms_dynimgrela imgrela;
6544 Elf_Internal_Dyn *entry;
6546 bfd_vma strtab_off = 0;
6547 bfd_vma strtab_sz = 0;
6548 char *strtab = NULL;
6550 memset (&fixup, 0, sizeof (fixup));
6551 memset (&imgrela, 0, sizeof (imgrela));
6553 /* Note: the order of the entries is specified by the OpenVMS specs. */
6554 for (entry = dynamic_section;
6555 entry < dynamic_section + dynamic_nent;
6558 switch (entry->d_tag)
6560 case DT_IA_64_VMS_STRTAB_OFFSET:
6561 strtab_off = entry->d_un.d_val;
6564 strtab_sz = entry->d_un.d_val;
6566 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6567 1, strtab_sz, _("dynamic string section"));
6570 case DT_IA_64_VMS_NEEDED_IDENT:
6571 fixup.needed_ident = entry->d_un.d_val;
6574 fixup.needed = entry->d_un.d_val;
6576 case DT_IA_64_VMS_FIXUP_NEEDED:
6577 fixup.fixup_needed = entry->d_un.d_val;
6579 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6580 fixup.fixup_rela_cnt = entry->d_un.d_val;
6582 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6583 fixup.fixup_rela_off = entry->d_un.d_val;
6585 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6588 case DT_IA_64_VMS_IMG_RELA_CNT:
6589 imgrela.img_rela_cnt = entry->d_un.d_val;
6591 case DT_IA_64_VMS_IMG_RELA_OFF:
6592 imgrela.img_rela_off = entry->d_un.d_val;
6594 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6614 } dynamic_relocations [] =
6616 { "REL", DT_REL, DT_RELSZ, FALSE },
6617 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6618 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6621 /* Process the reloc section. */
6624 process_relocs (FILE * file)
6626 unsigned long rel_size;
6627 unsigned long rel_offset;
6633 if (do_using_dynamic)
6637 int has_dynamic_reloc;
6640 has_dynamic_reloc = 0;
6642 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6644 is_rela = dynamic_relocations [i].rela;
6645 name = dynamic_relocations [i].name;
6646 rel_size = dynamic_info [dynamic_relocations [i].size];
6647 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6649 has_dynamic_reloc |= rel_size;
6651 if (is_rela == UNKNOWN)
6653 if (dynamic_relocations [i].reloc == DT_JMPREL)
6654 switch (dynamic_info[DT_PLTREL])
6668 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6669 name, rel_offset, rel_size);
6671 dump_relocations (file,
6672 offset_from_vma (file, rel_offset, rel_size),
6674 dynamic_symbols, num_dynamic_syms,
6675 dynamic_strings, dynamic_strings_length,
6681 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6683 if (! has_dynamic_reloc)
6684 printf (_("\nThere are no dynamic relocations in this file.\n"));
6688 Elf_Internal_Shdr * section;
6692 for (i = 0, section = section_headers;
6693 i < elf_header.e_shnum;
6696 if ( section->sh_type != SHT_RELA
6697 && section->sh_type != SHT_REL)
6700 rel_offset = section->sh_offset;
6701 rel_size = section->sh_size;
6705 Elf_Internal_Shdr * strsec;
6708 printf (_("\nRelocation section "));
6710 if (string_table == NULL)
6711 printf ("%d", section->sh_name);
6713 printf ("'%s'", printable_section_name (section));
6715 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6716 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6718 is_rela = section->sh_type == SHT_RELA;
6720 if (section->sh_link != 0
6721 && section->sh_link < elf_header.e_shnum)
6723 Elf_Internal_Shdr * symsec;
6724 Elf_Internal_Sym * symtab;
6725 unsigned long nsyms;
6726 unsigned long strtablen = 0;
6727 char * strtab = NULL;
6729 symsec = section_headers + section->sh_link;
6730 if (symsec->sh_type != SHT_SYMTAB
6731 && symsec->sh_type != SHT_DYNSYM)
6734 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6739 if (symsec->sh_link != 0
6740 && symsec->sh_link < elf_header.e_shnum)
6742 strsec = section_headers + symsec->sh_link;
6744 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6747 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6750 dump_relocations (file, rel_offset, rel_size,
6751 symtab, nsyms, strtab, strtablen,
6753 symsec->sh_type == SHT_DYNSYM);
6759 dump_relocations (file, rel_offset, rel_size,
6760 NULL, 0, NULL, 0, is_rela, 0);
6767 printf (_("\nThere are no relocations in this file.\n"));
6773 /* An absolute address consists of a section and an offset. If the
6774 section is NULL, the offset itself is the address, otherwise, the
6775 address equals to LOAD_ADDRESS(section) + offset. */
6779 unsigned short section;
6783 #define ABSADDR(a) \
6785 ? section_headers [(a).section].sh_addr + (a).offset \
6788 /* Find the nearest symbol at or below ADDR. Returns the symbol
6789 name, if found, and the offset from the symbol to ADDR. */
6792 find_symbol_for_address (Elf_Internal_Sym * symtab,
6793 unsigned long nsyms,
6794 const char * strtab,
6795 unsigned long strtab_size,
6796 struct absaddr addr,
6797 const char ** symname,
6800 bfd_vma dist = 0x100000;
6801 Elf_Internal_Sym * sym;
6802 Elf_Internal_Sym * beg;
6803 Elf_Internal_Sym * end;
6804 Elf_Internal_Sym * best = NULL;
6806 REMOVE_ARCH_BITS (addr.offset);
6808 end = symtab + nsyms;
6814 sym = beg + (end - beg) / 2;
6816 value = sym->st_value;
6817 REMOVE_ARCH_BITS (value);
6819 if (sym->st_name != 0
6820 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6821 && addr.offset >= value
6822 && addr.offset - value < dist)
6825 dist = addr.offset - value;
6830 if (addr.offset < value)
6838 *symname = (best->st_name >= strtab_size
6839 ? _("<corrupt>") : strtab + best->st_name);
6845 *offset = addr.offset;
6849 symcmp (const void *p, const void *q)
6851 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6852 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6854 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6857 /* Process the unwind section. */
6859 #include "unwind-ia64.h"
6861 struct ia64_unw_table_entry
6863 struct absaddr start;
6865 struct absaddr info;
6868 struct ia64_unw_aux_info
6870 struct ia64_unw_table_entry *table; /* Unwind table. */
6871 unsigned long table_len; /* Length of unwind table. */
6872 unsigned char * info; /* Unwind info. */
6873 unsigned long info_size; /* Size of unwind info. */
6874 bfd_vma info_addr; /* Starting address of unwind info. */
6875 bfd_vma seg_base; /* Starting address of segment. */
6876 Elf_Internal_Sym * symtab; /* The symbol table. */
6877 unsigned long nsyms; /* Number of symbols. */
6878 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6879 unsigned long nfuns; /* Number of entries in funtab. */
6880 char * strtab; /* The string table. */
6881 unsigned long strtab_size; /* Size of string table. */
6885 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6887 struct ia64_unw_table_entry * tp;
6888 unsigned long j, nfuns;
6891 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6892 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6893 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6894 aux->funtab[nfuns++] = aux->symtab[j];
6896 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6898 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6902 const unsigned char * dp;
6903 const unsigned char * head;
6904 const unsigned char * end;
6905 const char * procname;
6907 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6908 aux->strtab_size, tp->start, &procname, &offset);
6910 fputs ("\n<", stdout);
6914 fputs (procname, stdout);
6917 printf ("+%lx", (unsigned long) offset);
6920 fputs (">: [", stdout);
6921 print_vma (tp->start.offset, PREFIX_HEX);
6922 fputc ('-', stdout);
6923 print_vma (tp->end.offset, PREFIX_HEX);
6924 printf ("], info at +0x%lx\n",
6925 (unsigned long) (tp->info.offset - aux->seg_base));
6927 /* PR 17531: file: 86232b32. */
6928 if (aux->info == NULL)
6931 /* PR 17531: file: 0997b4d1. */
6932 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6934 warn (_("Invalid offset %lx in table entry %ld\n"),
6935 (long) tp->info.offset, (long) (tp - aux->table));
6939 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6940 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6942 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6943 (unsigned) UNW_VER (stamp),
6944 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6945 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6946 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6947 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6949 if (UNW_VER (stamp) != 1)
6951 printf (_("\tUnknown version.\n"));
6956 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6957 /* PR 17531: file: 16ceda89. */
6958 if (end > aux->info + aux->info_size)
6959 end = aux->info + aux->info_size;
6960 for (dp = head + 8; dp < end;)
6961 dp = unw_decode (dp, in_body, & in_body, end);
6968 slurp_ia64_unwind_table (FILE * file,
6969 struct ia64_unw_aux_info * aux,
6970 Elf_Internal_Shdr * sec)
6972 unsigned long size, nrelas, i;
6973 Elf_Internal_Phdr * seg;
6974 struct ia64_unw_table_entry * tep;
6975 Elf_Internal_Shdr * relsec;
6976 Elf_Internal_Rela * rela;
6977 Elf_Internal_Rela * rp;
6978 unsigned char * table;
6980 Elf_Internal_Sym * sym;
6981 const char * relname;
6985 /* First, find the starting address of the segment that includes
6988 if (elf_header.e_phnum)
6990 if (! get_program_headers (file))
6993 for (seg = program_headers;
6994 seg < program_headers + elf_header.e_phnum;
6997 if (seg->p_type != PT_LOAD)
7000 if (sec->sh_addr >= seg->p_vaddr
7001 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7003 aux->seg_base = seg->p_vaddr;
7009 /* Second, build the unwind table from the contents of the unwind section: */
7010 size = sec->sh_size;
7011 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7016 aux->table_len = size / (3 * eh_addr_size);
7017 aux->table = (struct ia64_unw_table_entry *)
7018 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7021 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7023 tep->start.section = SHN_UNDEF;
7024 tep->end.section = SHN_UNDEF;
7025 tep->info.section = SHN_UNDEF;
7026 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7027 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7028 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7029 tep->start.offset += aux->seg_base;
7030 tep->end.offset += aux->seg_base;
7031 tep->info.offset += aux->seg_base;
7035 /* Third, apply any relocations to the unwind table: */
7036 for (relsec = section_headers;
7037 relsec < section_headers + elf_header.e_shnum;
7040 if (relsec->sh_type != SHT_RELA
7041 || relsec->sh_info >= elf_header.e_shnum
7042 || section_headers + relsec->sh_info != sec)
7045 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7054 for (rp = rela; rp < rela + nrelas; ++rp)
7056 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7057 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7059 /* PR 17531: file: 9fa67536. */
7060 if (relname == NULL)
7062 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7066 if (! const_strneq (relname, "R_IA64_SEGREL"))
7068 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7072 i = rp->r_offset / (3 * eh_addr_size);
7074 /* PR 17531: file: 5bc8d9bf. */
7075 if (i >= aux->table_len)
7077 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7081 switch (rp->r_offset / eh_addr_size % 3)
7084 aux->table[i].start.section = sym->st_shndx;
7085 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7088 aux->table[i].end.section = sym->st_shndx;
7089 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7092 aux->table[i].info.section = sym->st_shndx;
7093 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7107 ia64_process_unwind (FILE * file)
7109 Elf_Internal_Shdr * sec;
7110 Elf_Internal_Shdr * unwsec = NULL;
7111 Elf_Internal_Shdr * strsec;
7112 unsigned long i, unwcount = 0, unwstart = 0;
7113 struct ia64_unw_aux_info aux;
7115 memset (& aux, 0, sizeof (aux));
7117 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7119 if (sec->sh_type == SHT_SYMTAB
7120 && sec->sh_link < elf_header.e_shnum)
7122 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7124 strsec = section_headers + sec->sh_link;
7125 if (aux.strtab != NULL)
7127 error (_("Multiple auxillary string tables encountered\n"));
7130 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7133 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7135 else if (sec->sh_type == SHT_IA_64_UNWIND)
7140 printf (_("\nThere are no unwind sections in this file.\n"));
7142 while (unwcount-- > 0)
7147 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7148 i < elf_header.e_shnum; ++i, ++sec)
7149 if (sec->sh_type == SHT_IA_64_UNWIND)
7154 /* We have already counted the number of SHT_IA64_UNWIND
7155 sections so the loop above should never fail. */
7156 assert (unwsec != NULL);
7159 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7161 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7163 /* We need to find which section group it is in. */
7164 struct group_list * g;
7166 if (section_headers_groups == NULL
7167 || section_headers_groups [i] == NULL)
7168 i = elf_header.e_shnum;
7171 g = section_headers_groups [i]->root;
7173 for (; g != NULL; g = g->next)
7175 sec = section_headers + g->section_index;
7177 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7182 i = elf_header.e_shnum;
7185 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7187 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7188 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7189 suffix = SECTION_NAME (unwsec) + len;
7190 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7192 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7193 && streq (SECTION_NAME (sec) + len2, suffix))
7198 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7199 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7200 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7201 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7203 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7204 suffix = SECTION_NAME (unwsec) + len;
7205 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7207 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7208 && streq (SECTION_NAME (sec) + len2, suffix))
7212 if (i == elf_header.e_shnum)
7214 printf (_("\nCould not find unwind info section for "));
7216 if (string_table == NULL)
7217 printf ("%d", unwsec->sh_name);
7219 printf ("'%s'", printable_section_name (unwsec));
7223 aux.info_addr = sec->sh_addr;
7224 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7227 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7229 printf (_("\nUnwind section "));
7231 if (string_table == NULL)
7232 printf ("%d", unwsec->sh_name);
7234 printf ("'%s'", printable_section_name (unwsec));
7236 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7237 (unsigned long) unwsec->sh_offset,
7238 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7240 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7241 && aux.table_len > 0)
7242 dump_ia64_unwind (& aux);
7245 free ((char *) aux.table);
7247 free ((char *) aux.info);
7256 free ((char *) aux.strtab);
7259 struct hppa_unw_table_entry
7261 struct absaddr start;
7263 unsigned int Cannot_unwind:1; /* 0 */
7264 unsigned int Millicode:1; /* 1 */
7265 unsigned int Millicode_save_sr0:1; /* 2 */
7266 unsigned int Region_description:2; /* 3..4 */
7267 unsigned int reserved1:1; /* 5 */
7268 unsigned int Entry_SR:1; /* 6 */
7269 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
7270 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
7271 unsigned int Args_stored:1; /* 16 */
7272 unsigned int Variable_Frame:1; /* 17 */
7273 unsigned int Separate_Package_Body:1; /* 18 */
7274 unsigned int Frame_Extension_Millicode:1; /* 19 */
7275 unsigned int Stack_Overflow_Check:1; /* 20 */
7276 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
7277 unsigned int Ada_Region:1; /* 22 */
7278 unsigned int cxx_info:1; /* 23 */
7279 unsigned int cxx_try_catch:1; /* 24 */
7280 unsigned int sched_entry_seq:1; /* 25 */
7281 unsigned int reserved2:1; /* 26 */
7282 unsigned int Save_SP:1; /* 27 */
7283 unsigned int Save_RP:1; /* 28 */
7284 unsigned int Save_MRP_in_frame:1; /* 29 */
7285 unsigned int extn_ptr_defined:1; /* 30 */
7286 unsigned int Cleanup_defined:1; /* 31 */
7288 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7289 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7290 unsigned int Large_frame:1; /* 2 */
7291 unsigned int Pseudo_SP_Set:1; /* 3 */
7292 unsigned int reserved4:1; /* 4 */
7293 unsigned int Total_frame_size:27; /* 5..31 */
7296 struct hppa_unw_aux_info
7298 struct hppa_unw_table_entry * table; /* Unwind table. */
7299 unsigned long table_len; /* Length of unwind table. */
7300 bfd_vma seg_base; /* Starting address of segment. */
7301 Elf_Internal_Sym * symtab; /* The symbol table. */
7302 unsigned long nsyms; /* Number of symbols. */
7303 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7304 unsigned long nfuns; /* Number of entries in funtab. */
7305 char * strtab; /* The string table. */
7306 unsigned long strtab_size; /* Size of string table. */
7310 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7312 struct hppa_unw_table_entry * tp;
7313 unsigned long j, nfuns;
7315 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7316 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7317 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7318 aux->funtab[nfuns++] = aux->symtab[j];
7320 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7322 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7325 const char * procname;
7327 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7328 aux->strtab_size, tp->start, &procname,
7331 fputs ("\n<", stdout);
7335 fputs (procname, stdout);
7338 printf ("+%lx", (unsigned long) offset);
7341 fputs (">: [", stdout);
7342 print_vma (tp->start.offset, PREFIX_HEX);
7343 fputc ('-', stdout);
7344 print_vma (tp->end.offset, PREFIX_HEX);
7347 #define PF(_m) if (tp->_m) printf (#_m " ");
7348 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7351 PF(Millicode_save_sr0);
7352 /* PV(Region_description); */
7358 PF(Separate_Package_Body);
7359 PF(Frame_Extension_Millicode);
7360 PF(Stack_Overflow_Check);
7361 PF(Two_Instruction_SP_Increment);
7365 PF(sched_entry_seq);
7368 PF(Save_MRP_in_frame);
7369 PF(extn_ptr_defined);
7370 PF(Cleanup_defined);
7371 PF(MPE_XL_interrupt_marker);
7372 PF(HP_UX_interrupt_marker);
7375 PV(Total_frame_size);
7386 slurp_hppa_unwind_table (FILE * file,
7387 struct hppa_unw_aux_info * aux,
7388 Elf_Internal_Shdr * sec)
7390 unsigned long size, unw_ent_size, nentries, nrelas, i;
7391 Elf_Internal_Phdr * seg;
7392 struct hppa_unw_table_entry * tep;
7393 Elf_Internal_Shdr * relsec;
7394 Elf_Internal_Rela * rela;
7395 Elf_Internal_Rela * rp;
7396 unsigned char * table;
7398 Elf_Internal_Sym * sym;
7399 const char * relname;
7401 /* First, find the starting address of the segment that includes
7404 if (elf_header.e_phnum)
7406 if (! get_program_headers (file))
7409 for (seg = program_headers;
7410 seg < program_headers + elf_header.e_phnum;
7413 if (seg->p_type != PT_LOAD)
7416 if (sec->sh_addr >= seg->p_vaddr
7417 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7419 aux->seg_base = seg->p_vaddr;
7425 /* Second, build the unwind table from the contents of the unwind
7427 size = sec->sh_size;
7428 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7434 nentries = size / unw_ent_size;
7435 size = unw_ent_size * nentries;
7437 tep = aux->table = (struct hppa_unw_table_entry *)
7438 xcmalloc (nentries, sizeof (aux->table[0]));
7440 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7442 unsigned int tmp1, tmp2;
7444 tep->start.section = SHN_UNDEF;
7445 tep->end.section = SHN_UNDEF;
7447 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7448 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7449 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7450 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7452 tep->start.offset += aux->seg_base;
7453 tep->end.offset += aux->seg_base;
7455 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7456 tep->Millicode = (tmp1 >> 30) & 0x1;
7457 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7458 tep->Region_description = (tmp1 >> 27) & 0x3;
7459 tep->reserved1 = (tmp1 >> 26) & 0x1;
7460 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7461 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7462 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7463 tep->Args_stored = (tmp1 >> 15) & 0x1;
7464 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7465 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7466 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7467 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7468 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7469 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7470 tep->cxx_info = (tmp1 >> 8) & 0x1;
7471 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7472 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7473 tep->reserved2 = (tmp1 >> 5) & 0x1;
7474 tep->Save_SP = (tmp1 >> 4) & 0x1;
7475 tep->Save_RP = (tmp1 >> 3) & 0x1;
7476 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7477 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7478 tep->Cleanup_defined = tmp1 & 0x1;
7480 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7481 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7482 tep->Large_frame = (tmp2 >> 29) & 0x1;
7483 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7484 tep->reserved4 = (tmp2 >> 27) & 0x1;
7485 tep->Total_frame_size = tmp2 & 0x7ffffff;
7489 /* Third, apply any relocations to the unwind table. */
7490 for (relsec = section_headers;
7491 relsec < section_headers + elf_header.e_shnum;
7494 if (relsec->sh_type != SHT_RELA
7495 || relsec->sh_info >= elf_header.e_shnum
7496 || section_headers + relsec->sh_info != sec)
7499 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7503 for (rp = rela; rp < rela + nrelas; ++rp)
7505 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7506 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7508 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7509 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7511 warn (_("Skipping unexpected relocation type %s\n"), relname);
7515 i = rp->r_offset / unw_ent_size;
7517 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7520 aux->table[i].start.section = sym->st_shndx;
7521 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7524 aux->table[i].end.section = sym->st_shndx;
7525 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7535 aux->table_len = nentries;
7541 hppa_process_unwind (FILE * file)
7543 struct hppa_unw_aux_info aux;
7544 Elf_Internal_Shdr * unwsec = NULL;
7545 Elf_Internal_Shdr * strsec;
7546 Elf_Internal_Shdr * sec;
7549 if (string_table == NULL)
7552 memset (& aux, 0, sizeof (aux));
7554 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7556 if (sec->sh_type == SHT_SYMTAB
7557 && sec->sh_link < elf_header.e_shnum)
7559 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7561 strsec = section_headers + sec->sh_link;
7562 if (aux.strtab != NULL)
7564 error (_("Multiple auxillary string tables encountered\n"));
7567 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7570 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7572 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7577 printf (_("\nThere are no unwind sections in this file.\n"));
7579 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7581 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7583 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7584 printable_section_name (sec),
7585 (unsigned long) sec->sh_offset,
7586 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7588 slurp_hppa_unwind_table (file, &aux, sec);
7589 if (aux.table_len > 0)
7590 dump_hppa_unwind (&aux);
7593 free ((char *) aux.table);
7601 free ((char *) aux.strtab);
7606 unsigned char * data; /* The unwind data. */
7607 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7608 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7609 unsigned long nrelas; /* The number of relocations. */
7610 unsigned int rel_type; /* REL or RELA ? */
7611 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7614 struct arm_unw_aux_info
7616 FILE * file; /* The file containing the unwind sections. */
7617 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7618 unsigned long nsyms; /* Number of symbols. */
7619 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7620 unsigned long nfuns; /* Number of these symbols. */
7621 char * strtab; /* The file's string table. */
7622 unsigned long strtab_size; /* Size of string table. */
7626 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7627 bfd_vma fn, struct absaddr addr)
7629 const char *procname;
7632 if (addr.section == SHN_UNDEF)
7635 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7636 aux->strtab_size, addr, &procname,
7639 print_vma (fn, PREFIX_HEX);
7643 fputs (" <", stdout);
7644 fputs (procname, stdout);
7647 printf ("+0x%lx", (unsigned long) sym_offset);
7648 fputc ('>', stdout);
7655 arm_free_section (struct arm_section *arm_sec)
7657 if (arm_sec->data != NULL)
7658 free (arm_sec->data);
7660 if (arm_sec->rela != NULL)
7661 free (arm_sec->rela);
7664 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7665 cached section and install SEC instead.
7666 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7667 and return its valued in * WORDP, relocating if necessary.
7668 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7669 relocation's offset in ADDR.
7670 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7671 into the string table of the symbol associated with the reloc. If no
7672 reloc was applied store -1 there.
7673 5) Return TRUE upon success, FALSE otherwise. */
7676 get_unwind_section_word (struct arm_unw_aux_info * aux,
7677 struct arm_section * arm_sec,
7678 Elf_Internal_Shdr * sec,
7679 bfd_vma word_offset,
7680 unsigned int * wordp,
7681 struct absaddr * addr,
7684 Elf_Internal_Rela *rp;
7685 Elf_Internal_Sym *sym;
7686 const char * relname;
7688 bfd_boolean wrapped;
7690 if (sec == NULL || arm_sec == NULL)
7693 addr->section = SHN_UNDEF;
7696 if (sym_name != NULL)
7697 *sym_name = (bfd_vma) -1;
7699 /* If necessary, update the section cache. */
7700 if (sec != arm_sec->sec)
7702 Elf_Internal_Shdr *relsec;
7704 arm_free_section (arm_sec);
7707 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7708 sec->sh_size, _("unwind data"));
7709 arm_sec->rela = NULL;
7710 arm_sec->nrelas = 0;
7712 for (relsec = section_headers;
7713 relsec < section_headers + elf_header.e_shnum;
7716 if (relsec->sh_info >= elf_header.e_shnum
7717 || section_headers + relsec->sh_info != sec
7718 /* PR 15745: Check the section type as well. */
7719 || (relsec->sh_type != SHT_REL
7720 && relsec->sh_type != SHT_RELA))
7723 arm_sec->rel_type = relsec->sh_type;
7724 if (relsec->sh_type == SHT_REL)
7726 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7728 & arm_sec->rela, & arm_sec->nrelas))
7731 else /* relsec->sh_type == SHT_RELA */
7733 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7735 & arm_sec->rela, & arm_sec->nrelas))
7741 arm_sec->next_rela = arm_sec->rela;
7744 /* If there is no unwind data we can do nothing. */
7745 if (arm_sec->data == NULL)
7748 /* If the offset is invalid then fail. */
7749 if (/* PR 21343 *//* PR 18879 */
7751 || word_offset > (sec->sh_size - 4)
7752 || ((bfd_signed_vma) word_offset) < 0)
7755 /* Get the word at the required offset. */
7756 word = byte_get (arm_sec->data + word_offset, 4);
7758 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7759 if (arm_sec->rela == NULL)
7765 /* Look through the relocs to find the one that applies to the provided offset. */
7767 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7769 bfd_vma prelval, offset;
7771 if (rp->r_offset > word_offset && !wrapped)
7776 if (rp->r_offset > word_offset)
7779 if (rp->r_offset & 3)
7781 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7782 (unsigned long) rp->r_offset);
7786 if (rp->r_offset < word_offset)
7789 /* PR 17531: file: 027-161405-0.004 */
7790 if (aux->symtab == NULL)
7793 if (arm_sec->rel_type == SHT_REL)
7795 offset = word & 0x7fffffff;
7796 if (offset & 0x40000000)
7797 offset |= ~ (bfd_vma) 0x7fffffff;
7799 else if (arm_sec->rel_type == SHT_RELA)
7800 offset = rp->r_addend;
7803 error (_("Unknown section relocation type %d encountered\n"),
7808 /* PR 17531 file: 027-1241568-0.004. */
7809 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7811 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7812 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7816 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7817 offset += sym->st_value;
7818 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7820 /* Check that we are processing the expected reloc type. */
7821 if (elf_header.e_machine == EM_ARM)
7823 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7824 if (relname == NULL)
7826 warn (_("Skipping unknown ARM relocation type: %d\n"),
7827 (int) ELF32_R_TYPE (rp->r_info));
7831 if (streq (relname, "R_ARM_NONE"))
7834 if (! streq (relname, "R_ARM_PREL31"))
7836 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7840 else if (elf_header.e_machine == EM_TI_C6000)
7842 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7843 if (relname == NULL)
7845 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7846 (int) ELF32_R_TYPE (rp->r_info));
7850 if (streq (relname, "R_C6000_NONE"))
7853 if (! streq (relname, "R_C6000_PREL31"))
7855 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7863 /* This function currently only supports ARM and TI unwinders. */
7864 warn (_("Only TI and ARM unwinders are currently supported\n"));
7868 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7869 addr->section = sym->st_shndx;
7870 addr->offset = offset;
7873 * sym_name = sym->st_name;
7878 arm_sec->next_rela = rp;
7883 static const char *tic6x_unwind_regnames[16] =
7885 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7886 "A14", "A13", "A12", "A11", "A10",
7887 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7891 decode_tic6x_unwind_regmask (unsigned int mask)
7895 for (i = 12; mask; mask >>= 1, i--)
7899 fputs (tic6x_unwind_regnames[i], stdout);
7901 fputs (", ", stdout);
7907 if (remaining == 0 && more_words) \
7910 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7911 data_offset, & word, & addr, NULL)) \
7917 #define GET_OP(OP) \
7922 (OP) = word >> 24; \
7927 printf (_("[Truncated opcode]\n")); \
7930 printf ("0x%02x ", OP)
7933 decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7935 unsigned int remaining,
7936 unsigned int more_words,
7937 bfd_vma data_offset,
7938 Elf_Internal_Shdr * data_sec,
7939 struct arm_section * data_arm_sec)
7941 struct absaddr addr;
7943 /* Decode the unwinding instructions. */
7946 unsigned int op, op2;
7955 printf (" 0x%02x ", op);
7957 if ((op & 0xc0) == 0x00)
7959 int offset = ((op & 0x3f) << 2) + 4;
7961 printf (" vsp = vsp + %d", offset);
7963 else if ((op & 0xc0) == 0x40)
7965 int offset = ((op & 0x3f) << 2) + 4;
7967 printf (" vsp = vsp - %d", offset);
7969 else if ((op & 0xf0) == 0x80)
7972 if (op == 0x80 && op2 == 0)
7973 printf (_("Refuse to unwind"));
7976 unsigned int mask = ((op & 0x0f) << 8) | op2;
7981 for (i = 0; i < 12; i++)
7982 if (mask & (1 << i))
7988 printf ("r%d", 4 + i);
7993 else if ((op & 0xf0) == 0x90)
7995 if (op == 0x9d || op == 0x9f)
7996 printf (_(" [Reserved]"));
7998 printf (" vsp = r%d", op & 0x0f);
8000 else if ((op & 0xf0) == 0xa0)
8002 int end = 4 + (op & 0x07);
8007 for (i = 4; i <= end; i++)
8023 else if (op == 0xb0)
8024 printf (_(" finish"));
8025 else if (op == 0xb1)
8028 if (op2 == 0 || (op2 & 0xf0) != 0)
8029 printf (_("[Spare]"));
8032 unsigned int mask = op2 & 0x0f;
8037 for (i = 0; i < 12; i++)
8038 if (mask & (1 << i))
8049 else if (op == 0xb2)
8051 unsigned char buf[9];
8052 unsigned int i, len;
8053 unsigned long offset;
8055 for (i = 0; i < sizeof (buf); i++)
8058 if ((buf[i] & 0x80) == 0)
8061 if (i == sizeof (buf))
8062 printf (_("corrupt change to vsp"));
8065 offset = read_uleb128 (buf, &len, buf + i + 1);
8066 assert (len == i + 1);
8067 offset = offset * 4 + 0x204;
8068 printf ("vsp = vsp + %ld", offset);
8071 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8073 unsigned int first, last;
8080 printf ("pop {D%d", first);
8082 printf ("-D%d", first + last);
8085 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8087 unsigned int count = op & 0x07;
8091 printf ("-D%d", 8 + count);
8094 else if (op >= 0xc0 && op <= 0xc5)
8096 unsigned int count = op & 0x07;
8098 printf (" pop {wR10");
8100 printf ("-wR%d", 10 + count);
8103 else if (op == 0xc6)
8105 unsigned int first, last;
8110 printf ("pop {wR%d", first);
8112 printf ("-wR%d", first + last);
8115 else if (op == 0xc7)
8118 if (op2 == 0 || (op2 & 0xf0) != 0)
8119 printf (_("[Spare]"));
8122 unsigned int mask = op2 & 0x0f;
8127 for (i = 0; i < 4; i++)
8128 if (mask & (1 << i))
8134 printf ("wCGR%d", i);
8140 printf (_(" [unsupported opcode]"));
8146 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8148 unsigned int remaining,
8149 unsigned int more_words,
8150 bfd_vma data_offset,
8151 Elf_Internal_Shdr * data_sec,
8152 struct arm_section * data_arm_sec)
8154 struct absaddr addr;
8156 /* Decode the unwinding instructions. */
8159 unsigned int op, op2;
8168 printf (" 0x%02x ", op);
8170 if ((op & 0xc0) == 0x00)
8172 int offset = ((op & 0x3f) << 3) + 8;
8173 printf (" sp = sp + %d", offset);
8175 else if ((op & 0xc0) == 0x80)
8178 if (op == 0x80 && op2 == 0)
8179 printf (_("Refuse to unwind"));
8182 unsigned int mask = ((op & 0x1f) << 8) | op2;
8184 printf ("pop compact {");
8188 decode_tic6x_unwind_regmask (mask);
8192 else if ((op & 0xf0) == 0xc0)
8200 unsigned int offset;
8204 /* Scan entire instruction first so that GET_OP output is not
8205 interleaved with disassembly. */
8207 for (i = 0; nregs < (op & 0xf); i++)
8213 regpos[nregs].offset = i * 2;
8214 regpos[nregs].reg = reg;
8221 regpos[nregs].offset = i * 2 + 1;
8222 regpos[nregs].reg = reg;
8227 printf (_("pop frame {"));
8229 for (i = i * 2; i > 0; i--)
8231 if (regpos[reg].offset == i - 1)
8233 name = tic6x_unwind_regnames[regpos[reg].reg];
8240 fputs (name, stdout);
8247 else if (op == 0xd0)
8248 printf (" MOV FP, SP");
8249 else if (op == 0xd1)
8250 printf (" __c6xabi_pop_rts");
8251 else if (op == 0xd2)
8253 unsigned char buf[9];
8254 unsigned int i, len;
8255 unsigned long offset;
8257 for (i = 0; i < sizeof (buf); i++)
8260 if ((buf[i] & 0x80) == 0)
8263 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8264 if (i == sizeof (buf))
8266 printf ("<corrupt sp adjust>\n");
8267 warn (_("Corrupt stack pointer adjustment detected\n"));
8271 offset = read_uleb128 (buf, &len, buf + i + 1);
8272 assert (len == i + 1);
8273 offset = offset * 8 + 0x408;
8274 printf (_("sp = sp + %ld"), offset);
8276 else if ((op & 0xf0) == 0xe0)
8278 if ((op & 0x0f) == 7)
8281 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8285 printf (_(" [unsupported opcode]"));
8292 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8296 offset = word & 0x7fffffff;
8297 if (offset & 0x40000000)
8298 offset |= ~ (bfd_vma) 0x7fffffff;
8300 if (elf_header.e_machine == EM_TI_C6000)
8303 return offset + where;
8307 decode_arm_unwind (struct arm_unw_aux_info * aux,
8309 unsigned int remaining,
8310 bfd_vma data_offset,
8311 Elf_Internal_Shdr * data_sec,
8312 struct arm_section * data_arm_sec)
8315 unsigned int more_words = 0;
8316 struct absaddr addr;
8317 bfd_vma sym_name = (bfd_vma) -1;
8321 /* Fetch the first word.
8322 Note - when decoding an object file the address extracted
8323 here will always be 0. So we also pass in the sym_name
8324 parameter so that we can find the symbol associated with
8325 the personality routine. */
8326 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8327 & word, & addr, & sym_name))
8333 if ((word & 0x80000000) == 0)
8335 /* Expand prel31 for personality routine. */
8337 const char *procname;
8339 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8340 printf (_(" Personality routine: "));
8342 && addr.section == SHN_UNDEF && addr.offset == 0
8343 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8345 procname = aux->strtab + sym_name;
8346 print_vma (fn, PREFIX_HEX);
8349 fputs (" <", stdout);
8350 fputs (procname, stdout);
8351 fputc ('>', stdout);
8355 procname = arm_print_vma_and_name (aux, fn, addr);
8356 fputc ('\n', stdout);
8358 /* The GCC personality routines use the standard compact
8359 encoding, starting with one byte giving the number of
8361 if (procname != NULL
8362 && (const_strneq (procname, "__gcc_personality_v0")
8363 || const_strneq (procname, "__gxx_personality_v0")
8364 || const_strneq (procname, "__gcj_personality_v0")
8365 || const_strneq (procname, "__gnu_objc_personality_v0")))
8372 printf (_(" [Truncated data]\n"));
8375 more_words = word >> 24;
8385 /* ARM EHABI Section 6.3:
8387 An exception-handling table entry for the compact model looks like:
8391 1 0 index Data for personalityRoutine[index] */
8393 if (elf_header.e_machine == EM_ARM
8394 && (word & 0x70000000))
8395 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8397 per_index = (word >> 24) & 0x7f;
8398 printf (_(" Compact model index: %d\n"), per_index);
8405 else if (per_index < 3)
8407 more_words = (word >> 16) & 0xff;
8413 switch (elf_header.e_machine)
8418 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8419 data_offset, data_sec, data_arm_sec);
8423 warn (_("Unknown ARM compact model index encountered\n"));
8424 printf (_(" [reserved]\n"));
8431 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8432 data_offset, data_sec, data_arm_sec);
8434 else if (per_index < 5)
8436 if (((word >> 17) & 0x7f) == 0x7f)
8437 printf (_(" Restore stack from frame pointer\n"));
8439 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8440 printf (_(" Registers restored: "));
8442 printf (" (compact) ");
8443 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8445 printf (_(" Return register: %s\n"),
8446 tic6x_unwind_regnames[word & 0xf]);
8449 printf (_(" [reserved (%d)]\n"), per_index);
8453 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8454 elf_header.e_machine);
8457 /* Decode the descriptors. Not implemented. */
8461 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8463 struct arm_section exidx_arm_sec, extab_arm_sec;
8464 unsigned int i, exidx_len;
8465 unsigned long j, nfuns;
8467 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8468 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8469 exidx_len = exidx_sec->sh_size / 8;
8471 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8472 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8473 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8474 aux->funtab[nfuns++] = aux->symtab[j];
8476 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8478 for (i = 0; i < exidx_len; i++)
8480 unsigned int exidx_fn, exidx_entry;
8481 struct absaddr fn_addr, entry_addr;
8484 fputc ('\n', stdout);
8486 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8487 8 * i, & exidx_fn, & fn_addr, NULL)
8488 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8489 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8492 arm_free_section (& exidx_arm_sec);
8493 arm_free_section (& extab_arm_sec);
8497 /* ARM EHABI, Section 5:
8498 An index table entry consists of 2 words.
8499 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8500 if (exidx_fn & 0x80000000)
8501 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8503 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8505 arm_print_vma_and_name (aux, fn, fn_addr);
8506 fputs (": ", stdout);
8508 if (exidx_entry == 1)
8510 print_vma (exidx_entry, PREFIX_HEX);
8511 fputs (" [cantunwind]\n", stdout);
8513 else if (exidx_entry & 0x80000000)
8515 print_vma (exidx_entry, PREFIX_HEX);
8516 fputc ('\n', stdout);
8517 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8521 bfd_vma table, table_offset = 0;
8522 Elf_Internal_Shdr *table_sec;
8524 fputs ("@", stdout);
8525 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8526 print_vma (table, PREFIX_HEX);
8529 /* Locate the matching .ARM.extab. */
8530 if (entry_addr.section != SHN_UNDEF
8531 && entry_addr.section < elf_header.e_shnum)
8533 table_sec = section_headers + entry_addr.section;
8534 table_offset = entry_addr.offset;
8536 if (table_offset > table_sec->sh_size
8537 || ((bfd_signed_vma) table_offset) < 0)
8539 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8540 (unsigned long) table_offset,
8541 printable_section_name (table_sec));
8547 table_sec = find_section_by_address (table);
8548 if (table_sec != NULL)
8549 table_offset = table - table_sec->sh_addr;
8551 if (table_sec == NULL)
8553 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8554 (unsigned long) table);
8557 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8565 arm_free_section (&exidx_arm_sec);
8566 arm_free_section (&extab_arm_sec);
8569 /* Used for both ARM and C6X unwinding tables. */
8572 arm_process_unwind (FILE *file)
8574 struct arm_unw_aux_info aux;
8575 Elf_Internal_Shdr *unwsec = NULL;
8576 Elf_Internal_Shdr *strsec;
8577 Elf_Internal_Shdr *sec;
8579 unsigned int sec_type;
8581 switch (elf_header.e_machine)
8584 sec_type = SHT_ARM_EXIDX;
8588 sec_type = SHT_C6000_UNWIND;
8592 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8593 elf_header.e_machine);
8597 if (string_table == NULL)
8600 memset (& aux, 0, sizeof (aux));
8603 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8605 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8607 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8609 strsec = section_headers + sec->sh_link;
8611 /* PR binutils/17531 file: 011-12666-0.004. */
8612 if (aux.strtab != NULL)
8614 error (_("Multiple string tables found in file.\n"));
8617 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8618 1, strsec->sh_size, _("string table"));
8619 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8621 else if (sec->sh_type == sec_type)
8626 printf (_("\nThere are no unwind sections in this file.\n"));
8628 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8630 if (sec->sh_type == sec_type)
8632 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8633 printable_section_name (sec),
8634 (unsigned long) sec->sh_offset,
8635 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8637 dump_arm_unwind (&aux, sec);
8644 free ((char *) aux.strtab);
8648 process_unwind (FILE * file)
8650 struct unwind_handler
8653 void (* handler)(FILE *);
8656 { EM_ARM, arm_process_unwind },
8657 { EM_IA_64, ia64_process_unwind },
8658 { EM_PARISC, hppa_process_unwind },
8659 { EM_TI_C6000, arm_process_unwind },
8667 for (i = 0; handlers[i].handler != NULL; i++)
8668 if (elf_header.e_machine == handlers[i].machtype)
8670 handlers[i].handler (file);
8674 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8675 get_machine_name (elf_header.e_machine));
8679 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8681 switch (entry->d_tag)
8684 if (entry->d_un.d_val == 0)
8688 static const char * opts[] =
8690 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8691 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8692 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8693 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8699 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8700 if (entry->d_un.d_val & (1 << cnt))
8702 printf ("%s%s", first ? "" : " ", opts[cnt]);
8708 case DT_MIPS_IVERSION:
8709 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8710 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8714 sprintf_vma (buf, entry->d_un.d_ptr);
8715 /* Note: coded this way so that there is a single string for translation. */
8716 printf (_("<corrupt: %s>"), buf);
8720 case DT_MIPS_TIME_STAMP:
8724 time_t atime = entry->d_un.d_val;
8726 tmp = gmtime (&atime);
8727 /* PR 17531: file: 6accc532. */
8729 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8731 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8732 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8733 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8734 printf (_("Time Stamp: %s"), timebuf);
8738 case DT_MIPS_RLD_VERSION:
8739 case DT_MIPS_LOCAL_GOTNO:
8740 case DT_MIPS_CONFLICTNO:
8741 case DT_MIPS_LIBLISTNO:
8742 case DT_MIPS_SYMTABNO:
8743 case DT_MIPS_UNREFEXTNO:
8744 case DT_MIPS_HIPAGENO:
8745 case DT_MIPS_DELTA_CLASS_NO:
8746 case DT_MIPS_DELTA_INSTANCE_NO:
8747 case DT_MIPS_DELTA_RELOC_NO:
8748 case DT_MIPS_DELTA_SYM_NO:
8749 case DT_MIPS_DELTA_CLASSSYM_NO:
8750 case DT_MIPS_COMPACT_SIZE:
8751 print_vma (entry->d_un.d_val, DEC);
8755 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8761 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8763 switch (entry->d_tag)
8765 case DT_HP_DLD_FLAGS:
8774 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8775 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8776 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8777 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8778 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8779 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8780 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8781 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8782 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8783 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8784 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8785 { DT_HP_GST, "HP_GST" },
8786 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8787 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8788 { DT_HP_NODELETE, "HP_NODELETE" },
8789 { DT_HP_GROUP, "HP_GROUP" },
8790 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8794 bfd_vma val = entry->d_un.d_val;
8796 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8797 if (val & flags[cnt].bit)
8801 fputs (flags[cnt].str, stdout);
8803 val ^= flags[cnt].bit;
8806 if (val != 0 || first)
8810 print_vma (val, HEX);
8816 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8824 /* VMS vs Unix time offset and factor. */
8826 #define VMS_EPOCH_OFFSET 35067168000000000LL
8827 #define VMS_GRANULARITY_FACTOR 10000000
8829 /* Display a VMS time in a human readable format. */
8832 print_vms_time (bfd_int64_t vmstime)
8837 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8838 tm = gmtime (&unxtime);
8839 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8840 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8841 tm->tm_hour, tm->tm_min, tm->tm_sec);
8846 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8848 switch (entry->d_tag)
8850 case DT_IA_64_PLT_RESERVE:
8851 /* First 3 slots reserved. */
8852 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8854 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8857 case DT_IA_64_VMS_LINKTIME:
8859 print_vms_time (entry->d_un.d_val);
8863 case DT_IA_64_VMS_LNKFLAGS:
8864 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8865 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8866 printf (" CALL_DEBUG");
8867 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8868 printf (" NOP0BUFS");
8869 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8870 printf (" P0IMAGE");
8871 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8872 printf (" MKTHREADS");
8873 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8874 printf (" UPCALLS");
8875 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8877 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8878 printf (" INITIALIZE");
8879 if (entry->d_un.d_val & VMS_LF_MAIN)
8881 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8882 printf (" EXE_INIT");
8883 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8884 printf (" TBK_IN_IMG");
8885 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8886 printf (" DBG_IN_IMG");
8887 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8888 printf (" TBK_IN_DSF");
8889 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8890 printf (" DBG_IN_DSF");
8891 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8892 printf (" SIGNATURES");
8893 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8894 printf (" REL_SEG_OFF");
8898 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8905 get_32bit_dynamic_section (FILE * file)
8907 Elf32_External_Dyn * edyn;
8908 Elf32_External_Dyn * ext;
8909 Elf_Internal_Dyn * entry;
8911 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8912 dynamic_size, _("dynamic section"));
8916 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8917 might not have the luxury of section headers. Look for the DT_NULL
8918 terminator to determine the number of entries. */
8919 for (ext = edyn, dynamic_nent = 0;
8920 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8924 if (BYTE_GET (ext->d_tag) == DT_NULL)
8928 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8930 if (dynamic_section == NULL)
8932 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8933 (unsigned long) dynamic_nent);
8938 for (ext = edyn, entry = dynamic_section;
8939 entry < dynamic_section + dynamic_nent;
8942 entry->d_tag = BYTE_GET (ext->d_tag);
8943 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8952 get_64bit_dynamic_section (FILE * file)
8954 Elf64_External_Dyn * edyn;
8955 Elf64_External_Dyn * ext;
8956 Elf_Internal_Dyn * entry;
8958 /* Read in the data. */
8959 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8960 dynamic_size, _("dynamic section"));
8964 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8965 might not have the luxury of section headers. Look for the DT_NULL
8966 terminator to determine the number of entries. */
8967 for (ext = edyn, dynamic_nent = 0;
8968 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8969 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
8973 if (BYTE_GET (ext->d_tag) == DT_NULL)
8977 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8979 if (dynamic_section == NULL)
8981 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8982 (unsigned long) dynamic_nent);
8987 /* Convert from external to internal formats. */
8988 for (ext = edyn, entry = dynamic_section;
8989 entry < dynamic_section + dynamic_nent;
8992 entry->d_tag = BYTE_GET (ext->d_tag);
8993 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9002 print_dynamic_flags (bfd_vma flags)
9010 flag = flags & - flags;
9020 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9021 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9022 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9023 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9024 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9025 default: fputs (_("unknown"), stdout); break;
9031 /* Parse and display the contents of the dynamic section. */
9034 process_dynamic_section (FILE * file)
9036 Elf_Internal_Dyn * entry;
9038 if (dynamic_size == 0)
9041 printf (_("\nThere is no dynamic section in this file.\n"));
9048 if (! get_32bit_dynamic_section (file))
9051 else if (! get_64bit_dynamic_section (file))
9054 /* Find the appropriate symbol table. */
9055 if (dynamic_symbols == NULL)
9057 for (entry = dynamic_section;
9058 entry < dynamic_section + dynamic_nent;
9061 Elf_Internal_Shdr section;
9063 if (entry->d_tag != DT_SYMTAB)
9066 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9068 /* Since we do not know how big the symbol table is,
9069 we default to reading in the entire file (!) and
9070 processing that. This is overkill, I know, but it
9072 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9074 if (archive_file_offset != 0)
9075 section.sh_size = archive_file_size - section.sh_offset;
9078 if (fseek (file, 0, SEEK_END))
9079 error (_("Unable to seek to end of file!\n"));
9081 section.sh_size = ftell (file) - section.sh_offset;
9085 section.sh_entsize = sizeof (Elf32_External_Sym);
9087 section.sh_entsize = sizeof (Elf64_External_Sym);
9088 section.sh_name = string_table_length;
9090 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
9091 if (num_dynamic_syms < 1)
9093 error (_("Unable to determine the number of symbols to load\n"));
9099 /* Similarly find a string table. */
9100 if (dynamic_strings == NULL)
9102 for (entry = dynamic_section;
9103 entry < dynamic_section + dynamic_nent;
9106 unsigned long offset;
9109 if (entry->d_tag != DT_STRTAB)
9112 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9114 /* Since we do not know how big the string table is,
9115 we default to reading in the entire file (!) and
9116 processing that. This is overkill, I know, but it
9119 offset = offset_from_vma (file, entry->d_un.d_val, 0);
9121 if (archive_file_offset != 0)
9122 str_tab_len = archive_file_size - offset;
9125 if (fseek (file, 0, SEEK_END))
9126 error (_("Unable to seek to end of file\n"));
9127 str_tab_len = ftell (file) - offset;
9130 if (str_tab_len < 1)
9133 (_("Unable to determine the length of the dynamic string table\n"));
9137 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9139 _("dynamic string table"));
9140 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9145 /* And find the syminfo section if available. */
9146 if (dynamic_syminfo == NULL)
9148 unsigned long syminsz = 0;
9150 for (entry = dynamic_section;
9151 entry < dynamic_section + dynamic_nent;
9154 if (entry->d_tag == DT_SYMINENT)
9156 /* Note: these braces are necessary to avoid a syntax
9157 error from the SunOS4 C compiler. */
9158 /* PR binutils/17531: A corrupt file can trigger this test.
9159 So do not use an assert, instead generate an error message. */
9160 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9161 error (_("Bad value (%d) for SYMINENT entry\n"),
9162 (int) entry->d_un.d_val);
9164 else if (entry->d_tag == DT_SYMINSZ)
9165 syminsz = entry->d_un.d_val;
9166 else if (entry->d_tag == DT_SYMINFO)
9167 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9171 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9173 Elf_External_Syminfo * extsyminfo;
9174 Elf_External_Syminfo * extsym;
9175 Elf_Internal_Syminfo * syminfo;
9177 /* There is a syminfo section. Read the data. */
9178 extsyminfo = (Elf_External_Syminfo *)
9179 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9180 _("symbol information"));
9184 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9185 if (dynamic_syminfo == NULL)
9187 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9188 (unsigned long) syminsz);
9192 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9193 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9194 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9195 ++syminfo, ++extsym)
9197 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9198 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9205 if (do_dynamic && dynamic_addr)
9206 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9207 dynamic_addr, (unsigned long) dynamic_nent);
9209 printf (_(" Tag Type Name/Value\n"));
9211 for (entry = dynamic_section;
9212 entry < dynamic_section + dynamic_nent;
9220 print_vma (entry->d_tag, FULL_HEX);
9221 dtype = get_dynamic_type (entry->d_tag);
9222 printf (" (%s)%*s", dtype,
9223 ((is_32bit_elf ? 27 : 19)
9224 - (int) strlen (dtype)),
9228 switch (entry->d_tag)
9232 print_dynamic_flags (entry->d_un.d_val);
9242 switch (entry->d_tag)
9245 printf (_("Auxiliary library"));
9249 printf (_("Filter library"));
9253 printf (_("Configuration file"));
9257 printf (_("Dependency audit library"));
9261 printf (_("Audit library"));
9265 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9266 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9270 print_vma (entry->d_un.d_val, PREFIX_HEX);
9279 printf (_("Flags:"));
9281 if (entry->d_un.d_val == 0)
9282 printf (_(" None\n"));
9285 unsigned long int val = entry->d_un.d_val;
9287 if (val & DTF_1_PARINIT)
9289 printf (" PARINIT");
9290 val ^= DTF_1_PARINIT;
9292 if (val & DTF_1_CONFEXP)
9294 printf (" CONFEXP");
9295 val ^= DTF_1_CONFEXP;
9298 printf (" %lx", val);
9307 printf (_("Flags:"));
9309 if (entry->d_un.d_val == 0)
9310 printf (_(" None\n"));
9313 unsigned long int val = entry->d_un.d_val;
9315 if (val & DF_P1_LAZYLOAD)
9317 printf (" LAZYLOAD");
9318 val ^= DF_P1_LAZYLOAD;
9320 if (val & DF_P1_GROUPPERM)
9322 printf (" GROUPPERM");
9323 val ^= DF_P1_GROUPPERM;
9326 printf (" %lx", val);
9335 printf (_("Flags:"));
9336 if (entry->d_un.d_val == 0)
9337 printf (_(" None\n"));
9340 unsigned long int val = entry->d_un.d_val;
9347 if (val & DF_1_GLOBAL)
9352 if (val & DF_1_GROUP)
9357 if (val & DF_1_NODELETE)
9359 printf (" NODELETE");
9360 val ^= DF_1_NODELETE;
9362 if (val & DF_1_LOADFLTR)
9364 printf (" LOADFLTR");
9365 val ^= DF_1_LOADFLTR;
9367 if (val & DF_1_INITFIRST)
9369 printf (" INITFIRST");
9370 val ^= DF_1_INITFIRST;
9372 if (val & DF_1_NOOPEN)
9377 if (val & DF_1_ORIGIN)
9382 if (val & DF_1_DIRECT)
9387 if (val & DF_1_TRANS)
9392 if (val & DF_1_INTERPOSE)
9394 printf (" INTERPOSE");
9395 val ^= DF_1_INTERPOSE;
9397 if (val & DF_1_NODEFLIB)
9399 printf (" NODEFLIB");
9400 val ^= DF_1_NODEFLIB;
9402 if (val & DF_1_NODUMP)
9407 if (val & DF_1_CONFALT)
9409 printf (" CONFALT");
9410 val ^= DF_1_CONFALT;
9412 if (val & DF_1_ENDFILTEE)
9414 printf (" ENDFILTEE");
9415 val ^= DF_1_ENDFILTEE;
9417 if (val & DF_1_DISPRELDNE)
9419 printf (" DISPRELDNE");
9420 val ^= DF_1_DISPRELDNE;
9422 if (val & DF_1_DISPRELPND)
9424 printf (" DISPRELPND");
9425 val ^= DF_1_DISPRELPND;
9427 if (val & DF_1_NODIRECT)
9429 printf (" NODIRECT");
9430 val ^= DF_1_NODIRECT;
9432 if (val & DF_1_IGNMULDEF)
9434 printf (" IGNMULDEF");
9435 val ^= DF_1_IGNMULDEF;
9437 if (val & DF_1_NOKSYMS)
9439 printf (" NOKSYMS");
9440 val ^= DF_1_NOKSYMS;
9442 if (val & DF_1_NOHDR)
9447 if (val & DF_1_EDITED)
9452 if (val & DF_1_NORELOC)
9454 printf (" NORELOC");
9455 val ^= DF_1_NORELOC;
9457 if (val & DF_1_SYMINTPOSE)
9459 printf (" SYMINTPOSE");
9460 val ^= DF_1_SYMINTPOSE;
9462 if (val & DF_1_GLOBAUDIT)
9464 printf (" GLOBAUDIT");
9465 val ^= DF_1_GLOBAUDIT;
9467 if (val & DF_1_SINGLETON)
9469 printf (" SINGLETON");
9470 val ^= DF_1_SINGLETON;
9472 if (val & DF_1_STUB)
9483 printf (" %lx", val);
9490 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9492 puts (get_dynamic_type (entry->d_un.d_val));
9512 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9518 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9519 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9525 switch (entry->d_tag)
9528 printf (_("Shared library: [%s]"), name);
9530 if (streq (name, program_interpreter))
9531 printf (_(" program interpreter"));
9535 printf (_("Library soname: [%s]"), name);
9539 printf (_("Library rpath: [%s]"), name);
9543 printf (_("Library runpath: [%s]"), name);
9547 print_vma (entry->d_un.d_val, PREFIX_HEX);
9552 print_vma (entry->d_un.d_val, PREFIX_HEX);
9565 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9569 case DT_INIT_ARRAYSZ:
9570 case DT_FINI_ARRAYSZ:
9571 case DT_GNU_CONFLICTSZ:
9572 case DT_GNU_LIBLISTSZ:
9575 print_vma (entry->d_un.d_val, UNSIGNED);
9576 printf (_(" (bytes)\n"));
9586 print_vma (entry->d_un.d_val, UNSIGNED);
9599 if (entry->d_tag == DT_USED
9600 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9602 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9606 printf (_("Not needed object: [%s]\n"), name);
9611 print_vma (entry->d_un.d_val, PREFIX_HEX);
9617 /* The value of this entry is ignored. */
9622 case DT_GNU_PRELINKED:
9626 time_t atime = entry->d_un.d_val;
9628 tmp = gmtime (&atime);
9629 /* PR 17533 file: 041-1244816-0.004. */
9631 printf (_("<corrupt time val: %lx"),
9632 (unsigned long) atime);
9634 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9635 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9636 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9642 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9645 print_vma (entry->d_un.d_val, PREFIX_HEX);
9651 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9652 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9657 switch (elf_header.e_machine)
9660 case EM_MIPS_RS3_LE:
9661 dynamic_section_mips_val (entry);
9664 dynamic_section_parisc_val (entry);
9667 dynamic_section_ia64_val (entry);
9670 print_vma (entry->d_un.d_val, PREFIX_HEX);
9682 get_ver_flags (unsigned int flags)
9684 static char buff[32];
9691 if (flags & VER_FLG_BASE)
9692 strcat (buff, "BASE ");
9694 if (flags & VER_FLG_WEAK)
9696 if (flags & VER_FLG_BASE)
9697 strcat (buff, "| ");
9699 strcat (buff, "WEAK ");
9702 if (flags & VER_FLG_INFO)
9704 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9705 strcat (buff, "| ");
9707 strcat (buff, "INFO ");
9710 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9711 strcat (buff, _("| <unknown>"));
9716 /* Display the contents of the version sections. */
9719 process_version_sections (FILE * file)
9721 Elf_Internal_Shdr * section;
9728 for (i = 0, section = section_headers;
9729 i < elf_header.e_shnum;
9732 switch (section->sh_type)
9734 case SHT_GNU_verdef:
9736 Elf_External_Verdef * edefs;
9743 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9744 printable_section_name (section),
9747 printf (_(" Addr: 0x"));
9748 printf_vma (section->sh_addr);
9749 printf (_(" Offset: %#08lx Link: %u (%s)"),
9750 (unsigned long) section->sh_offset, section->sh_link,
9751 printable_section_name_from_index (section->sh_link));
9753 edefs = (Elf_External_Verdef *)
9754 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9755 _("version definition section"));
9758 endbuf = (char *) edefs + section->sh_size;
9760 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9763 Elf_External_Verdef * edef;
9764 Elf_Internal_Verdef ent;
9765 Elf_External_Verdaux * eaux;
9766 Elf_Internal_Verdaux aux;
9770 /* Check for very large indicies. */
9771 if (idx > (size_t) (endbuf - (char *) edefs))
9774 vstart = ((char *) edefs) + idx;
9775 if (vstart + sizeof (*edef) > endbuf)
9778 edef = (Elf_External_Verdef *) vstart;
9780 ent.vd_version = BYTE_GET (edef->vd_version);
9781 ent.vd_flags = BYTE_GET (edef->vd_flags);
9782 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9783 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9784 ent.vd_hash = BYTE_GET (edef->vd_hash);
9785 ent.vd_aux = BYTE_GET (edef->vd_aux);
9786 ent.vd_next = BYTE_GET (edef->vd_next);
9788 printf (_(" %#06x: Rev: %d Flags: %s"),
9789 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9791 printf (_(" Index: %d Cnt: %d "),
9792 ent.vd_ndx, ent.vd_cnt);
9794 /* Check for overflow. */
9795 if (ent.vd_aux > (size_t) (endbuf - vstart))
9798 vstart += ent.vd_aux;
9800 eaux = (Elf_External_Verdaux *) vstart;
9802 aux.vda_name = BYTE_GET (eaux->vda_name);
9803 aux.vda_next = BYTE_GET (eaux->vda_next);
9805 if (VALID_DYNAMIC_NAME (aux.vda_name))
9806 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9808 printf (_("Name index: %ld\n"), aux.vda_name);
9810 isum = idx + ent.vd_aux;
9812 for (j = 1; j < ent.vd_cnt; j++)
9814 /* Check for overflow. */
9815 if (aux.vda_next > (size_t) (endbuf - vstart))
9818 isum += aux.vda_next;
9819 vstart += aux.vda_next;
9821 eaux = (Elf_External_Verdaux *) vstart;
9822 if (vstart + sizeof (*eaux) > endbuf)
9825 aux.vda_name = BYTE_GET (eaux->vda_name);
9826 aux.vda_next = BYTE_GET (eaux->vda_next);
9828 if (VALID_DYNAMIC_NAME (aux.vda_name))
9829 printf (_(" %#06x: Parent %d: %s\n"),
9830 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9832 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9833 isum, j, aux.vda_name);
9837 printf (_(" Version def aux past end of section\n"));
9839 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9840 if (idx + ent.vd_next <= idx)
9846 if (cnt < section->sh_info)
9847 printf (_(" Version definition past end of section\n"));
9853 case SHT_GNU_verneed:
9855 Elf_External_Verneed * eneed;
9862 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9863 printable_section_name (section), section->sh_info);
9865 printf (_(" Addr: 0x"));
9866 printf_vma (section->sh_addr);
9867 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9868 (unsigned long) section->sh_offset, section->sh_link,
9869 printable_section_name_from_index (section->sh_link));
9871 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9872 section->sh_offset, 1,
9874 _("Version Needs section"));
9877 endbuf = (char *) eneed + section->sh_size;
9879 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9881 Elf_External_Verneed * entry;
9882 Elf_Internal_Verneed ent;
9887 if (idx > (size_t) (endbuf - (char *) eneed))
9890 vstart = ((char *) eneed) + idx;
9891 if (vstart + sizeof (*entry) > endbuf)
9894 entry = (Elf_External_Verneed *) vstart;
9896 ent.vn_version = BYTE_GET (entry->vn_version);
9897 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9898 ent.vn_file = BYTE_GET (entry->vn_file);
9899 ent.vn_aux = BYTE_GET (entry->vn_aux);
9900 ent.vn_next = BYTE_GET (entry->vn_next);
9902 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9904 if (VALID_DYNAMIC_NAME (ent.vn_file))
9905 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9907 printf (_(" File: %lx"), ent.vn_file);
9909 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9911 /* Check for overflow. */
9912 if (ent.vn_aux > (size_t) (endbuf - vstart))
9914 vstart += ent.vn_aux;
9916 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9918 Elf_External_Vernaux * eaux;
9919 Elf_Internal_Vernaux aux;
9921 if (vstart + sizeof (*eaux) > endbuf)
9923 eaux = (Elf_External_Vernaux *) vstart;
9925 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9926 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9927 aux.vna_other = BYTE_GET (eaux->vna_other);
9928 aux.vna_name = BYTE_GET (eaux->vna_name);
9929 aux.vna_next = BYTE_GET (eaux->vna_next);
9931 if (VALID_DYNAMIC_NAME (aux.vna_name))
9932 printf (_(" %#06x: Name: %s"),
9933 isum, GET_DYNAMIC_NAME (aux.vna_name));
9935 printf (_(" %#06x: Name index: %lx"),
9936 isum, aux.vna_name);
9938 printf (_(" Flags: %s Version: %d\n"),
9939 get_ver_flags (aux.vna_flags), aux.vna_other);
9941 /* Check for overflow. */
9942 if (aux.vna_next > (size_t) (endbuf - vstart)
9943 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9945 warn (_("Invalid vna_next field of %lx\n"),
9950 isum += aux.vna_next;
9951 vstart += aux.vna_next;
9955 warn (_("Missing Version Needs auxillary information\n"));
9957 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9959 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9960 cnt = section->sh_info;
9966 if (cnt < section->sh_info)
9967 warn (_("Missing Version Needs information\n"));
9973 case SHT_GNU_versym:
9975 Elf_Internal_Shdr * link_section;
9978 unsigned char * edata;
9979 unsigned short * data;
9981 Elf_Internal_Sym * symbols;
9982 Elf_Internal_Shdr * string_sec;
9983 unsigned long num_syms;
9986 if (section->sh_link >= elf_header.e_shnum)
9989 link_section = section_headers + section->sh_link;
9990 total = section->sh_size / sizeof (Elf_External_Versym);
9992 if (link_section->sh_link >= elf_header.e_shnum)
9997 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9998 if (symbols == NULL)
10001 string_sec = section_headers + link_section->sh_link;
10003 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10004 string_sec->sh_size,
10005 _("version string table"));
10012 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10013 printable_section_name (section), (unsigned long) total);
10015 printf (_(" Addr: "));
10016 printf_vma (section->sh_addr);
10017 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10018 (unsigned long) section->sh_offset, section->sh_link,
10019 printable_section_name (link_section));
10021 off = offset_from_vma (file,
10022 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10023 total * sizeof (short));
10024 edata = (unsigned char *) get_data (NULL, file, off, total,
10026 _("version symbol data"));
10034 data = (short unsigned int *) cmalloc (total, sizeof (short));
10036 for (cnt = total; cnt --;)
10037 data[cnt] = byte_get (edata + cnt * sizeof (short),
10042 for (cnt = 0; cnt < total; cnt += 4)
10046 char *invalid = _("*invalid*");
10048 printf (" %03x:", cnt);
10050 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10051 switch (data[cnt + j])
10054 fputs (_(" 0 (*local*) "), stdout);
10058 fputs (_(" 1 (*global*) "), stdout);
10062 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10063 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10065 /* If this index value is greater than the size of the symbols
10066 array, break to avoid an out-of-bounds read. */
10067 if ((unsigned long)(cnt + j) >= num_syms)
10069 warn (_("invalid index into symbol array\n"));
10074 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10076 Elf_Internal_Verneed ivn;
10077 unsigned long offset;
10079 offset = offset_from_vma
10080 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10081 sizeof (Elf_External_Verneed));
10085 Elf_Internal_Vernaux ivna;
10086 Elf_External_Verneed evn;
10087 Elf_External_Vernaux evna;
10088 unsigned long a_off;
10090 if (get_data (&evn, file, offset, sizeof (evn), 1,
10091 _("version need")) == NULL)
10094 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10095 ivn.vn_next = BYTE_GET (evn.vn_next);
10097 a_off = offset + ivn.vn_aux;
10101 if (get_data (&evna, file, a_off, sizeof (evna),
10102 1, _("version need aux (2)")) == NULL)
10105 ivna.vna_other = 0;
10109 ivna.vna_next = BYTE_GET (evna.vna_next);
10110 ivna.vna_other = BYTE_GET (evna.vna_other);
10113 a_off += ivna.vna_next;
10115 while (ivna.vna_other != data[cnt + j]
10116 && ivna.vna_next != 0);
10118 if (ivna.vna_other == data[cnt + j])
10120 ivna.vna_name = BYTE_GET (evna.vna_name);
10122 if (ivna.vna_name >= string_sec->sh_size)
10125 name = strtab + ivna.vna_name;
10129 offset += ivn.vn_next;
10131 while (ivn.vn_next);
10134 if (data[cnt + j] != 0x8001
10135 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10137 Elf_Internal_Verdef ivd;
10138 Elf_External_Verdef evd;
10139 unsigned long offset;
10141 offset = offset_from_vma
10142 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10147 if (get_data (&evd, file, offset, sizeof (evd), 1,
10148 _("version def")) == NULL)
10151 /* PR 17531: file: 046-1082287-0.004. */
10152 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10157 ivd.vd_next = BYTE_GET (evd.vd_next);
10158 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10161 offset += ivd.vd_next;
10163 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10164 && ivd.vd_next != 0);
10166 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10168 Elf_External_Verdaux evda;
10169 Elf_Internal_Verdaux ivda;
10171 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10173 if (get_data (&evda, file,
10174 offset - ivd.vd_next + ivd.vd_aux,
10176 _("version def aux")) == NULL)
10179 ivda.vda_name = BYTE_GET (evda.vda_name);
10181 if (ivda.vda_name >= string_sec->sh_size)
10183 else if (name != NULL && name != invalid)
10184 name = _("*both*");
10186 name = strtab + ivda.vda_name;
10190 nn += printf ("(%s%-*s",
10192 12 - (int) strlen (name),
10196 printf ("%*c", 18 - nn, ' ');
10214 printf (_("\nNo version information found in this file.\n"));
10219 static const char *
10220 get_symbol_binding (unsigned int binding)
10222 static char buff[32];
10226 case STB_LOCAL: return "LOCAL";
10227 case STB_GLOBAL: return "GLOBAL";
10228 case STB_WEAK: return "WEAK";
10230 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10231 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10233 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10235 if (binding == STB_GNU_UNIQUE
10236 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10237 /* GNU is still using the default value 0. */
10238 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10240 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10243 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10248 static const char *
10249 get_symbol_type (unsigned int type)
10251 static char buff[32];
10255 case STT_NOTYPE: return "NOTYPE";
10256 case STT_OBJECT: return "OBJECT";
10257 case STT_FUNC: return "FUNC";
10258 case STT_SECTION: return "SECTION";
10259 case STT_FILE: return "FILE";
10260 case STT_COMMON: return "COMMON";
10261 case STT_TLS: return "TLS";
10262 case STT_RELC: return "RELC";
10263 case STT_SRELC: return "SRELC";
10265 if (type >= STT_LOPROC && type <= STT_HIPROC)
10267 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10268 return "THUMB_FUNC";
10270 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10273 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10274 return "PARISC_MILLI";
10276 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10278 else if (type >= STT_LOOS && type <= STT_HIOS)
10280 if (elf_header.e_machine == EM_PARISC)
10282 if (type == STT_HP_OPAQUE)
10283 return "HP_OPAQUE";
10284 if (type == STT_HP_STUB)
10288 if (type == STT_GNU_IFUNC
10289 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10290 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10291 /* GNU is still using the default value 0. */
10292 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10295 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10298 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10303 static const char *
10304 get_symbol_visibility (unsigned int visibility)
10306 switch (visibility)
10308 case STV_DEFAULT: return "DEFAULT";
10309 case STV_INTERNAL: return "INTERNAL";
10310 case STV_HIDDEN: return "HIDDEN";
10311 case STV_PROTECTED: return "PROTECTED";
10313 error (_("Unrecognized visibility value: %u"), visibility);
10314 return _("<unknown>");
10318 static const char *
10319 get_solaris_symbol_visibility (unsigned int visibility)
10321 switch (visibility)
10323 case 4: return "EXPORTED";
10324 case 5: return "SINGLETON";
10325 case 6: return "ELIMINATE";
10326 default: return get_symbol_visibility (visibility);
10330 static const char *
10331 get_mips_symbol_other (unsigned int other)
10341 case STO_MICROMIPS:
10342 return "MICROMIPS";
10343 case STO_MICROMIPS | STO_MIPS_PIC:
10344 return "MICROMIPS, MIPS PIC";
10352 static const char *
10353 get_ia64_symbol_other (unsigned int other)
10355 if (is_ia64_vms ())
10357 static char res[32];
10361 /* Function types is for images and .STB files only. */
10362 switch (elf_header.e_type)
10366 switch (VMS_ST_FUNC_TYPE (other))
10368 case VMS_SFT_CODE_ADDR:
10369 strcat (res, " CA");
10371 case VMS_SFT_SYMV_IDX:
10372 strcat (res, " VEC");
10375 strcat (res, " FD");
10377 case VMS_SFT_RESERVE:
10378 strcat (res, " RSV");
10381 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10382 VMS_ST_FUNC_TYPE (other));
10383 strcat (res, " <unknown>");
10390 switch (VMS_ST_LINKAGE (other))
10392 case VMS_STL_IGNORE:
10393 strcat (res, " IGN");
10395 case VMS_STL_RESERVE:
10396 strcat (res, " RSV");
10399 strcat (res, " STD");
10402 strcat (res, " LNK");
10405 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10406 VMS_ST_LINKAGE (other));
10407 strcat (res, " <unknown>");
10419 static const char *
10420 get_ppc64_symbol_other (unsigned int other)
10422 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10424 static char buf[32];
10425 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10426 PPC64_LOCAL_ENTRY_OFFSET (other));
10432 static const char *
10433 get_symbol_other (unsigned int other)
10435 const char * result = NULL;
10436 static char buff [32];
10441 switch (elf_header.e_machine)
10444 result = get_mips_symbol_other (other);
10447 result = get_ia64_symbol_other (other);
10450 result = get_ppc64_symbol_other (other);
10460 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10464 static const char *
10465 get_symbol_index_type (unsigned int type)
10467 static char buff[32];
10471 case SHN_UNDEF: return "UND";
10472 case SHN_ABS: return "ABS";
10473 case SHN_COMMON: return "COM";
10475 if (type == SHN_IA_64_ANSI_COMMON
10476 && elf_header.e_machine == EM_IA_64
10477 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10479 else if ((elf_header.e_machine == EM_X86_64
10480 || elf_header.e_machine == EM_L1OM
10481 || elf_header.e_machine == EM_K1OM)
10482 && type == SHN_X86_64_LCOMMON)
10483 return "LARGE_COM";
10484 else if ((type == SHN_MIPS_SCOMMON
10485 && elf_header.e_machine == EM_MIPS)
10486 || (type == SHN_TIC6X_SCOMMON
10487 && elf_header.e_machine == EM_TI_C6000))
10489 else if (type == SHN_MIPS_SUNDEFINED
10490 && elf_header.e_machine == EM_MIPS)
10492 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10493 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10494 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10495 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10496 else if (type >= SHN_LORESERVE)
10497 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10498 else if (type >= elf_header.e_shnum)
10499 sprintf (buff, _("bad section index[%3d]"), type);
10501 sprintf (buff, "%3d", type);
10509 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10511 unsigned char * e_data;
10514 /* If the size_t type is smaller than the bfd_size_type, eg because
10515 you are building a 32-bit tool on a 64-bit host, then make sure
10516 that when (number) is cast to (size_t) no information is lost. */
10517 if (sizeof (size_t) < sizeof (bfd_size_type)
10518 && (bfd_size_type) ((size_t) number) != number)
10520 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10521 " elements of size %u\n"),
10526 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10527 attempting to allocate memory when the read is bound to fail. */
10528 if (ent_size * number > current_file_size)
10530 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10535 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10536 if (e_data == NULL)
10538 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10543 if (fread (e_data, ent_size, (size_t) number, file) != number)
10545 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10546 number * ent_size);
10551 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10552 if (i_data == NULL)
10554 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10555 " dynamic entries\n"),
10562 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10570 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10572 Elf_Internal_Sym * psym;
10575 n = print_vma (si, DEC_5);
10577 fputs (&" "[n], stdout);
10578 printf (" %3lu: ", hn);
10580 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10582 printf (_("<No info available for dynamic symbol number %lu>\n"),
10583 (unsigned long) si);
10587 psym = dynamic_symbols + si;
10588 print_vma (psym->st_value, LONG_HEX);
10590 print_vma (psym->st_size, DEC_5);
10592 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10593 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10595 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10596 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10599 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10601 printf (" %-7s", get_symbol_visibility (vis));
10602 /* Check to see if any other bits in the st_other field are set.
10603 Note - displaying this information disrupts the layout of the
10604 table being generated, but for the moment this case is very
10606 if (psym->st_other ^ vis)
10607 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10610 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10611 if (VALID_DYNAMIC_NAME (psym->st_name))
10612 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10614 printf (_(" <corrupt: %14ld>"), psym->st_name);
10618 static const char *
10619 get_symbol_version_string (FILE * file,
10620 bfd_boolean is_dynsym,
10621 const char * strtab,
10622 unsigned long int strtab_size,
10624 Elf_Internal_Sym * psym,
10625 enum versioned_symbol_info * sym_info,
10626 unsigned short * vna_other)
10628 unsigned char data[2];
10629 unsigned short vers_data;
10630 unsigned long offset;
10633 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10636 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10637 sizeof data + si * sizeof (vers_data));
10639 if (get_data (&data, file, offset + si * sizeof (vers_data),
10640 sizeof (data), 1, _("version data")) == NULL)
10643 vers_data = byte_get (data, 2);
10645 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10648 /* Usually we'd only see verdef for defined symbols, and verneed for
10649 undefined symbols. However, symbols defined by the linker in
10650 .dynbss for variables copied from a shared library in order to
10651 avoid text relocations are defined yet have verneed. We could
10652 use a heuristic to detect the special case, for example, check
10653 for verneed first on symbols defined in SHT_NOBITS sections, but
10654 it is simpler and more reliable to just look for both verdef and
10655 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10657 if (psym->st_shndx != SHN_UNDEF
10658 && vers_data != 0x8001
10659 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10661 Elf_Internal_Verdef ivd;
10662 Elf_Internal_Verdaux ivda;
10663 Elf_External_Verdaux evda;
10666 off = offset_from_vma (file,
10667 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10668 sizeof (Elf_External_Verdef));
10672 Elf_External_Verdef evd;
10674 if (get_data (&evd, file, off, sizeof (evd), 1,
10675 _("version def")) == NULL)
10683 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10684 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10685 ivd.vd_next = BYTE_GET (evd.vd_next);
10688 off += ivd.vd_next;
10690 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10692 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10694 off -= ivd.vd_next;
10697 if (get_data (&evda, file, off, sizeof (evda), 1,
10698 _("version def aux")) != NULL)
10700 ivda.vda_name = BYTE_GET (evda.vda_name);
10702 if (psym->st_name != ivda.vda_name)
10704 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10705 ? symbol_hidden : symbol_public);
10706 return (ivda.vda_name < strtab_size
10707 ? strtab + ivda.vda_name : _("<corrupt>"));
10713 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10715 Elf_External_Verneed evn;
10716 Elf_Internal_Verneed ivn;
10717 Elf_Internal_Vernaux ivna;
10719 offset = offset_from_vma (file,
10720 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10724 unsigned long vna_off;
10726 if (get_data (&evn, file, offset, sizeof (evn), 1,
10727 _("version need")) == NULL)
10730 ivna.vna_other = 0;
10735 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10736 ivn.vn_next = BYTE_GET (evn.vn_next);
10738 vna_off = offset + ivn.vn_aux;
10742 Elf_External_Vernaux evna;
10744 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
10745 _("version need aux (3)")) == NULL)
10748 ivna.vna_other = 0;
10753 ivna.vna_other = BYTE_GET (evna.vna_other);
10754 ivna.vna_next = BYTE_GET (evna.vna_next);
10755 ivna.vna_name = BYTE_GET (evna.vna_name);
10758 vna_off += ivna.vna_next;
10760 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
10762 if (ivna.vna_other == vers_data)
10765 offset += ivn.vn_next;
10767 while (ivn.vn_next != 0);
10769 if (ivna.vna_other == vers_data)
10771 *sym_info = symbol_undefined;
10772 *vna_other = ivna.vna_other;
10773 return (ivna.vna_name < strtab_size
10774 ? strtab + ivna.vna_name : _("<corrupt>"));
10780 /* Dump the symbol table. */
10782 process_symbol_table (FILE * file)
10784 Elf_Internal_Shdr * section;
10785 bfd_size_type nbuckets = 0;
10786 bfd_size_type nchains = 0;
10787 bfd_vma * buckets = NULL;
10788 bfd_vma * chains = NULL;
10789 bfd_vma ngnubuckets = 0;
10790 bfd_vma * gnubuckets = NULL;
10791 bfd_vma * gnuchains = NULL;
10792 bfd_vma gnusymidx = 0;
10793 bfd_size_type ngnuchains = 0;
10795 if (!do_syms && !do_dyn_syms && !do_histogram)
10798 if (dynamic_info[DT_HASH]
10800 || (do_using_dynamic
10802 && dynamic_strings != NULL)))
10804 unsigned char nb[8];
10805 unsigned char nc[8];
10806 unsigned int hash_ent_size = 4;
10808 if ((elf_header.e_machine == EM_ALPHA
10809 || elf_header.e_machine == EM_S390
10810 || elf_header.e_machine == EM_S390_OLD)
10811 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10815 (archive_file_offset
10816 + offset_from_vma (file, dynamic_info[DT_HASH],
10817 sizeof nb + sizeof nc)),
10820 error (_("Unable to seek to start of dynamic information\n"));
10824 if (fread (nb, hash_ent_size, 1, file) != 1)
10826 error (_("Failed to read in number of buckets\n"));
10830 if (fread (nc, hash_ent_size, 1, file) != 1)
10832 error (_("Failed to read in number of chains\n"));
10836 nbuckets = byte_get (nb, hash_ent_size);
10837 nchains = byte_get (nc, hash_ent_size);
10839 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10840 chains = get_dynamic_data (file, nchains, hash_ent_size);
10843 if (buckets == NULL || chains == NULL)
10845 if (do_using_dynamic)
10856 if (dynamic_info_DT_GNU_HASH
10858 || (do_using_dynamic
10860 && dynamic_strings != NULL)))
10862 unsigned char nb[16];
10863 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10864 bfd_vma buckets_vma;
10867 (archive_file_offset
10868 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10872 error (_("Unable to seek to start of dynamic information\n"));
10876 if (fread (nb, 16, 1, file) != 1)
10878 error (_("Failed to read in number of buckets\n"));
10882 ngnubuckets = byte_get (nb, 4);
10883 gnusymidx = byte_get (nb + 4, 4);
10884 bitmaskwords = byte_get (nb + 8, 4);
10885 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10887 buckets_vma += bitmaskwords * 4;
10889 buckets_vma += bitmaskwords * 8;
10892 (archive_file_offset
10893 + offset_from_vma (file, buckets_vma, 4)),
10896 error (_("Unable to seek to start of dynamic information\n"));
10900 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10902 if (gnubuckets == NULL)
10905 for (i = 0; i < ngnubuckets; i++)
10906 if (gnubuckets[i] != 0)
10908 if (gnubuckets[i] < gnusymidx)
10911 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10912 maxchain = gnubuckets[i];
10915 if (maxchain == 0xffffffff)
10918 maxchain -= gnusymidx;
10921 (archive_file_offset
10922 + offset_from_vma (file, buckets_vma
10923 + 4 * (ngnubuckets + maxchain), 4)),
10926 error (_("Unable to seek to start of dynamic information\n"));
10932 if (fread (nb, 4, 1, file) != 1)
10934 error (_("Failed to determine last chain length\n"));
10938 if (maxchain + 1 == 0)
10943 while ((byte_get (nb, 4) & 1) == 0);
10946 (archive_file_offset
10947 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10950 error (_("Unable to seek to start of dynamic information\n"));
10954 gnuchains = get_dynamic_data (file, maxchain, 4);
10955 ngnuchains = maxchain;
10958 if (gnuchains == NULL)
10963 if (do_using_dynamic)
10968 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10970 && do_using_dynamic
10971 && dynamic_strings != NULL
10972 && dynamic_symbols != NULL)
10976 if (dynamic_info[DT_HASH])
10980 printf (_("\nSymbol table for image:\n"));
10982 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10984 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10986 for (hn = 0; hn < nbuckets; hn++)
10991 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10992 print_dynamic_symbol (si, hn);
10996 if (dynamic_info_DT_GNU_HASH)
10998 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11000 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11002 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11004 for (hn = 0; hn < ngnubuckets; ++hn)
11005 if (gnubuckets[hn] != 0)
11007 bfd_vma si = gnubuckets[hn];
11008 bfd_vma off = si - gnusymidx;
11012 print_dynamic_symbol (si, hn);
11015 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11019 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11020 && section_headers != NULL)
11024 for (i = 0, section = section_headers;
11025 i < elf_header.e_shnum;
11029 char * strtab = NULL;
11030 unsigned long int strtab_size = 0;
11031 Elf_Internal_Sym * symtab;
11032 Elf_Internal_Sym * psym;
11033 unsigned long num_syms;
11035 if ((section->sh_type != SHT_SYMTAB
11036 && section->sh_type != SHT_DYNSYM)
11038 && section->sh_type == SHT_SYMTAB))
11041 if (section->sh_entsize == 0)
11043 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11044 printable_section_name (section));
11048 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11049 printable_section_name (section),
11050 (unsigned long) (section->sh_size / section->sh_entsize));
11053 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11055 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11057 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11058 if (symtab == NULL)
11061 if (section->sh_link == elf_header.e_shstrndx)
11063 strtab = string_table;
11064 strtab_size = string_table_length;
11066 else if (section->sh_link < elf_header.e_shnum)
11068 Elf_Internal_Shdr * string_sec;
11070 string_sec = section_headers + section->sh_link;
11072 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11073 1, string_sec->sh_size,
11074 _("string table"));
11075 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11078 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11080 const char *version_string;
11081 enum versioned_symbol_info sym_info;
11082 unsigned short vna_other;
11084 printf ("%6d: ", si);
11085 print_vma (psym->st_value, LONG_HEX);
11087 print_vma (psym->st_size, DEC_5);
11088 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11089 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11090 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11091 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11094 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11096 printf (" %-7s", get_symbol_visibility (vis));
11097 /* Check to see if any other bits in the st_other field are set.
11098 Note - displaying this information disrupts the layout of the
11099 table being generated, but for the moment this case is very rare. */
11100 if (psym->st_other ^ vis)
11101 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11103 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11104 print_symbol (25, psym->st_name < strtab_size
11105 ? strtab + psym->st_name : _("<corrupt>"));
11108 = get_symbol_version_string (file,
11109 section->sh_type == SHT_DYNSYM,
11110 strtab, strtab_size, si,
11111 psym, &sym_info, &vna_other);
11112 if (version_string)
11114 if (sym_info == symbol_undefined)
11115 printf ("@%s (%d)", version_string, vna_other);
11117 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11125 if (strtab != string_table)
11131 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11133 if (do_histogram && buckets != NULL)
11135 unsigned long * lengths;
11136 unsigned long * counts;
11139 unsigned long maxlength = 0;
11140 unsigned long nzero_counts = 0;
11141 unsigned long nsyms = 0;
11142 unsigned long chained;
11144 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11145 (unsigned long) nbuckets);
11147 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11148 if (lengths == NULL)
11150 error (_("Out of memory allocating space for histogram buckets\n"));
11154 printf (_(" Length Number %% of total Coverage\n"));
11155 for (hn = 0; hn < nbuckets; ++hn)
11157 for (si = buckets[hn], chained = 0;
11158 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11159 si = chains[si], ++chained)
11162 if (maxlength < ++lengths[hn])
11166 /* PR binutils/17531: A corrupt binary could contain broken
11167 histogram data. Do not go into an infinite loop trying
11169 if (chained > nchains)
11171 error (_("histogram chain is corrupt\n"));
11176 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11177 if (counts == NULL)
11180 error (_("Out of memory allocating space for histogram counts\n"));
11184 for (hn = 0; hn < nbuckets; ++hn)
11185 ++counts[lengths[hn]];
11190 printf (" 0 %-10lu (%5.1f%%)\n",
11191 counts[0], (counts[0] * 100.0) / nbuckets);
11192 for (i = 1; i <= maxlength; ++i)
11194 nzero_counts += counts[i] * i;
11195 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11196 i, counts[i], (counts[i] * 100.0) / nbuckets,
11197 (nzero_counts * 100.0) / nsyms);
11205 if (buckets != NULL)
11211 if (do_histogram && gnubuckets != NULL)
11213 unsigned long * lengths;
11214 unsigned long * counts;
11216 unsigned long maxlength = 0;
11217 unsigned long nzero_counts = 0;
11218 unsigned long nsyms = 0;
11220 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11221 (unsigned long) ngnubuckets);
11223 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11224 if (lengths == NULL)
11226 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11230 printf (_(" Length Number %% of total Coverage\n"));
11232 for (hn = 0; hn < ngnubuckets; ++hn)
11233 if (gnubuckets[hn] != 0)
11235 bfd_vma off, length = 1;
11237 for (off = gnubuckets[hn] - gnusymidx;
11238 /* PR 17531 file: 010-77222-0.004. */
11239 off < ngnuchains && (gnuchains[off] & 1) == 0;
11242 lengths[hn] = length;
11243 if (length > maxlength)
11244 maxlength = length;
11248 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11249 if (counts == NULL)
11252 error (_("Out of memory allocating space for gnu histogram counts\n"));
11256 for (hn = 0; hn < ngnubuckets; ++hn)
11257 ++counts[lengths[hn]];
11259 if (ngnubuckets > 0)
11262 printf (" 0 %-10lu (%5.1f%%)\n",
11263 counts[0], (counts[0] * 100.0) / ngnubuckets);
11264 for (j = 1; j <= maxlength; ++j)
11266 nzero_counts += counts[j] * j;
11267 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11268 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11269 (nzero_counts * 100.0) / nsyms);
11283 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11287 if (dynamic_syminfo == NULL
11289 /* No syminfo, this is ok. */
11292 /* There better should be a dynamic symbol section. */
11293 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11297 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11298 dynamic_syminfo_offset, dynamic_syminfo_nent);
11300 printf (_(" Num: Name BoundTo Flags\n"));
11301 for (i = 0; i < dynamic_syminfo_nent; ++i)
11303 unsigned short int flags = dynamic_syminfo[i].si_flags;
11305 printf ("%4d: ", i);
11306 if (i >= num_dynamic_syms)
11307 printf (_("<corrupt index>"));
11308 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11309 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11311 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11314 switch (dynamic_syminfo[i].si_boundto)
11316 case SYMINFO_BT_SELF:
11317 fputs ("SELF ", stdout);
11319 case SYMINFO_BT_PARENT:
11320 fputs ("PARENT ", stdout);
11323 if (dynamic_syminfo[i].si_boundto > 0
11324 && dynamic_syminfo[i].si_boundto < dynamic_nent
11325 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11327 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11331 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11335 if (flags & SYMINFO_FLG_DIRECT)
11336 printf (" DIRECT");
11337 if (flags & SYMINFO_FLG_PASSTHRU)
11338 printf (" PASSTHRU");
11339 if (flags & SYMINFO_FLG_COPY)
11341 if (flags & SYMINFO_FLG_LAZYLOAD)
11342 printf (" LAZYLOAD");
11350 /* Check to see if the given reloc needs to be handled in a target specific
11351 manner. If so then process the reloc and return TRUE otherwise return
11355 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11356 unsigned char * start,
11357 Elf_Internal_Sym * symtab)
11359 unsigned int reloc_type = get_reloc_type (reloc->r_info);
11361 switch (elf_header.e_machine)
11364 case EM_MSP430_OLD:
11366 static Elf_Internal_Sym * saved_sym = NULL;
11368 switch (reloc_type)
11370 case 10: /* R_MSP430_SYM_DIFF */
11371 if (uses_msp430x_relocs ())
11373 case 21: /* R_MSP430X_SYM_DIFF */
11374 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11377 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11378 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11379 goto handle_sym_diff;
11381 case 5: /* R_MSP430_16_BYTE */
11382 case 9: /* R_MSP430_8 */
11383 if (uses_msp430x_relocs ())
11385 goto handle_sym_diff;
11387 case 2: /* R_MSP430_ABS16 */
11388 case 15: /* R_MSP430X_ABS16 */
11389 if (! uses_msp430x_relocs ())
11391 goto handle_sym_diff;
11394 if (saved_sym != NULL)
11398 value = reloc->r_addend
11399 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11400 - saved_sym->st_value);
11402 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11410 if (saved_sym != NULL)
11411 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11418 case EM_CYGNUS_MN10300:
11420 static Elf_Internal_Sym * saved_sym = NULL;
11422 switch (reloc_type)
11424 case 34: /* R_MN10300_ALIGN */
11426 case 33: /* R_MN10300_SYM_DIFF */
11427 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11429 case 1: /* R_MN10300_32 */
11430 case 2: /* R_MN10300_16 */
11431 if (saved_sym != NULL)
11435 value = reloc->r_addend
11436 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11437 - saved_sym->st_value);
11439 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11446 if (saved_sym != NULL)
11447 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11455 static bfd_vma saved_sym1 = 0;
11456 static bfd_vma saved_sym2 = 0;
11457 static bfd_vma value;
11459 switch (reloc_type)
11461 case 0x80: /* R_RL78_SYM. */
11462 saved_sym1 = saved_sym2;
11463 saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
11464 saved_sym2 += reloc->r_addend;
11467 case 0x83: /* R_RL78_OPsub. */
11468 value = saved_sym1 - saved_sym2;
11469 saved_sym2 = saved_sym1 = 0;
11473 case 0x41: /* R_RL78_ABS32. */
11474 byte_put (start + reloc->r_offset, value, 4);
11478 case 0x43: /* R_RL78_ABS16. */
11479 byte_put (start + reloc->r_offset, value, 2);
11493 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11494 DWARF debug sections. This is a target specific test. Note - we do not
11495 go through the whole including-target-headers-multiple-times route, (as
11496 we have already done with <elf/h8.h>) because this would become very
11497 messy and even then this function would have to contain target specific
11498 information (the names of the relocs instead of their numeric values).
11499 FIXME: This is not the correct way to solve this problem. The proper way
11500 is to have target specific reloc sizing and typing functions created by
11501 the reloc-macros.h header, in the same way that it already creates the
11502 reloc naming functions. */
11505 is_32bit_abs_reloc (unsigned int reloc_type)
11507 /* Please keep this table alpha-sorted for ease of visual lookup. */
11508 switch (elf_header.e_machine)
11512 return reloc_type == 1; /* R_386_32. */
11514 return reloc_type == 1; /* R_68K_32. */
11516 return reloc_type == 1; /* R_860_32. */
11518 return reloc_type == 2; /* R_960_32. */
11520 return reloc_type == 258; /* R_AARCH64_ABS32 */
11521 case EM_ADAPTEVA_EPIPHANY:
11522 return reloc_type == 3;
11524 return reloc_type == 1; /* R_ALPHA_REFLONG. */
11526 return reloc_type == 1; /* R_ARC_32. */
11527 case EM_ARC_COMPACT:
11528 case EM_ARC_COMPACT2:
11529 return reloc_type == 4; /* R_ARC_32. */
11531 return reloc_type == 2; /* R_ARM_ABS32 */
11534 return reloc_type == 1;
11536 return reloc_type == 0x12; /* R_byte4_data. */
11538 return reloc_type == 3; /* R_CRIS_32. */
11540 return reloc_type == 3; /* R_CR16_NUM32. */
11542 return reloc_type == 15; /* R_CRX_NUM32. */
11543 case EM_CYGNUS_FRV:
11544 return reloc_type == 1;
11545 case EM_CYGNUS_D10V:
11547 return reloc_type == 6; /* R_D10V_32. */
11548 case EM_CYGNUS_D30V:
11550 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11552 return reloc_type == 3; /* R_DLX_RELOC_32. */
11553 case EM_CYGNUS_FR30:
11555 return reloc_type == 3; /* R_FR30_32. */
11557 return reloc_type == 1; /* R_FT32_32. */
11561 return reloc_type == 1; /* R_H8_DIR32. */
11563 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11564 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
11567 return reloc_type == 2; /* R_IP2K_32. */
11569 return reloc_type == 2; /* R_IQ2000_32. */
11570 case EM_LATTICEMICO32:
11571 return reloc_type == 3; /* R_LM32_32. */
11574 return reloc_type == 3; /* R_M32C_32. */
11576 return reloc_type == 34; /* R_M32R_32_RELA. */
11579 return reloc_type == 6; /* R_M68HC11_32. */
11581 return reloc_type == 1; /* R_MCORE_ADDR32. */
11582 case EM_CYGNUS_MEP:
11583 return reloc_type == 4; /* R_MEP_32. */
11585 return reloc_type == 2; /* R_METAG_ADDR32. */
11586 case EM_MICROBLAZE:
11587 return reloc_type == 1; /* R_MICROBLAZE_32. */
11589 return reloc_type == 2; /* R_MIPS_32. */
11591 return reloc_type == 4; /* R_MMIX_32. */
11592 case EM_CYGNUS_MN10200:
11594 return reloc_type == 1; /* R_MN10200_32. */
11595 case EM_CYGNUS_MN10300:
11597 return reloc_type == 1; /* R_MN10300_32. */
11599 return reloc_type == 1; /* R_MOXIE_32. */
11600 case EM_MSP430_OLD:
11602 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11604 return reloc_type == 2; /* R_MT_32. */
11606 return reloc_type == 20; /* R_NDS32_RELA. */
11607 case EM_ALTERA_NIOS2:
11608 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
11610 return reloc_type == 1; /* R_NIOS_32. */
11612 return reloc_type == 1; /* R_OR1K_32. */
11614 return (reloc_type == 1 /* R_PARISC_DIR32. */
11615 || reloc_type == 41); /* R_PARISC_SECREL32. */
11618 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11620 return reloc_type == 1; /* R_PPC64_ADDR32. */
11622 return reloc_type == 1; /* R_PPC_ADDR32. */
11624 return reloc_type == 1; /* R_RL78_DIR32. */
11626 return reloc_type == 1; /* R_RX_DIR32. */
11628 return reloc_type == 1; /* R_I370_ADDR31. */
11631 return reloc_type == 4; /* R_S390_32. */
11633 return reloc_type == 8; /* R_SCORE_ABS32. */
11635 return reloc_type == 1; /* R_SH_DIR32. */
11636 case EM_SPARC32PLUS:
11639 return reloc_type == 3 /* R_SPARC_32. */
11640 || reloc_type == 23; /* R_SPARC_UA32. */
11642 return reloc_type == 6; /* R_SPU_ADDR32 */
11644 return reloc_type == 1; /* R_C6000_ABS32. */
11646 return reloc_type == 2; /* R_TILEGX_32. */
11648 return reloc_type == 1; /* R_TILEPRO_32. */
11649 case EM_CYGNUS_V850:
11651 return reloc_type == 6; /* R_V850_ABS32. */
11653 return reloc_type == 0x33; /* R_V810_WORD. */
11655 return reloc_type == 1; /* R_VAX_32. */
11657 return reloc_type == 3; /* R_VISIUM_32. */
11661 return reloc_type == 10; /* R_X86_64_32. */
11664 return reloc_type == 3; /* R_XC16C_ABS_32. */
11666 return reloc_type == 4; /* R_XGATE_32. */
11668 return reloc_type == 1; /* R_XSTROMY16_32. */
11669 case EM_XTENSA_OLD:
11671 return reloc_type == 1; /* R_XTENSA_32. */
11674 static unsigned int prev_warn = 0;
11676 /* Avoid repeating the same warning multiple times. */
11677 if (prev_warn != elf_header.e_machine)
11678 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11679 elf_header.e_machine);
11680 prev_warn = elf_header.e_machine;
11686 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11687 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11690 is_32bit_pcrel_reloc (unsigned int reloc_type)
11692 switch (elf_header.e_machine)
11693 /* Please keep this table alpha-sorted for ease of visual lookup. */
11697 return reloc_type == 2; /* R_386_PC32. */
11699 return reloc_type == 4; /* R_68K_PC32. */
11701 return reloc_type == 261; /* R_AARCH64_PREL32 */
11702 case EM_ADAPTEVA_EPIPHANY:
11703 return reloc_type == 6;
11705 return reloc_type == 10; /* R_ALPHA_SREL32. */
11706 case EM_ARC_COMPACT:
11707 case EM_ARC_COMPACT2:
11708 return reloc_type == 49; /* R_ARC_32_PCREL. */
11710 return reloc_type == 3; /* R_ARM_REL32 */
11713 return reloc_type == 36; /* R_AVR_32_PCREL. */
11714 case EM_MICROBLAZE:
11715 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11717 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11719 return reloc_type == 9; /* R_PARISC_PCREL32. */
11721 return reloc_type == 26; /* R_PPC_REL32. */
11723 return reloc_type == 26; /* R_PPC64_REL32. */
11726 return reloc_type == 5; /* R_390_PC32. */
11728 return reloc_type == 2; /* R_SH_REL32. */
11729 case EM_SPARC32PLUS:
11732 return reloc_type == 6; /* R_SPARC_DISP32. */
11734 return reloc_type == 13; /* R_SPU_REL32. */
11736 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11738 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11740 return reloc_type == 6; /* R_VISIUM_32_PCREL */
11744 return reloc_type == 2; /* R_X86_64_PC32. */
11745 case EM_XTENSA_OLD:
11747 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11749 /* Do not abort or issue an error message here. Not all targets use
11750 pc-relative 32-bit relocs in their DWARF debug information and we
11751 have already tested for target coverage in is_32bit_abs_reloc. A
11752 more helpful warning message will be generated by apply_relocations
11753 anyway, so just return. */
11758 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11759 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11762 is_64bit_abs_reloc (unsigned int reloc_type)
11764 switch (elf_header.e_machine)
11767 return reloc_type == 257; /* R_AARCH64_ABS64. */
11769 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11771 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11773 return reloc_type == 80; /* R_PARISC_DIR64. */
11775 return reloc_type == 38; /* R_PPC64_ADDR64. */
11776 case EM_SPARC32PLUS:
11779 return reloc_type == 32 /* R_SPARC_64. */
11780 || reloc_type == 54; /* R_SPARC_UA64. */
11784 return reloc_type == 1; /* R_X86_64_64. */
11787 return reloc_type == 22; /* R_S390_64. */
11789 return reloc_type == 1; /* R_TILEGX_64. */
11791 return reloc_type == 18; /* R_MIPS_64. */
11797 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11798 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11801 is_64bit_pcrel_reloc (unsigned int reloc_type)
11803 switch (elf_header.e_machine)
11806 return reloc_type == 260; /* R_AARCH64_PREL64. */
11808 return reloc_type == 11; /* R_ALPHA_SREL64. */
11810 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11812 return reloc_type == 72; /* R_PARISC_PCREL64. */
11814 return reloc_type == 44; /* R_PPC64_REL64. */
11815 case EM_SPARC32PLUS:
11818 return reloc_type == 46; /* R_SPARC_DISP64. */
11822 return reloc_type == 24; /* R_X86_64_PC64. */
11825 return reloc_type == 23; /* R_S390_PC64. */
11827 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11833 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11834 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11837 is_24bit_abs_reloc (unsigned int reloc_type)
11839 switch (elf_header.e_machine)
11841 case EM_CYGNUS_MN10200:
11843 return reloc_type == 4; /* R_MN10200_24. */
11845 return reloc_type == 5; /* R_FT32_20. */
11851 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11852 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11855 is_16bit_abs_reloc (unsigned int reloc_type)
11857 /* Please keep this table alpha-sorted for ease of visual lookup. */
11858 switch (elf_header.e_machine)
11861 case EM_ARC_COMPACT:
11862 case EM_ARC_COMPACT2:
11863 return reloc_type == 2; /* R_ARC_16. */
11864 case EM_ADAPTEVA_EPIPHANY:
11865 return reloc_type == 5;
11868 return reloc_type == 4; /* R_AVR_16. */
11869 case EM_CYGNUS_D10V:
11871 return reloc_type == 3; /* R_D10V_16. */
11875 return reloc_type == R_H8_DIR16;
11878 return reloc_type == 1; /* R_IP2K_16. */
11881 return reloc_type == 1; /* R_M32C_16 */
11882 case EM_CYGNUS_MN10200:
11884 return reloc_type == 2; /* R_MN10200_16. */
11885 case EM_CYGNUS_MN10300:
11887 return reloc_type == 2; /* R_MN10300_16. */
11889 if (uses_msp430x_relocs ())
11890 return reloc_type == 2; /* R_MSP430_ABS16. */
11891 case EM_MSP430_OLD:
11892 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11894 return reloc_type == 19; /* R_NDS32_RELA. */
11895 case EM_ALTERA_NIOS2:
11896 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11898 return reloc_type == 9; /* R_NIOS_16. */
11900 return reloc_type == 2; /* R_OR1K_16. */
11902 return reloc_type == 2; /* R_C6000_ABS16. */
11904 return reloc_type == 2; /* R_VISIUM_16. */
11907 return reloc_type == 2; /* R_XC16C_ABS_16. */
11909 return reloc_type == 3; /* R_XGATE_16. */
11915 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11916 relocation entries (possibly formerly used for SHT_GROUP sections). */
11919 is_none_reloc (unsigned int reloc_type)
11921 switch (elf_header.e_machine)
11923 case EM_386: /* R_386_NONE. */
11924 case EM_68K: /* R_68K_NONE. */
11925 case EM_ADAPTEVA_EPIPHANY:
11926 case EM_ALPHA: /* R_ALPHA_NONE. */
11927 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11928 case EM_ARC: /* R_ARC_NONE. */
11929 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
11930 case EM_ARC_COMPACT: /* R_ARC_NONE. */
11931 case EM_ARM: /* R_ARM_NONE. */
11932 case EM_C166: /* R_XC16X_NONE. */
11933 case EM_CRIS: /* R_CRIS_NONE. */
11934 case EM_FT32: /* R_FT32_NONE. */
11935 case EM_IA_64: /* R_IA64_NONE. */
11936 case EM_K1OM: /* R_X86_64_NONE. */
11937 case EM_L1OM: /* R_X86_64_NONE. */
11938 case EM_M32R: /* R_M32R_NONE. */
11939 case EM_MIPS: /* R_MIPS_NONE. */
11940 case EM_MN10300: /* R_MN10300_NONE. */
11941 case EM_MOXIE: /* R_MOXIE_NONE. */
11942 case EM_NIOS32: /* R_NIOS_NONE. */
11943 case EM_OR1K: /* R_OR1K_NONE. */
11944 case EM_PARISC: /* R_PARISC_NONE. */
11945 case EM_PPC64: /* R_PPC64_NONE. */
11946 case EM_PPC: /* R_PPC_NONE. */
11947 case EM_S390: /* R_390_NONE. */
11949 case EM_SH: /* R_SH_NONE. */
11950 case EM_SPARC32PLUS:
11951 case EM_SPARC: /* R_SPARC_NONE. */
11953 case EM_TILEGX: /* R_TILEGX_NONE. */
11954 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11955 case EM_TI_C6000:/* R_C6000_NONE. */
11956 case EM_X86_64: /* R_X86_64_NONE. */
11958 return reloc_type == 0;
11961 return reloc_type == 0 || reloc_type == 256;
11964 return (reloc_type == 0 /* R_AVR_NONE. */
11965 || reloc_type == 30 /* R_AVR_DIFF8. */
11966 || reloc_type == 31 /* R_AVR_DIFF16. */
11967 || reloc_type == 32 /* R_AVR_DIFF32. */);
11969 return reloc_type == 3; /* R_METAG_NONE. */
11971 return (reloc_type == 0 /* R_XTENSA_NONE. */
11972 || reloc_type == 204 /* R_NDS32_DIFF8. */
11973 || reloc_type == 205 /* R_NDS32_DIFF16. */
11974 || reloc_type == 206 /* R_NDS32_DIFF32. */
11975 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11976 case EM_XTENSA_OLD:
11978 return (reloc_type == 0 /* R_XTENSA_NONE. */
11979 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11980 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11981 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11986 /* Returns TRUE if there is a relocation against
11987 section NAME at OFFSET bytes. */
11990 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
11992 Elf_Internal_Rela * relocs;
11993 Elf_Internal_Rela * rp;
11995 if (dsec == NULL || dsec->reloc_info == NULL)
11998 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12000 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12001 if (rp->r_offset == offset)
12007 /* Apply relocations to a section.
12008 Note: So far support has been added only for those relocations
12009 which can be found in debug sections.
12010 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12011 loaded relocs. It is then the caller's responsibility to free them.
12012 FIXME: Add support for more relocations ? */
12015 apply_relocations (void * file,
12016 const Elf_Internal_Shdr * section,
12017 unsigned char * start,
12018 bfd_size_type size,
12019 void ** relocs_return,
12020 unsigned long * num_relocs_return)
12022 Elf_Internal_Shdr * relsec;
12023 unsigned char * end = start + size;
12025 if (relocs_return != NULL)
12027 * (Elf_Internal_Rela **) relocs_return = NULL;
12028 * num_relocs_return = 0;
12031 if (elf_header.e_type != ET_REL)
12034 /* Find the reloc section associated with the section. */
12035 for (relsec = section_headers;
12036 relsec < section_headers + elf_header.e_shnum;
12039 bfd_boolean is_rela;
12040 unsigned long num_relocs;
12041 Elf_Internal_Rela * relocs;
12042 Elf_Internal_Rela * rp;
12043 Elf_Internal_Shdr * symsec;
12044 Elf_Internal_Sym * symtab;
12045 unsigned long num_syms;
12046 Elf_Internal_Sym * sym;
12048 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12049 || relsec->sh_info >= elf_header.e_shnum
12050 || section_headers + relsec->sh_info != section
12051 || relsec->sh_size == 0
12052 || relsec->sh_link >= elf_header.e_shnum)
12055 is_rela = relsec->sh_type == SHT_RELA;
12059 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12060 relsec->sh_size, & relocs, & num_relocs))
12065 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12066 relsec->sh_size, & relocs, & num_relocs))
12070 /* SH uses RELA but uses in place value instead of the addend field. */
12071 if (elf_header.e_machine == EM_SH)
12074 symsec = section_headers + relsec->sh_link;
12075 if (symsec->sh_type != SHT_SYMTAB
12076 && symsec->sh_type != SHT_DYNSYM)
12078 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12080 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12083 unsigned int reloc_type;
12084 unsigned int reloc_size;
12085 unsigned char * rloc;
12086 unsigned long sym_index;
12088 reloc_type = get_reloc_type (rp->r_info);
12090 if (target_specific_reloc_handling (rp, start, symtab))
12092 else if (is_none_reloc (reloc_type))
12094 else if (is_32bit_abs_reloc (reloc_type)
12095 || is_32bit_pcrel_reloc (reloc_type))
12097 else if (is_64bit_abs_reloc (reloc_type)
12098 || is_64bit_pcrel_reloc (reloc_type))
12100 else if (is_24bit_abs_reloc (reloc_type))
12102 else if (is_16bit_abs_reloc (reloc_type))
12106 static unsigned int prev_reloc = 0;
12107 if (reloc_type != prev_reloc)
12108 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12109 reloc_type, printable_section_name (section));
12110 prev_reloc = reloc_type;
12114 rloc = start + rp->r_offset;
12115 if ((rloc + reloc_size) > end || (rloc < start))
12117 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12118 (unsigned long) rp->r_offset,
12119 printable_section_name (section));
12123 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12124 if (sym_index >= num_syms)
12126 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12127 sym_index, printable_section_name (section));
12130 sym = symtab + sym_index;
12132 /* If the reloc has a symbol associated with it,
12133 make sure that it is of an appropriate type.
12135 Relocations against symbols without type can happen.
12136 Gcc -feliminate-dwarf2-dups may generate symbols
12137 without type for debug info.
12139 Icc generates relocations against function symbols
12140 instead of local labels.
12142 Relocations against object symbols can happen, eg when
12143 referencing a global array. For an example of this see
12144 the _clz.o binary in libgcc.a. */
12146 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12147 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12149 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12150 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12151 (long int)(rp - relocs),
12152 printable_section_name (relsec));
12158 addend += rp->r_addend;
12159 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12160 partial_inplace. */
12162 || (elf_header.e_machine == EM_XTENSA
12163 && reloc_type == 1)
12164 || ((elf_header.e_machine == EM_PJ
12165 || elf_header.e_machine == EM_PJ_OLD)
12166 && reloc_type == 1)
12167 || ((elf_header.e_machine == EM_D30V
12168 || elf_header.e_machine == EM_CYGNUS_D30V)
12169 && reloc_type == 12))
12170 addend += byte_get (rloc, reloc_size);
12172 if (is_32bit_pcrel_reloc (reloc_type)
12173 || is_64bit_pcrel_reloc (reloc_type))
12175 /* On HPPA, all pc-relative relocations are biased by 8. */
12176 if (elf_header.e_machine == EM_PARISC)
12178 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12182 byte_put (rloc, addend + sym->st_value, reloc_size);
12189 * (Elf_Internal_Rela **) relocs_return = relocs;
12190 * num_relocs_return = num_relocs;
12199 #ifdef SUPPORT_DISASSEMBLY
12201 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12203 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12205 /* FIXME: XXX -- to be done --- XXX */
12211 /* Reads in the contents of SECTION from FILE, returning a pointer
12212 to a malloc'ed buffer or NULL if something went wrong. */
12215 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12217 bfd_size_type num_bytes;
12219 num_bytes = section->sh_size;
12221 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12223 printf (_("\nSection '%s' has no data to dump.\n"),
12224 printable_section_name (section));
12228 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12229 _("section contents"));
12232 /* Uncompresses a section that was compressed using zlib, in place. */
12235 uncompress_section_contents (unsigned char **buffer,
12236 dwarf_size_type uncompressed_size,
12237 dwarf_size_type *size)
12239 dwarf_size_type compressed_size = *size;
12240 unsigned char * compressed_buffer = *buffer;
12241 unsigned char * uncompressed_buffer;
12245 /* It is possible the section consists of several compressed
12246 buffers concatenated together, so we uncompress in a loop. */
12247 /* PR 18313: The state field in the z_stream structure is supposed
12248 to be invisible to the user (ie us), but some compilers will
12249 still complain about it being used without initialisation. So
12250 we first zero the entire z_stream structure and then set the fields
12252 memset (& strm, 0, sizeof strm);
12253 strm.avail_in = compressed_size;
12254 strm.next_in = (Bytef *) compressed_buffer;
12255 strm.avail_out = uncompressed_size;
12256 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12258 rc = inflateInit (& strm);
12259 while (strm.avail_in > 0)
12263 strm.next_out = ((Bytef *) uncompressed_buffer
12264 + (uncompressed_size - strm.avail_out));
12265 rc = inflate (&strm, Z_FINISH);
12266 if (rc != Z_STREAM_END)
12268 rc = inflateReset (& strm);
12270 rc = inflateEnd (& strm);
12272 || strm.avail_out != 0)
12275 *buffer = uncompressed_buffer;
12276 *size = uncompressed_size;
12280 free (uncompressed_buffer);
12281 /* Indicate decompression failure. */
12287 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12289 Elf_Internal_Shdr * relsec;
12290 bfd_size_type num_bytes;
12291 unsigned char * data;
12292 unsigned char * end;
12293 unsigned char * real_start;
12294 unsigned char * start;
12295 bfd_boolean some_strings_shown;
12297 real_start = start = (unsigned char *) get_section_contents (section,
12301 num_bytes = section->sh_size;
12303 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12305 if (decompress_dumps)
12307 dwarf_size_type new_size = num_bytes;
12308 dwarf_size_type uncompressed_size = 0;
12310 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12312 Elf_Internal_Chdr chdr;
12313 unsigned int compression_header_size
12314 = get_compression_header (& chdr, (unsigned char *) start);
12316 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12318 warn (_("section '%s' has unsupported compress type: %d\n"),
12319 printable_section_name (section), chdr.ch_type);
12322 else if (chdr.ch_addralign != section->sh_addralign)
12324 warn (_("compressed section '%s' is corrupted\n"),
12325 printable_section_name (section));
12328 uncompressed_size = chdr.ch_size;
12329 start += compression_header_size;
12330 new_size -= compression_header_size;
12332 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12334 /* Read the zlib header. In this case, it should be "ZLIB"
12335 followed by the uncompressed section size, 8 bytes in
12336 big-endian order. */
12337 uncompressed_size = start[4]; uncompressed_size <<= 8;
12338 uncompressed_size += start[5]; uncompressed_size <<= 8;
12339 uncompressed_size += start[6]; uncompressed_size <<= 8;
12340 uncompressed_size += start[7]; uncompressed_size <<= 8;
12341 uncompressed_size += start[8]; uncompressed_size <<= 8;
12342 uncompressed_size += start[9]; uncompressed_size <<= 8;
12343 uncompressed_size += start[10]; uncompressed_size <<= 8;
12344 uncompressed_size += start[11];
12349 if (uncompressed_size
12350 && uncompress_section_contents (& start,
12351 uncompressed_size, & new_size))
12352 num_bytes = new_size;
12355 /* If the section being dumped has relocations against it the user might
12356 be expecting these relocations to have been applied. Check for this
12357 case and issue a warning message in order to avoid confusion.
12358 FIXME: Maybe we ought to have an option that dumps a section with
12359 relocs applied ? */
12360 for (relsec = section_headers;
12361 relsec < section_headers + elf_header.e_shnum;
12364 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12365 || relsec->sh_info >= elf_header.e_shnum
12366 || section_headers + relsec->sh_info != section
12367 || relsec->sh_size == 0
12368 || relsec->sh_link >= elf_header.e_shnum)
12371 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12376 end = start + num_bytes;
12377 some_strings_shown = FALSE;
12381 while (!ISPRINT (* data))
12382 if (++ data >= end)
12387 size_t maxlen = end - data;
12390 /* PR 11128: Use two separate invocations in order to work
12391 around bugs in the Solaris 8 implementation of printf. */
12392 printf (" [%6tx] ", data - start);
12394 printf (" [%6Ix] ", (size_t) (data - start));
12398 print_symbol ((int) maxlen, (const char *) data);
12400 data += strnlen ((const char *) data, maxlen);
12404 printf (_("<corrupt>\n"));
12407 some_strings_shown = TRUE;
12411 if (! some_strings_shown)
12412 printf (_(" No strings found in this section."));
12420 dump_section_as_bytes (Elf_Internal_Shdr * section,
12422 bfd_boolean relocate)
12424 Elf_Internal_Shdr * relsec;
12425 bfd_size_type bytes;
12426 bfd_size_type section_size;
12428 unsigned char * data;
12429 unsigned char * real_start;
12430 unsigned char * start;
12432 real_start = start = (unsigned char *) get_section_contents (section, file);
12435 section_size = section->sh_size;
12437 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12439 if (decompress_dumps)
12441 dwarf_size_type new_size = section_size;
12442 dwarf_size_type uncompressed_size = 0;
12444 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12446 Elf_Internal_Chdr chdr;
12447 unsigned int compression_header_size
12448 = get_compression_header (& chdr, start);
12450 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12452 warn (_("section '%s' has unsupported compress type: %d\n"),
12453 printable_section_name (section), chdr.ch_type);
12456 else if (chdr.ch_addralign != section->sh_addralign)
12458 warn (_("compressed section '%s' is corrupted\n"),
12459 printable_section_name (section));
12462 uncompressed_size = chdr.ch_size;
12463 start += compression_header_size;
12464 new_size -= compression_header_size;
12466 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12468 /* Read the zlib header. In this case, it should be "ZLIB"
12469 followed by the uncompressed section size, 8 bytes in
12470 big-endian order. */
12471 uncompressed_size = start[4]; uncompressed_size <<= 8;
12472 uncompressed_size += start[5]; uncompressed_size <<= 8;
12473 uncompressed_size += start[6]; uncompressed_size <<= 8;
12474 uncompressed_size += start[7]; uncompressed_size <<= 8;
12475 uncompressed_size += start[8]; uncompressed_size <<= 8;
12476 uncompressed_size += start[9]; uncompressed_size <<= 8;
12477 uncompressed_size += start[10]; uncompressed_size <<= 8;
12478 uncompressed_size += start[11];
12483 if (uncompressed_size
12484 && uncompress_section_contents (& start, uncompressed_size,
12486 section_size = new_size;
12491 apply_relocations (file, section, start, section_size, NULL, NULL);
12495 /* If the section being dumped has relocations against it the user might
12496 be expecting these relocations to have been applied. Check for this
12497 case and issue a warning message in order to avoid confusion.
12498 FIXME: Maybe we ought to have an option that dumps a section with
12499 relocs applied ? */
12500 for (relsec = section_headers;
12501 relsec < section_headers + elf_header.e_shnum;
12504 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12505 || relsec->sh_info >= elf_header.e_shnum
12506 || section_headers + relsec->sh_info != section
12507 || relsec->sh_size == 0
12508 || relsec->sh_link >= elf_header.e_shnum)
12511 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12516 addr = section->sh_addr;
12517 bytes = section_size;
12526 lbytes = (bytes > 16 ? 16 : bytes);
12528 printf (" 0x%8.8lx ", (unsigned long) addr);
12530 for (j = 0; j < 16; j++)
12533 printf ("%2.2x", data[j]);
12541 for (j = 0; j < lbytes; j++)
12544 if (k >= ' ' && k < 0x7f)
12563 load_specific_debug_section (enum dwarf_section_display_enum debug,
12564 const Elf_Internal_Shdr * sec, void * file)
12566 struct dwarf_section * section = &debug_displays [debug].section;
12569 /* If it is already loaded, do nothing. */
12570 if (section->start != NULL)
12573 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12574 section->address = sec->sh_addr;
12575 section->user_data = NULL;
12576 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12578 sec->sh_size, buf);
12579 if (section->start == NULL)
12583 unsigned char *start = section->start;
12584 dwarf_size_type size = sec->sh_size;
12585 dwarf_size_type uncompressed_size = 0;
12587 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
12589 Elf_Internal_Chdr chdr;
12590 unsigned int compression_header_size
12591 = get_compression_header (&chdr, start);
12592 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12594 warn (_("section '%s' has unsupported compress type: %d\n"),
12595 section->name, chdr.ch_type);
12598 else if (chdr.ch_addralign != sec->sh_addralign)
12600 warn (_("compressed section '%s' is corrupted\n"),
12604 uncompressed_size = chdr.ch_size;
12605 start += compression_header_size;
12606 size -= compression_header_size;
12608 else if (size > 12 && streq ((char *) start, "ZLIB"))
12610 /* Read the zlib header. In this case, it should be "ZLIB"
12611 followed by the uncompressed section size, 8 bytes in
12612 big-endian order. */
12613 uncompressed_size = start[4]; uncompressed_size <<= 8;
12614 uncompressed_size += start[5]; uncompressed_size <<= 8;
12615 uncompressed_size += start[6]; uncompressed_size <<= 8;
12616 uncompressed_size += start[7]; uncompressed_size <<= 8;
12617 uncompressed_size += start[8]; uncompressed_size <<= 8;
12618 uncompressed_size += start[9]; uncompressed_size <<= 8;
12619 uncompressed_size += start[10]; uncompressed_size <<= 8;
12620 uncompressed_size += start[11];
12625 if (uncompressed_size
12626 && uncompress_section_contents (&start, uncompressed_size,
12629 /* Free the compressed buffer, update the section buffer
12630 and the section size if uncompress is successful. */
12631 free (section->start);
12632 section->start = start;
12634 section->size = size;
12637 if (section->start == NULL)
12640 if (debug_displays [debug].relocate)
12641 apply_relocations ((FILE *) file, sec, section->start, section->size,
12642 & section->reloc_info, & section->num_relocs);
12645 section->reloc_info = NULL;
12646 section->num_relocs = 0;
12652 /* If this is not NULL, load_debug_section will only look for sections
12653 within the list of sections given here. */
12654 unsigned int *section_subset = NULL;
12657 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12659 struct dwarf_section * section = &debug_displays [debug].section;
12660 Elf_Internal_Shdr * sec;
12662 /* Locate the debug section. */
12663 sec = find_section_in_set (section->uncompressed_name, section_subset);
12665 section->name = section->uncompressed_name;
12668 sec = find_section_in_set (section->compressed_name, section_subset);
12670 section->name = section->compressed_name;
12675 /* If we're loading from a subset of sections, and we've loaded
12676 a section matching this name before, it's likely that it's a
12678 if (section_subset != NULL)
12679 free_debug_section (debug);
12681 return load_specific_debug_section (debug, sec, (FILE *) file);
12685 free_debug_section (enum dwarf_section_display_enum debug)
12687 struct dwarf_section * section = &debug_displays [debug].section;
12689 if (section->start == NULL)
12692 free ((char *) section->start);
12693 section->start = NULL;
12694 section->address = 0;
12699 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12701 char * name = SECTION_NAME (section);
12702 const char * print_name = printable_section_name (section);
12703 bfd_size_type length;
12707 length = section->sh_size;
12710 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12713 if (section->sh_type == SHT_NOBITS)
12715 /* There is no point in dumping the contents of a debugging section
12716 which has the NOBITS type - the bits in the file will be random.
12717 This can happen when a file containing a .eh_frame section is
12718 stripped with the --only-keep-debug command line option. */
12719 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12724 if (const_strneq (name, ".gnu.linkonce.wi."))
12725 name = ".debug_info";
12727 /* See if we know how to display the contents of this section. */
12728 for (i = 0; i < max; i++)
12729 if (streq (debug_displays[i].section.uncompressed_name, name)
12730 || (i == line && const_strneq (name, ".debug_line."))
12731 || streq (debug_displays[i].section.compressed_name, name))
12733 struct dwarf_section * sec = &debug_displays [i].section;
12734 int secondary = (section != find_section (name));
12737 free_debug_section ((enum dwarf_section_display_enum) i);
12739 if (i == line && const_strneq (name, ".debug_line."))
12741 else if (streq (sec->uncompressed_name, name))
12742 sec->name = sec->uncompressed_name;
12744 sec->name = sec->compressed_name;
12745 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12748 /* If this debug section is part of a CU/TU set in a .dwp file,
12749 restrict load_debug_section to the sections in that set. */
12750 section_subset = find_cu_tu_set (file, shndx);
12752 result &= debug_displays[i].display (sec, file);
12754 section_subset = NULL;
12756 if (secondary || (i != info && i != abbrev))
12757 free_debug_section ((enum dwarf_section_display_enum) i);
12765 printf (_("Unrecognized debug section: %s\n"), print_name);
12772 /* Set DUMP_SECTS for all sections where dumps were requested
12773 based on section name. */
12776 initialise_dumps_byname (void)
12778 struct dump_list_entry * cur;
12780 for (cur = dump_sects_byname; cur; cur = cur->next)
12785 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12786 if (streq (SECTION_NAME (section_headers + i), cur->name))
12788 request_dump_bynumber (i, cur->type);
12793 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12799 process_section_contents (FILE * file)
12801 Elf_Internal_Shdr * section;
12807 initialise_dumps_byname ();
12809 for (i = 0, section = section_headers;
12810 i < elf_header.e_shnum && i < num_dump_sects;
12813 #ifdef SUPPORT_DISASSEMBLY
12814 if (dump_sects[i] & DISASS_DUMP)
12815 disassemble_section (section, file);
12817 if (dump_sects[i] & HEX_DUMP)
12818 dump_section_as_bytes (section, file, FALSE);
12820 if (dump_sects[i] & RELOC_DUMP)
12821 dump_section_as_bytes (section, file, TRUE);
12823 if (dump_sects[i] & STRING_DUMP)
12824 dump_section_as_strings (section, file);
12826 if (dump_sects[i] & DEBUG_DUMP)
12827 display_debug_section (i, section, file);
12830 /* Check to see if the user requested a
12831 dump of a section that does not exist. */
12832 while (i++ < num_dump_sects)
12834 warn (_("Section %d was not dumped because it does not exist!\n"), i);
12838 process_mips_fpe_exception (int mask)
12843 if (mask & OEX_FPU_INEX)
12844 fputs ("INEX", stdout), first = 0;
12845 if (mask & OEX_FPU_UFLO)
12846 printf ("%sUFLO", first ? "" : "|"), first = 0;
12847 if (mask & OEX_FPU_OFLO)
12848 printf ("%sOFLO", first ? "" : "|"), first = 0;
12849 if (mask & OEX_FPU_DIV0)
12850 printf ("%sDIV0", first ? "" : "|"), first = 0;
12851 if (mask & OEX_FPU_INVAL)
12852 printf ("%sINVAL", first ? "" : "|");
12855 fputs ("0", stdout);
12858 /* Display's the value of TAG at location P. If TAG is
12859 greater than 0 it is assumed to be an unknown tag, and
12860 a message is printed to this effect. Otherwise it is
12861 assumed that a message has already been printed.
12863 If the bottom bit of TAG is set it assumed to have a
12864 string value, otherwise it is assumed to have an integer
12867 Returns an updated P pointing to the first unread byte
12868 beyond the end of TAG's value.
12870 Reads at or beyond END will not be made. */
12872 static unsigned char *
12873 display_tag_value (int tag,
12875 const unsigned char * const end)
12880 printf (" Tag_unknown_%d: ", tag);
12884 warn (_("<corrupt tag>\n"));
12888 /* PR 17531 file: 027-19978-0.004. */
12889 size_t maxlen = (end - p) - 1;
12894 print_symbol ((int) maxlen, (const char *) p);
12895 p += strnlen ((char *) p, maxlen) + 1;
12899 printf (_("<corrupt string tag>"));
12900 p = (unsigned char *) end;
12908 val = read_uleb128 (p, &len, end);
12910 printf ("%ld (0x%lx)\n", val, val);
12917 /* ARM EABI attributes section. */
12922 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12924 const char ** table;
12925 } arm_attr_public_tag;
12927 static const char * arm_attr_tag_CPU_arch[] =
12928 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12929 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12931 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12932 static const char * arm_attr_tag_THUMB_ISA_use[] =
12933 {"No", "Thumb-1", "Thumb-2", "Yes"};
12934 static const char * arm_attr_tag_FP_arch[] =
12935 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12936 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12937 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12938 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12939 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12940 "NEON for ARMv8.1"};
12941 static const char * arm_attr_tag_PCS_config[] =
12942 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12943 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12944 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12945 {"V6", "SB", "TLS", "Unused"};
12946 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12947 {"Absolute", "PC-relative", "SB-relative", "None"};
12948 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12949 {"Absolute", "PC-relative", "None"};
12950 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12951 {"None", "direct", "GOT-indirect"};
12952 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12953 {"None", "??? 1", "2", "??? 3", "4"};
12954 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12955 static const char * arm_attr_tag_ABI_FP_denormal[] =
12956 {"Unused", "Needed", "Sign only"};
12957 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12958 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12959 static const char * arm_attr_tag_ABI_FP_number_model[] =
12960 {"Unused", "Finite", "RTABI", "IEEE 754"};
12961 static const char * arm_attr_tag_ABI_enum_size[] =
12962 {"Unused", "small", "int", "forced to int"};
12963 static const char * arm_attr_tag_ABI_HardFP_use[] =
12964 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12965 static const char * arm_attr_tag_ABI_VFP_args[] =
12966 {"AAPCS", "VFP registers", "custom", "compatible"};
12967 static const char * arm_attr_tag_ABI_WMMX_args[] =
12968 {"AAPCS", "WMMX registers", "custom"};
12969 static const char * arm_attr_tag_ABI_optimization_goals[] =
12970 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12971 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12972 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12973 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12974 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12975 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12976 static const char * arm_attr_tag_FP_HP_extension[] =
12977 {"Not Allowed", "Allowed"};
12978 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12979 {"None", "IEEE 754", "Alternative Format"};
12980 static const char * arm_attr_tag_DSP_extension[] =
12981 {"Follow architecture", "Allowed"};
12982 static const char * arm_attr_tag_MPextension_use[] =
12983 {"Not Allowed", "Allowed"};
12984 static const char * arm_attr_tag_DIV_use[] =
12985 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12986 "Allowed in v7-A with integer division extension"};
12987 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12988 static const char * arm_attr_tag_Virtualization_use[] =
12989 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12990 "TrustZone and Virtualization Extensions"};
12991 static const char * arm_attr_tag_MPextension_use_legacy[] =
12992 {"Not Allowed", "Allowed"};
12994 #define LOOKUP(id, name) \
12995 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12996 static arm_attr_public_tag arm_attr_public_tags[] =
12998 {4, "CPU_raw_name", 1, NULL},
12999 {5, "CPU_name", 1, NULL},
13000 LOOKUP(6, CPU_arch),
13001 {7, "CPU_arch_profile", 0, NULL},
13002 LOOKUP(8, ARM_ISA_use),
13003 LOOKUP(9, THUMB_ISA_use),
13004 LOOKUP(10, FP_arch),
13005 LOOKUP(11, WMMX_arch),
13006 LOOKUP(12, Advanced_SIMD_arch),
13007 LOOKUP(13, PCS_config),
13008 LOOKUP(14, ABI_PCS_R9_use),
13009 LOOKUP(15, ABI_PCS_RW_data),
13010 LOOKUP(16, ABI_PCS_RO_data),
13011 LOOKUP(17, ABI_PCS_GOT_use),
13012 LOOKUP(18, ABI_PCS_wchar_t),
13013 LOOKUP(19, ABI_FP_rounding),
13014 LOOKUP(20, ABI_FP_denormal),
13015 LOOKUP(21, ABI_FP_exceptions),
13016 LOOKUP(22, ABI_FP_user_exceptions),
13017 LOOKUP(23, ABI_FP_number_model),
13018 {24, "ABI_align_needed", 0, NULL},
13019 {25, "ABI_align_preserved", 0, NULL},
13020 LOOKUP(26, ABI_enum_size),
13021 LOOKUP(27, ABI_HardFP_use),
13022 LOOKUP(28, ABI_VFP_args),
13023 LOOKUP(29, ABI_WMMX_args),
13024 LOOKUP(30, ABI_optimization_goals),
13025 LOOKUP(31, ABI_FP_optimization_goals),
13026 {32, "compatibility", 0, NULL},
13027 LOOKUP(34, CPU_unaligned_access),
13028 LOOKUP(36, FP_HP_extension),
13029 LOOKUP(38, ABI_FP_16bit_format),
13030 LOOKUP(42, MPextension_use),
13031 LOOKUP(44, DIV_use),
13032 LOOKUP(46, DSP_extension),
13033 {64, "nodefaults", 0, NULL},
13034 {65, "also_compatible_with", 0, NULL},
13035 LOOKUP(66, T2EE_use),
13036 {67, "conformance", 1, NULL},
13037 LOOKUP(68, Virtualization_use),
13038 LOOKUP(70, MPextension_use_legacy)
13042 static unsigned char *
13043 display_arm_attribute (unsigned char * p,
13044 const unsigned char * const end)
13049 arm_attr_public_tag * attr;
13053 tag = read_uleb128 (p, &len, end);
13056 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13058 if (arm_attr_public_tags[i].tag == tag)
13060 attr = &arm_attr_public_tags[i];
13067 printf (" Tag_%s: ", attr->name);
13068 switch (attr->type)
13073 case 7: /* Tag_CPU_arch_profile. */
13074 val = read_uleb128 (p, &len, end);
13078 case 0: printf (_("None\n")); break;
13079 case 'A': printf (_("Application\n")); break;
13080 case 'R': printf (_("Realtime\n")); break;
13081 case 'M': printf (_("Microcontroller\n")); break;
13082 case 'S': printf (_("Application or Realtime\n")); break;
13083 default: printf ("??? (%d)\n", val); break;
13087 case 24: /* Tag_align_needed. */
13088 val = read_uleb128 (p, &len, end);
13092 case 0: printf (_("None\n")); break;
13093 case 1: printf (_("8-byte\n")); break;
13094 case 2: printf (_("4-byte\n")); break;
13095 case 3: printf ("??? 3\n"); break;
13098 printf (_("8-byte and up to %d-byte extended\n"),
13101 printf ("??? (%d)\n", val);
13106 case 25: /* Tag_align_preserved. */
13107 val = read_uleb128 (p, &len, end);
13111 case 0: printf (_("None\n")); break;
13112 case 1: printf (_("8-byte, except leaf SP\n")); break;
13113 case 2: printf (_("8-byte\n")); break;
13114 case 3: printf ("??? 3\n"); break;
13117 printf (_("8-byte and up to %d-byte extended\n"),
13120 printf ("??? (%d)\n", val);
13125 case 32: /* Tag_compatibility. */
13127 val = read_uleb128 (p, &len, end);
13129 printf (_("flag = %d, vendor = "), val);
13132 size_t maxlen = (end - p) - 1;
13134 print_symbol ((int) maxlen, (const char *) p);
13135 p += strnlen ((char *) p, maxlen) + 1;
13139 printf (_("<corrupt>"));
13140 p = (unsigned char *) end;
13146 case 64: /* Tag_nodefaults. */
13147 /* PR 17531: file: 001-505008-0.01. */
13150 printf (_("True\n"));
13153 case 65: /* Tag_also_compatible_with. */
13154 val = read_uleb128 (p, &len, end);
13156 if (val == 6 /* Tag_CPU_arch. */)
13158 val = read_uleb128 (p, &len, end);
13160 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13161 printf ("??? (%d)\n", val);
13163 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13167 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13172 printf (_("<unknown: %d>\n"), tag);
13178 return display_tag_value (-1, p, end);
13180 return display_tag_value (0, p, end);
13183 assert (attr->type & 0x80);
13184 val = read_uleb128 (p, &len, end);
13186 type = attr->type & 0x7f;
13188 printf ("??? (%d)\n", val);
13190 printf ("%s\n", attr->table[val]);
13195 return display_tag_value (tag, p, end);
13198 static unsigned char *
13199 display_gnu_attribute (unsigned char * p,
13200 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
13201 const unsigned char * const end)
13207 tag = read_uleb128 (p, &len, end);
13210 /* Tag_compatibility is the only generic GNU attribute defined at
13214 val = read_uleb128 (p, &len, end);
13217 printf (_("flag = %d, vendor = "), val);
13220 printf (_("<corrupt>\n"));
13221 warn (_("corrupt vendor attribute\n"));
13227 size_t maxlen = (end - p) - 1;
13229 print_symbol ((int) maxlen, (const char *) p);
13230 p += strnlen ((char *) p, maxlen) + 1;
13234 printf (_("<corrupt>"));
13235 p = (unsigned char *) end;
13242 if ((tag & 2) == 0 && display_proc_gnu_attribute)
13243 return display_proc_gnu_attribute (p, tag, end);
13245 return display_tag_value (tag, p, end);
13248 static unsigned char *
13249 display_power_gnu_attribute (unsigned char * p,
13251 const unsigned char * const end)
13256 if (tag == Tag_GNU_Power_ABI_FP)
13258 val = read_uleb128 (p, &len, end);
13260 printf (" Tag_GNU_Power_ABI_FP: ");
13265 printf (_("Hard or soft float\n"));
13268 printf (_("Hard float\n"));
13271 printf (_("Soft float\n"));
13274 printf (_("Single-precision hard float\n"));
13277 printf ("??? (%d)\n", val);
13283 if (tag == Tag_GNU_Power_ABI_Vector)
13285 val = read_uleb128 (p, &len, end);
13287 printf (" Tag_GNU_Power_ABI_Vector: ");
13291 printf (_("Any\n"));
13294 printf (_("Generic\n"));
13297 printf ("AltiVec\n");
13303 printf ("??? (%d)\n", val);
13309 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13313 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13317 val = read_uleb128 (p, &len, end);
13319 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13323 printf (_("Any\n"));
13326 printf ("r3/r4\n");
13329 printf (_("Memory\n"));
13332 printf ("??? (%d)\n", val);
13338 return display_tag_value (tag & 1, p, end);
13341 static unsigned char *
13342 display_s390_gnu_attribute (unsigned char * p,
13344 const unsigned char * const end)
13349 if (tag == Tag_GNU_S390_ABI_Vector)
13351 val = read_uleb128 (p, &len, end);
13353 printf (" Tag_GNU_S390_ABI_Vector: ");
13358 printf (_("any\n"));
13361 printf (_("software\n"));
13364 printf (_("hardware\n"));
13367 printf ("??? (%d)\n", val);
13373 return display_tag_value (tag & 1, p, end);
13377 display_sparc_hwcaps (int mask)
13383 if (mask & ELF_SPARC_HWCAP_MUL32)
13384 fputs ("mul32", stdout), first = 0;
13385 if (mask & ELF_SPARC_HWCAP_DIV32)
13386 printf ("%sdiv32", first ? "" : "|"), first = 0;
13387 if (mask & ELF_SPARC_HWCAP_FSMULD)
13388 printf ("%sfsmuld", first ? "" : "|"), first = 0;
13389 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13390 printf ("%sv8plus", first ? "" : "|"), first = 0;
13391 if (mask & ELF_SPARC_HWCAP_POPC)
13392 printf ("%spopc", first ? "" : "|"), first = 0;
13393 if (mask & ELF_SPARC_HWCAP_VIS)
13394 printf ("%svis", first ? "" : "|"), first = 0;
13395 if (mask & ELF_SPARC_HWCAP_VIS2)
13396 printf ("%svis2", first ? "" : "|"), first = 0;
13397 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13398 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
13399 if (mask & ELF_SPARC_HWCAP_FMAF)
13400 printf ("%sfmaf", first ? "" : "|"), first = 0;
13401 if (mask & ELF_SPARC_HWCAP_VIS3)
13402 printf ("%svis3", first ? "" : "|"), first = 0;
13403 if (mask & ELF_SPARC_HWCAP_HPC)
13404 printf ("%shpc", first ? "" : "|"), first = 0;
13405 if (mask & ELF_SPARC_HWCAP_RANDOM)
13406 printf ("%srandom", first ? "" : "|"), first = 0;
13407 if (mask & ELF_SPARC_HWCAP_TRANS)
13408 printf ("%strans", first ? "" : "|"), first = 0;
13409 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13410 printf ("%sfjfmau", first ? "" : "|"), first = 0;
13411 if (mask & ELF_SPARC_HWCAP_IMA)
13412 printf ("%sima", first ? "" : "|"), first = 0;
13413 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13414 printf ("%scspare", first ? "" : "|"), first = 0;
13417 fputc ('0', stdout);
13418 fputc ('\n', stdout);
13422 display_sparc_hwcaps2 (int mask)
13428 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13429 fputs ("fjathplus", stdout), first = 0;
13430 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13431 printf ("%svis3b", first ? "" : "|"), first = 0;
13432 if (mask & ELF_SPARC_HWCAP2_ADP)
13433 printf ("%sadp", first ? "" : "|"), first = 0;
13434 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13435 printf ("%ssparc5", first ? "" : "|"), first = 0;
13436 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13437 printf ("%smwait", first ? "" : "|"), first = 0;
13438 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13439 printf ("%sxmpmul", first ? "" : "|"), first = 0;
13440 if (mask & ELF_SPARC_HWCAP2_XMONT)
13441 printf ("%sxmont2", first ? "" : "|"), first = 0;
13442 if (mask & ELF_SPARC_HWCAP2_NSEC)
13443 printf ("%snsec", first ? "" : "|"), first = 0;
13444 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13445 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
13446 if (mask & ELF_SPARC_HWCAP2_FJDES)
13447 printf ("%sfjdes", first ? "" : "|"), first = 0;
13448 if (mask & ELF_SPARC_HWCAP2_FJAES)
13449 printf ("%sfjaes", first ? "" : "|"), first = 0;
13452 fputc ('0', stdout);
13453 fputc ('\n', stdout);
13456 static unsigned char *
13457 display_sparc_gnu_attribute (unsigned char * p,
13459 const unsigned char * const end)
13464 if (tag == Tag_GNU_Sparc_HWCAPS)
13466 val = read_uleb128 (p, &len, end);
13468 printf (" Tag_GNU_Sparc_HWCAPS: ");
13469 display_sparc_hwcaps (val);
13472 if (tag == Tag_GNU_Sparc_HWCAPS2)
13474 val = read_uleb128 (p, &len, end);
13476 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13477 display_sparc_hwcaps2 (val);
13481 return display_tag_value (tag, p, end);
13485 print_mips_fp_abi_value (int val)
13489 case Val_GNU_MIPS_ABI_FP_ANY:
13490 printf (_("Hard or soft float\n"));
13492 case Val_GNU_MIPS_ABI_FP_DOUBLE:
13493 printf (_("Hard float (double precision)\n"));
13495 case Val_GNU_MIPS_ABI_FP_SINGLE:
13496 printf (_("Hard float (single precision)\n"));
13498 case Val_GNU_MIPS_ABI_FP_SOFT:
13499 printf (_("Soft float\n"));
13501 case Val_GNU_MIPS_ABI_FP_OLD_64:
13502 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13504 case Val_GNU_MIPS_ABI_FP_XX:
13505 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13507 case Val_GNU_MIPS_ABI_FP_64:
13508 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13510 case Val_GNU_MIPS_ABI_FP_64A:
13511 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13513 case Val_GNU_MIPS_ABI_FP_NAN2008:
13514 printf (_("NaN 2008 compatibility\n"));
13517 printf ("??? (%d)\n", val);
13522 static unsigned char *
13523 display_mips_gnu_attribute (unsigned char * p,
13525 const unsigned char * const end)
13527 if (tag == Tag_GNU_MIPS_ABI_FP)
13532 val = read_uleb128 (p, &len, end);
13534 printf (" Tag_GNU_MIPS_ABI_FP: ");
13536 print_mips_fp_abi_value (val);
13541 if (tag == Tag_GNU_MIPS_ABI_MSA)
13546 val = read_uleb128 (p, &len, end);
13548 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13552 case Val_GNU_MIPS_ABI_MSA_ANY:
13553 printf (_("Any MSA or not\n"));
13555 case Val_GNU_MIPS_ABI_MSA_128:
13556 printf (_("128-bit MSA\n"));
13559 printf ("??? (%d)\n", val);
13565 return display_tag_value (tag & 1, p, end);
13568 static unsigned char *
13569 display_tic6x_attribute (unsigned char * p,
13570 const unsigned char * const end)
13576 tag = read_uleb128 (p, &len, end);
13582 val = read_uleb128 (p, &len, end);
13584 printf (" Tag_ISA: ");
13588 case C6XABI_Tag_ISA_none:
13589 printf (_("None\n"));
13591 case C6XABI_Tag_ISA_C62X:
13594 case C6XABI_Tag_ISA_C67X:
13597 case C6XABI_Tag_ISA_C67XP:
13598 printf ("C67x+\n");
13600 case C6XABI_Tag_ISA_C64X:
13603 case C6XABI_Tag_ISA_C64XP:
13604 printf ("C64x+\n");
13606 case C6XABI_Tag_ISA_C674X:
13607 printf ("C674x\n");
13610 printf ("??? (%d)\n", val);
13615 case Tag_ABI_wchar_t:
13616 val = read_uleb128 (p, &len, end);
13618 printf (" Tag_ABI_wchar_t: ");
13622 printf (_("Not used\n"));
13625 printf (_("2 bytes\n"));
13628 printf (_("4 bytes\n"));
13631 printf ("??? (%d)\n", val);
13636 case Tag_ABI_stack_align_needed:
13637 val = read_uleb128 (p, &len, end);
13639 printf (" Tag_ABI_stack_align_needed: ");
13643 printf (_("8-byte\n"));
13646 printf (_("16-byte\n"));
13649 printf ("??? (%d)\n", val);
13654 case Tag_ABI_stack_align_preserved:
13655 val = read_uleb128 (p, &len, end);
13657 printf (" Tag_ABI_stack_align_preserved: ");
13661 printf (_("8-byte\n"));
13664 printf (_("16-byte\n"));
13667 printf ("??? (%d)\n", val);
13673 val = read_uleb128 (p, &len, end);
13675 printf (" Tag_ABI_DSBT: ");
13679 printf (_("DSBT addressing not used\n"));
13682 printf (_("DSBT addressing used\n"));
13685 printf ("??? (%d)\n", val);
13691 val = read_uleb128 (p, &len, end);
13693 printf (" Tag_ABI_PID: ");
13697 printf (_("Data addressing position-dependent\n"));
13700 printf (_("Data addressing position-independent, GOT near DP\n"));
13703 printf (_("Data addressing position-independent, GOT far from DP\n"));
13706 printf ("??? (%d)\n", val);
13712 val = read_uleb128 (p, &len, end);
13714 printf (" Tag_ABI_PIC: ");
13718 printf (_("Code addressing position-dependent\n"));
13721 printf (_("Code addressing position-independent\n"));
13724 printf ("??? (%d)\n", val);
13729 case Tag_ABI_array_object_alignment:
13730 val = read_uleb128 (p, &len, end);
13732 printf (" Tag_ABI_array_object_alignment: ");
13736 printf (_("8-byte\n"));
13739 printf (_("4-byte\n"));
13742 printf (_("16-byte\n"));
13745 printf ("??? (%d)\n", val);
13750 case Tag_ABI_array_object_align_expected:
13751 val = read_uleb128 (p, &len, end);
13753 printf (" Tag_ABI_array_object_align_expected: ");
13757 printf (_("8-byte\n"));
13760 printf (_("4-byte\n"));
13763 printf (_("16-byte\n"));
13766 printf ("??? (%d)\n", val);
13771 case Tag_ABI_compatibility:
13773 val = read_uleb128 (p, &len, end);
13775 printf (" Tag_ABI_compatibility: ");
13776 printf (_("flag = %d, vendor = "), val);
13779 size_t maxlen = (end - p) - 1;
13781 print_symbol ((int) maxlen, (const char *) p);
13782 p += strnlen ((char *) p, maxlen) + 1;
13786 printf (_("<corrupt>"));
13787 p = (unsigned char *) end;
13793 case Tag_ABI_conformance:
13795 printf (" Tag_ABI_conformance: \"");
13798 size_t maxlen = (end - p) - 1;
13800 print_symbol ((int) maxlen, (const char *) p);
13801 p += strnlen ((char *) p, maxlen) + 1;
13805 printf (_("<corrupt>"));
13806 p = (unsigned char *) end;
13813 return display_tag_value (tag, p, end);
13817 display_raw_attribute (unsigned char * p, unsigned char * end)
13819 unsigned long addr = 0;
13820 size_t bytes = end - p;
13827 int lbytes = (bytes > 16 ? 16 : bytes);
13829 printf (" 0x%8.8lx ", addr);
13831 for (j = 0; j < 16; j++)
13834 printf ("%2.2x", p[j]);
13842 for (j = 0; j < lbytes; j++)
13845 if (k >= ' ' && k < 0x7f)
13861 static unsigned char *
13862 display_msp430x_attribute (unsigned char * p,
13863 const unsigned char * const end)
13869 tag = read_uleb128 (p, & len, end);
13874 case OFBA_MSPABI_Tag_ISA:
13875 val = read_uleb128 (p, &len, end);
13877 printf (" Tag_ISA: ");
13880 case 0: printf (_("None\n")); break;
13881 case 1: printf (_("MSP430\n")); break;
13882 case 2: printf (_("MSP430X\n")); break;
13883 default: printf ("??? (%d)\n", val); break;
13887 case OFBA_MSPABI_Tag_Code_Model:
13888 val = read_uleb128 (p, &len, end);
13890 printf (" Tag_Code_Model: ");
13893 case 0: printf (_("None\n")); break;
13894 case 1: printf (_("Small\n")); break;
13895 case 2: printf (_("Large\n")); break;
13896 default: printf ("??? (%d)\n", val); break;
13900 case OFBA_MSPABI_Tag_Data_Model:
13901 val = read_uleb128 (p, &len, end);
13903 printf (" Tag_Data_Model: ");
13906 case 0: printf (_("None\n")); break;
13907 case 1: printf (_("Small\n")); break;
13908 case 2: printf (_("Large\n")); break;
13909 case 3: printf (_("Restricted Large\n")); break;
13910 default: printf ("??? (%d)\n", val); break;
13915 printf (_(" <unknown tag %d>: "), tag);
13922 size_t maxlen = (end - p) - 1;
13924 print_symbol ((int) maxlen, (const char *) p);
13925 p += strnlen ((char *) p, maxlen) + 1;
13929 printf (_("<corrupt>"));
13930 p = (unsigned char *) end;
13936 val = read_uleb128 (p, &len, end);
13938 printf ("%d (0x%x)\n", val, val);
13948 process_attributes (FILE * file,
13949 const char * public_name,
13950 unsigned int proc_type,
13951 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13952 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13954 Elf_Internal_Shdr * sect;
13957 /* Find the section header so that we get the size. */
13958 for (i = 0, sect = section_headers;
13959 i < elf_header.e_shnum;
13962 unsigned char * contents;
13965 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13968 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13969 sect->sh_size, _("attributes"));
13970 if (contents == NULL)
13976 bfd_vma section_len;
13978 section_len = sect->sh_size - 1;
13981 while (section_len > 0)
13984 unsigned int namelen;
13985 bfd_boolean public_section;
13986 bfd_boolean gnu_section;
13988 if (section_len <= 4)
13990 error (_("Tag section ends prematurely\n"));
13993 attr_len = byte_get (p, 4);
13996 if (attr_len > section_len)
13998 error (_("Bad attribute length (%u > %u)\n"),
13999 (unsigned) attr_len, (unsigned) section_len);
14000 attr_len = section_len;
14002 /* PR 17531: file: 001-101425-0.004 */
14003 else if (attr_len < 5)
14005 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14009 section_len -= attr_len;
14012 namelen = strnlen ((char *) p, attr_len) + 1;
14013 if (namelen == 0 || namelen >= attr_len)
14015 error (_("Corrupt attribute section name\n"));
14019 printf (_("Attribute Section: "));
14020 print_symbol (INT_MAX, (const char *) p);
14023 if (public_name && streq ((char *) p, public_name))
14024 public_section = TRUE;
14026 public_section = FALSE;
14028 if (streq ((char *) p, "gnu"))
14029 gnu_section = TRUE;
14031 gnu_section = FALSE;
14034 attr_len -= namelen;
14036 while (attr_len > 0 && p < contents + sect->sh_size)
14041 unsigned char * end;
14043 /* PR binutils/17531: Safe handling of corrupt files. */
14046 error (_("Unused bytes at end of section\n"));
14052 size = byte_get (p, 4);
14053 if (size > attr_len)
14055 error (_("Bad subsection length (%u > %u)\n"),
14056 (unsigned) size, (unsigned) attr_len);
14059 /* PR binutils/17531: Safe handling of corrupt files. */
14062 error (_("Bad subsection length (%u < 6)\n"),
14069 end = p + size - 1;
14070 assert (end <= contents + sect->sh_size);
14076 printf (_("File Attributes\n"));
14079 printf (_("Section Attributes:"));
14082 printf (_("Symbol Attributes:"));
14088 val = read_uleb128 (p, &j, end);
14092 printf (" %d", val);
14097 printf (_("Unknown tag: %d\n"), tag);
14098 public_section = FALSE;
14102 if (public_section && display_pub_attribute != NULL)
14105 p = display_pub_attribute (p, end);
14108 else if (gnu_section && display_proc_gnu_attribute != NULL)
14111 p = display_gnu_attribute (p,
14112 display_proc_gnu_attribute,
14118 printf (_(" Unknown attribute:\n"));
14119 display_raw_attribute (p, end);
14128 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
14136 process_arm_specific (FILE * file)
14138 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
14139 display_arm_attribute, NULL);
14143 process_power_specific (FILE * file)
14145 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14146 display_power_gnu_attribute);
14150 process_s390_specific (FILE * file)
14152 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14153 display_s390_gnu_attribute);
14157 process_sparc_specific (FILE * file)
14159 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14160 display_sparc_gnu_attribute);
14164 process_tic6x_specific (FILE * file)
14166 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
14167 display_tic6x_attribute, NULL);
14171 process_msp430x_specific (FILE * file)
14173 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
14174 display_msp430x_attribute, NULL);
14177 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14178 Print the Address, Access and Initial fields of an entry at VMA ADDR
14179 and return the VMA of the next entry, or -1 if there was a problem.
14180 Does not read from DATA_END or beyond. */
14183 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14184 unsigned char * data_end)
14187 print_vma (addr, LONG_HEX);
14189 if (addr < pltgot + 0xfff0)
14190 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14192 printf ("%10s", "");
14195 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14199 unsigned char * from = data + addr - pltgot;
14201 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14203 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14204 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14205 return (bfd_vma) -1;
14209 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14210 print_vma (entry, LONG_HEX);
14213 return addr + (is_32bit_elf ? 4 : 8);
14216 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14217 PLTGOT. Print the Address and Initial fields of an entry at VMA
14218 ADDR and return the VMA of the next entry. */
14221 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14224 print_vma (addr, LONG_HEX);
14227 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14232 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14233 print_vma (entry, LONG_HEX);
14235 return addr + (is_32bit_elf ? 4 : 8);
14239 print_mips_ases (unsigned int mask)
14241 if (mask & AFL_ASE_DSP)
14242 fputs ("\n\tDSP ASE", stdout);
14243 if (mask & AFL_ASE_DSPR2)
14244 fputs ("\n\tDSP R2 ASE", stdout);
14245 if (mask & AFL_ASE_DSPR3)
14246 fputs ("\n\tDSP R3 ASE", stdout);
14247 if (mask & AFL_ASE_EVA)
14248 fputs ("\n\tEnhanced VA Scheme", stdout);
14249 if (mask & AFL_ASE_MCU)
14250 fputs ("\n\tMCU (MicroController) ASE", stdout);
14251 if (mask & AFL_ASE_MDMX)
14252 fputs ("\n\tMDMX ASE", stdout);
14253 if (mask & AFL_ASE_MIPS3D)
14254 fputs ("\n\tMIPS-3D ASE", stdout);
14255 if (mask & AFL_ASE_MT)
14256 fputs ("\n\tMT ASE", stdout);
14257 if (mask & AFL_ASE_SMARTMIPS)
14258 fputs ("\n\tSmartMIPS ASE", stdout);
14259 if (mask & AFL_ASE_VIRT)
14260 fputs ("\n\tVZ ASE", stdout);
14261 if (mask & AFL_ASE_MSA)
14262 fputs ("\n\tMSA ASE", stdout);
14263 if (mask & AFL_ASE_MIPS16)
14264 fputs ("\n\tMIPS16 ASE", stdout);
14265 if (mask & AFL_ASE_MICROMIPS)
14266 fputs ("\n\tMICROMIPS ASE", stdout);
14267 if (mask & AFL_ASE_XPA)
14268 fputs ("\n\tXPA ASE", stdout);
14270 fprintf (stdout, "\n\t%s", _("None"));
14271 else if ((mask & ~AFL_ASE_MASK) != 0)
14272 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14276 print_mips_isa_ext (unsigned int isa_ext)
14281 fputs (_("None"), stdout);
14284 fputs ("RMI XLR", stdout);
14286 case AFL_EXT_OCTEON3:
14287 fputs ("Cavium Networks Octeon3", stdout);
14289 case AFL_EXT_OCTEON2:
14290 fputs ("Cavium Networks Octeon2", stdout);
14292 case AFL_EXT_OCTEONP:
14293 fputs ("Cavium Networks OcteonP", stdout);
14295 case AFL_EXT_LOONGSON_3A:
14296 fputs ("Loongson 3A", stdout);
14298 case AFL_EXT_OCTEON:
14299 fputs ("Cavium Networks Octeon", stdout);
14302 fputs ("Toshiba R5900", stdout);
14305 fputs ("MIPS R4650", stdout);
14308 fputs ("LSI R4010", stdout);
14311 fputs ("NEC VR4100", stdout);
14314 fputs ("Toshiba R3900", stdout);
14316 case AFL_EXT_10000:
14317 fputs ("MIPS R10000", stdout);
14320 fputs ("Broadcom SB-1", stdout);
14323 fputs ("NEC VR4111/VR4181", stdout);
14326 fputs ("NEC VR4120", stdout);
14329 fputs ("NEC VR5400", stdout);
14332 fputs ("NEC VR5500", stdout);
14334 case AFL_EXT_LOONGSON_2E:
14335 fputs ("ST Microelectronics Loongson 2E", stdout);
14337 case AFL_EXT_LOONGSON_2F:
14338 fputs ("ST Microelectronics Loongson 2F", stdout);
14341 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14346 get_mips_reg_size (int reg_size)
14348 return (reg_size == AFL_REG_NONE) ? 0
14349 : (reg_size == AFL_REG_32) ? 32
14350 : (reg_size == AFL_REG_64) ? 64
14351 : (reg_size == AFL_REG_128) ? 128
14356 process_mips_specific (FILE * file)
14358 Elf_Internal_Dyn * entry;
14359 Elf_Internal_Shdr *sect = NULL;
14360 size_t liblist_offset = 0;
14361 size_t liblistno = 0;
14362 size_t conflictsno = 0;
14363 size_t options_offset = 0;
14364 size_t conflicts_offset = 0;
14365 size_t pltrelsz = 0;
14367 bfd_vma pltgot = 0;
14368 bfd_vma mips_pltgot = 0;
14369 bfd_vma jmprel = 0;
14370 bfd_vma local_gotno = 0;
14371 bfd_vma gotsym = 0;
14372 bfd_vma symtabno = 0;
14374 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14375 display_mips_gnu_attribute);
14377 sect = find_section (".MIPS.abiflags");
14381 Elf_External_ABIFlags_v0 *abiflags_ext;
14382 Elf_Internal_ABIFlags_v0 abiflags_in;
14384 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14385 fputs ("\nCorrupt ABI Flags section.\n", stdout);
14388 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14389 sect->sh_size, _("MIPS ABI Flags section"));
14392 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14393 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14394 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14395 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14396 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14397 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14398 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14399 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14400 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14401 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14402 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14404 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14405 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14406 if (abiflags_in.isa_rev > 1)
14407 printf ("r%d", abiflags_in.isa_rev);
14408 printf ("\nGPR size: %d",
14409 get_mips_reg_size (abiflags_in.gpr_size));
14410 printf ("\nCPR1 size: %d",
14411 get_mips_reg_size (abiflags_in.cpr1_size));
14412 printf ("\nCPR2 size: %d",
14413 get_mips_reg_size (abiflags_in.cpr2_size));
14414 fputs ("\nFP ABI: ", stdout);
14415 print_mips_fp_abi_value (abiflags_in.fp_abi);
14416 fputs ("ISA Extension: ", stdout);
14417 print_mips_isa_ext (abiflags_in.isa_ext);
14418 fputs ("\nASEs:", stdout);
14419 print_mips_ases (abiflags_in.ases);
14420 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14421 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14422 fputc ('\n', stdout);
14423 free (abiflags_ext);
14428 /* We have a lot of special sections. Thanks SGI! */
14429 if (dynamic_section == NULL)
14430 /* No information available. */
14433 for (entry = dynamic_section;
14434 /* PR 17531 file: 012-50589-0.004. */
14435 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14437 switch (entry->d_tag)
14439 case DT_MIPS_LIBLIST:
14441 = offset_from_vma (file, entry->d_un.d_val,
14442 liblistno * sizeof (Elf32_External_Lib));
14444 case DT_MIPS_LIBLISTNO:
14445 liblistno = entry->d_un.d_val;
14447 case DT_MIPS_OPTIONS:
14448 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14450 case DT_MIPS_CONFLICT:
14452 = offset_from_vma (file, entry->d_un.d_val,
14453 conflictsno * sizeof (Elf32_External_Conflict));
14455 case DT_MIPS_CONFLICTNO:
14456 conflictsno = entry->d_un.d_val;
14459 pltgot = entry->d_un.d_ptr;
14461 case DT_MIPS_LOCAL_GOTNO:
14462 local_gotno = entry->d_un.d_val;
14464 case DT_MIPS_GOTSYM:
14465 gotsym = entry->d_un.d_val;
14467 case DT_MIPS_SYMTABNO:
14468 symtabno = entry->d_un.d_val;
14470 case DT_MIPS_PLTGOT:
14471 mips_pltgot = entry->d_un.d_ptr;
14474 pltrel = entry->d_un.d_val;
14477 pltrelsz = entry->d_un.d_val;
14480 jmprel = entry->d_un.d_ptr;
14486 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14488 Elf32_External_Lib * elib;
14491 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
14493 sizeof (Elf32_External_Lib),
14494 _("liblist section data"));
14497 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14498 (unsigned long) liblistno);
14499 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14502 for (cnt = 0; cnt < liblistno; ++cnt)
14509 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14510 atime = BYTE_GET (elib[cnt].l_time_stamp);
14511 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14512 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14513 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14515 tmp = gmtime (&atime);
14516 snprintf (timebuf, sizeof (timebuf),
14517 "%04u-%02u-%02uT%02u:%02u:%02u",
14518 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14519 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14521 printf ("%3lu: ", (unsigned long) cnt);
14522 if (VALID_DYNAMIC_NAME (liblist.l_name))
14523 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
14525 printf (_("<corrupt: %9ld>"), liblist.l_name);
14526 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
14527 liblist.l_version);
14529 if (liblist.l_flags == 0)
14533 static const struct
14540 { " EXACT_MATCH", LL_EXACT_MATCH },
14541 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
14542 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
14543 { " EXPORTS", LL_EXPORTS },
14544 { " DELAY_LOAD", LL_DELAY_LOAD },
14545 { " DELTA", LL_DELTA }
14547 int flags = liblist.l_flags;
14550 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
14551 if ((flags & l_flags_vals[fcnt].bit) != 0)
14553 fputs (l_flags_vals[fcnt].name, stdout);
14554 flags ^= l_flags_vals[fcnt].bit;
14557 printf (" %#x", (unsigned int) flags);
14567 if (options_offset != 0)
14569 Elf_External_Options * eopt;
14570 Elf_Internal_Options * iopt;
14571 Elf_Internal_Options * option;
14574 sect = section_headers;
14576 /* Find the section header so that we get the size. */
14577 sect = find_section_by_type (SHT_MIPS_OPTIONS);
14578 /* PR 17533 file: 012-277276-0.004. */
14581 error (_("No MIPS_OPTIONS header found\n"));
14585 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
14586 sect->sh_size, _("options"));
14589 iopt = (Elf_Internal_Options *)
14590 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
14593 error (_("Out of memory allocatinf space for MIPS options\n"));
14600 while (offset <= sect->sh_size - sizeof (* eopt))
14602 Elf_External_Options * eoption;
14604 eoption = (Elf_External_Options *) ((char *) eopt + offset);
14606 option->kind = BYTE_GET (eoption->kind);
14607 option->size = BYTE_GET (eoption->size);
14608 option->section = BYTE_GET (eoption->section);
14609 option->info = BYTE_GET (eoption->info);
14611 /* PR 17531: file: ffa0fa3b. */
14612 if (option->size < sizeof (* eopt)
14613 || offset + option->size > sect->sh_size)
14615 error (_("Invalid size (%u) for MIPS option\n"), option->size);
14618 offset += option->size;
14624 printf (_("\nSection '%s' contains %d entries:\n"),
14625 printable_section_name (sect), cnt);
14634 switch (option->kind)
14637 /* This shouldn't happen. */
14638 printf (" NULL %d %lx", option->section, option->info);
14641 printf (" REGINFO ");
14642 if (elf_header.e_machine == EM_MIPS)
14645 Elf32_External_RegInfo * ereg;
14646 Elf32_RegInfo reginfo;
14648 ereg = (Elf32_External_RegInfo *) (option + 1);
14649 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14650 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14651 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14652 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14653 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14654 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14656 printf ("GPR %08lx GP 0x%lx\n",
14657 reginfo.ri_gprmask,
14658 (unsigned long) reginfo.ri_gp_value);
14659 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14660 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14661 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14666 Elf64_External_RegInfo * ereg;
14667 Elf64_Internal_RegInfo reginfo;
14669 ereg = (Elf64_External_RegInfo *) (option + 1);
14670 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14671 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14672 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14673 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14674 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14675 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14677 printf ("GPR %08lx GP 0x",
14678 reginfo.ri_gprmask);
14679 printf_vma (reginfo.ri_gp_value);
14682 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14683 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14684 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14688 case ODK_EXCEPTIONS:
14689 fputs (" EXCEPTIONS fpe_min(", stdout);
14690 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14691 fputs (") fpe_max(", stdout);
14692 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14693 fputs (")", stdout);
14695 if (option->info & OEX_PAGE0)
14696 fputs (" PAGE0", stdout);
14697 if (option->info & OEX_SMM)
14698 fputs (" SMM", stdout);
14699 if (option->info & OEX_FPDBUG)
14700 fputs (" FPDBUG", stdout);
14701 if (option->info & OEX_DISMISS)
14702 fputs (" DISMISS", stdout);
14705 fputs (" PAD ", stdout);
14706 if (option->info & OPAD_PREFIX)
14707 fputs (" PREFIX", stdout);
14708 if (option->info & OPAD_POSTFIX)
14709 fputs (" POSTFIX", stdout);
14710 if (option->info & OPAD_SYMBOL)
14711 fputs (" SYMBOL", stdout);
14714 fputs (" HWPATCH ", stdout);
14715 if (option->info & OHW_R4KEOP)
14716 fputs (" R4KEOP", stdout);
14717 if (option->info & OHW_R8KPFETCH)
14718 fputs (" R8KPFETCH", stdout);
14719 if (option->info & OHW_R5KEOP)
14720 fputs (" R5KEOP", stdout);
14721 if (option->info & OHW_R5KCVTL)
14722 fputs (" R5KCVTL", stdout);
14725 fputs (" FILL ", stdout);
14726 /* XXX Print content of info word? */
14729 fputs (" TAGS ", stdout);
14730 /* XXX Print content of info word? */
14733 fputs (" HWAND ", stdout);
14734 if (option->info & OHWA0_R4KEOP_CHECKED)
14735 fputs (" R4KEOP_CHECKED", stdout);
14736 if (option->info & OHWA0_R4KEOP_CLEAN)
14737 fputs (" R4KEOP_CLEAN", stdout);
14740 fputs (" HWOR ", stdout);
14741 if (option->info & OHWA0_R4KEOP_CHECKED)
14742 fputs (" R4KEOP_CHECKED", stdout);
14743 if (option->info & OHWA0_R4KEOP_CLEAN)
14744 fputs (" R4KEOP_CLEAN", stdout);
14747 printf (" GP_GROUP %#06lx self-contained %#06lx",
14748 option->info & OGP_GROUP,
14749 (option->info & OGP_SELF) >> 16);
14752 printf (" IDENT %#06lx self-contained %#06lx",
14753 option->info & OGP_GROUP,
14754 (option->info & OGP_SELF) >> 16);
14757 /* This shouldn't happen. */
14758 printf (" %3d ??? %d %lx",
14759 option->kind, option->section, option->info);
14763 len = sizeof (* eopt);
14764 while (len < option->size)
14766 unsigned char datum = * ((unsigned char *) eopt + offset + len);
14768 if (ISPRINT (datum))
14769 printf ("%c", datum);
14771 printf ("\\%03o", datum);
14774 fputs ("\n", stdout);
14776 offset += option->size;
14784 if (conflicts_offset != 0 && conflictsno != 0)
14786 Elf32_Conflict * iconf;
14789 if (dynamic_symbols == NULL)
14791 error (_("conflict list found without a dynamic symbol table\n"));
14795 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14798 error (_("Out of memory allocating space for dynamic conflicts\n"));
14804 Elf32_External_Conflict * econf32;
14806 econf32 = (Elf32_External_Conflict *)
14807 get_data (NULL, file, conflicts_offset, conflictsno,
14808 sizeof (* econf32), _("conflict"));
14812 for (cnt = 0; cnt < conflictsno; ++cnt)
14813 iconf[cnt] = BYTE_GET (econf32[cnt]);
14819 Elf64_External_Conflict * econf64;
14821 econf64 = (Elf64_External_Conflict *)
14822 get_data (NULL, file, conflicts_offset, conflictsno,
14823 sizeof (* econf64), _("conflict"));
14827 for (cnt = 0; cnt < conflictsno; ++cnt)
14828 iconf[cnt] = BYTE_GET (econf64[cnt]);
14833 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14834 (unsigned long) conflictsno);
14835 puts (_(" Num: Index Value Name"));
14837 for (cnt = 0; cnt < conflictsno; ++cnt)
14839 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
14841 if (iconf[cnt] >= num_dynamic_syms)
14842 printf (_("<corrupt symbol index>"));
14845 Elf_Internal_Sym * psym;
14847 psym = & dynamic_symbols[iconf[cnt]];
14848 print_vma (psym->st_value, FULL_HEX);
14850 if (VALID_DYNAMIC_NAME (psym->st_name))
14851 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14853 printf (_("<corrupt: %14ld>"), psym->st_name);
14861 if (pltgot != 0 && local_gotno != 0)
14863 bfd_vma ent, local_end, global_end;
14865 unsigned char * data;
14866 unsigned char * data_end;
14870 addr_size = (is_32bit_elf ? 4 : 8);
14871 local_end = pltgot + local_gotno * addr_size;
14873 /* PR binutils/17533 file: 012-111227-0.004 */
14874 if (symtabno < gotsym)
14876 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14877 (unsigned long) gotsym, (unsigned long) symtabno);
14881 global_end = local_end + (symtabno - gotsym) * addr_size;
14882 /* PR 17531: file: 54c91a34. */
14883 if (global_end < local_end)
14885 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14889 offset = offset_from_vma (file, pltgot, global_end - pltgot);
14890 data = (unsigned char *) get_data (NULL, file, offset,
14891 global_end - pltgot, 1,
14892 _("Global Offset Table data"));
14895 data_end = data + (global_end - pltgot);
14897 printf (_("\nPrimary GOT:\n"));
14898 printf (_(" Canonical gp value: "));
14899 print_vma (pltgot + 0x7ff0, LONG_HEX);
14902 printf (_(" Reserved entries:\n"));
14903 printf (_(" %*s %10s %*s Purpose\n"),
14904 addr_size * 2, _("Address"), _("Access"),
14905 addr_size * 2, _("Initial"));
14906 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14907 printf (_(" Lazy resolver\n"));
14908 if (ent == (bfd_vma) -1)
14909 goto got_print_fail;
14911 && (byte_get (data + ent - pltgot, addr_size)
14912 >> (addr_size * 8 - 1)) != 0)
14914 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14915 printf (_(" Module pointer (GNU extension)\n"));
14916 if (ent == (bfd_vma) -1)
14917 goto got_print_fail;
14921 if (ent < local_end)
14923 printf (_(" Local entries:\n"));
14924 printf (" %*s %10s %*s\n",
14925 addr_size * 2, _("Address"), _("Access"),
14926 addr_size * 2, _("Initial"));
14927 while (ent < local_end)
14929 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14931 if (ent == (bfd_vma) -1)
14932 goto got_print_fail;
14937 if (gotsym < symtabno)
14941 printf (_(" Global entries:\n"));
14942 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14943 addr_size * 2, _("Address"),
14945 addr_size * 2, _("Initial"),
14946 addr_size * 2, _("Sym.Val."),
14948 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14949 _("Ndx"), _("Name"));
14951 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14953 for (i = gotsym; i < symtabno; i++)
14955 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14958 if (dynamic_symbols == NULL)
14959 printf (_("<no dynamic symbols>"));
14960 else if (i < num_dynamic_syms)
14962 Elf_Internal_Sym * psym = dynamic_symbols + i;
14964 print_vma (psym->st_value, LONG_HEX);
14965 printf (" %-7s %3s ",
14966 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14967 get_symbol_index_type (psym->st_shndx));
14969 if (VALID_DYNAMIC_NAME (psym->st_name))
14970 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14972 printf (_("<corrupt: %14ld>"), psym->st_name);
14975 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14976 (unsigned long) i);
14979 if (ent == (bfd_vma) -1)
14990 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14993 size_t offset, rel_offset;
14994 unsigned long count, i;
14995 unsigned char * data;
14996 int addr_size, sym_width;
14997 Elf_Internal_Rela * rels;
14999 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15000 if (pltrel == DT_RELA)
15002 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15007 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15012 addr_size = (is_32bit_elf ? 4 : 8);
15013 end = mips_pltgot + (2 + count) * addr_size;
15015 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15016 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15017 1, _("Procedure Linkage Table data"));
15021 printf ("\nPLT GOT:\n\n");
15022 printf (_(" Reserved entries:\n"));
15023 printf (_(" %*s %*s Purpose\n"),
15024 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15025 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15026 printf (_(" PLT lazy resolver\n"));
15027 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15028 printf (_(" Module pointer\n"));
15031 printf (_(" Entries:\n"));
15032 printf (" %*s %*s %*s %-7s %3s %s\n",
15033 addr_size * 2, _("Address"),
15034 addr_size * 2, _("Initial"),
15035 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15036 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15037 for (i = 0; i < count; i++)
15039 unsigned long idx = get_reloc_symindex (rels[i].r_info);
15041 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15044 if (idx >= num_dynamic_syms)
15045 printf (_("<corrupt symbol index: %lu>"), idx);
15048 Elf_Internal_Sym * psym = dynamic_symbols + idx;
15050 print_vma (psym->st_value, LONG_HEX);
15051 printf (" %-7s %3s ",
15052 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15053 get_symbol_index_type (psym->st_shndx));
15054 if (VALID_DYNAMIC_NAME (psym->st_name))
15055 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15057 printf (_("<corrupt: %14ld>"), psym->st_name);
15072 process_nds32_specific (FILE * file)
15074 Elf_Internal_Shdr *sect = NULL;
15076 sect = find_section (".nds32_e_flags");
15079 unsigned int *flag;
15081 printf ("\nNDS32 elf flags section:\n");
15082 flag = get_data (NULL, file, sect->sh_offset, 1,
15083 sect->sh_size, _("NDS32 elf flags section"));
15085 switch ((*flag) & 0x3)
15088 printf ("(VEC_SIZE):\tNo entry.\n");
15091 printf ("(VEC_SIZE):\t4 bytes\n");
15094 printf ("(VEC_SIZE):\t16 bytes\n");
15097 printf ("(VEC_SIZE):\treserved\n");
15106 process_gnu_liblist (FILE * file)
15108 Elf_Internal_Shdr * section;
15109 Elf_Internal_Shdr * string_sec;
15110 Elf32_External_Lib * elib;
15112 size_t strtab_size;
15119 for (i = 0, section = section_headers;
15120 i < elf_header.e_shnum;
15123 switch (section->sh_type)
15125 case SHT_GNU_LIBLIST:
15126 if (section->sh_link >= elf_header.e_shnum)
15129 elib = (Elf32_External_Lib *)
15130 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
15131 _("liblist section data"));
15135 string_sec = section_headers + section->sh_link;
15137 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15138 string_sec->sh_size,
15139 _("liblist string table"));
15141 || section->sh_entsize != sizeof (Elf32_External_Lib))
15147 strtab_size = string_sec->sh_size;
15149 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15150 printable_section_name (section),
15151 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
15153 puts (_(" Library Time Stamp Checksum Version Flags"));
15155 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15163 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15164 atime = BYTE_GET (elib[cnt].l_time_stamp);
15165 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15166 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15167 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15169 tmp = gmtime (&atime);
15170 snprintf (timebuf, sizeof (timebuf),
15171 "%04u-%02u-%02uT%02u:%02u:%02u",
15172 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15173 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15175 printf ("%3lu: ", (unsigned long) cnt);
15177 printf ("%-20s", liblist.l_name < strtab_size
15178 ? strtab + liblist.l_name : _("<corrupt>"));
15180 printf ("%-20.20s", liblist.l_name < strtab_size
15181 ? strtab + liblist.l_name : _("<corrupt>"));
15182 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15183 liblist.l_version, liblist.l_flags);
15194 static const char *
15195 get_note_type (unsigned e_type)
15197 static char buff[64];
15199 if (elf_header.e_type == ET_CORE)
15203 return _("NT_AUXV (auxiliary vector)");
15205 return _("NT_PRSTATUS (prstatus structure)");
15207 return _("NT_FPREGSET (floating point registers)");
15209 return _("NT_PRPSINFO (prpsinfo structure)");
15210 case NT_TASKSTRUCT:
15211 return _("NT_TASKSTRUCT (task structure)");
15213 return _("NT_PRXFPREG (user_xfpregs structure)");
15215 return _("NT_PPC_VMX (ppc Altivec registers)");
15217 return _("NT_PPC_VSX (ppc VSX registers)");
15219 return _("NT_386_TLS (x86 TLS information)");
15220 case NT_386_IOPERM:
15221 return _("NT_386_IOPERM (x86 I/O permissions)");
15222 case NT_X86_XSTATE:
15223 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15224 case NT_S390_HIGH_GPRS:
15225 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15226 case NT_S390_TIMER:
15227 return _("NT_S390_TIMER (s390 timer register)");
15228 case NT_S390_TODCMP:
15229 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15230 case NT_S390_TODPREG:
15231 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15233 return _("NT_S390_CTRS (s390 control registers)");
15234 case NT_S390_PREFIX:
15235 return _("NT_S390_PREFIX (s390 prefix register)");
15236 case NT_S390_LAST_BREAK:
15237 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15238 case NT_S390_SYSTEM_CALL:
15239 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15241 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15242 case NT_S390_VXRS_LOW:
15243 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15244 case NT_S390_VXRS_HIGH:
15245 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15247 return _("NT_ARM_VFP (arm VFP registers)");
15249 return _("NT_ARM_TLS (AArch TLS registers)");
15250 case NT_ARM_HW_BREAK:
15251 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15252 case NT_ARM_HW_WATCH:
15253 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15255 return _("NT_PSTATUS (pstatus structure)");
15257 return _("NT_FPREGS (floating point registers)");
15259 return _("NT_PSINFO (psinfo structure)");
15261 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15263 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15264 case NT_WIN32PSTATUS:
15265 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15267 return _("NT_SIGINFO (siginfo_t data)");
15269 return _("NT_FILE (mapped files)");
15277 return _("NT_VERSION (version)");
15279 return _("NT_ARCH (architecture)");
15280 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15282 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15288 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15293 print_core_note (Elf_Internal_Note *pnote)
15295 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15296 bfd_vma count, page_size;
15297 unsigned char *descdata, *filenames, *descend;
15299 if (pnote->type != NT_FILE)
15305 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15306 /* Still "successful". */
15311 if (pnote->descsz < 2 * addr_size)
15313 printf (_(" Malformed note - too short for header\n"));
15317 descdata = (unsigned char *) pnote->descdata;
15318 descend = descdata + pnote->descsz;
15320 if (descdata[pnote->descsz - 1] != '\0')
15322 printf (_(" Malformed note - does not end with \\0\n"));
15326 count = byte_get (descdata, addr_size);
15327 descdata += addr_size;
15329 page_size = byte_get (descdata, addr_size);
15330 descdata += addr_size;
15332 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15334 printf (_(" Malformed note - too short for supplied file count\n"));
15338 printf (_(" Page size: "));
15339 print_vma (page_size, DEC);
15342 printf (_(" %*s%*s%*s\n"),
15343 (int) (2 + 2 * addr_size), _("Start"),
15344 (int) (4 + 2 * addr_size), _("End"),
15345 (int) (4 + 2 * addr_size), _("Page Offset"));
15346 filenames = descdata + count * 3 * addr_size;
15347 while (count-- > 0)
15349 bfd_vma start, end, file_ofs;
15351 if (filenames == descend)
15353 printf (_(" Malformed note - filenames end too early\n"));
15357 start = byte_get (descdata, addr_size);
15358 descdata += addr_size;
15359 end = byte_get (descdata, addr_size);
15360 descdata += addr_size;
15361 file_ofs = byte_get (descdata, addr_size);
15362 descdata += addr_size;
15365 print_vma (start, FULL_HEX);
15367 print_vma (end, FULL_HEX);
15369 print_vma (file_ofs, FULL_HEX);
15370 printf ("\n %s\n", filenames);
15372 filenames += 1 + strlen ((char *) filenames);
15378 static const char *
15379 get_gnu_elf_note_type (unsigned e_type)
15381 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15384 case NT_GNU_ABI_TAG:
15385 return _("NT_GNU_ABI_TAG (ABI version tag)");
15387 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15388 case NT_GNU_BUILD_ID:
15389 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15390 case NT_GNU_GOLD_VERSION:
15391 return _("NT_GNU_GOLD_VERSION (gold version)");
15392 case NT_GNU_PROPERTY_TYPE_0:
15393 return _("NT_GNU_PROPERTY_TYPE_0");
15394 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15395 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15396 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15397 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15400 static char buff[64];
15402 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15409 decode_x86_isa (unsigned int bitmask)
15413 unsigned int bit = bitmask & (- bitmask);
15418 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
15419 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
15420 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
15421 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
15422 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
15423 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
15424 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
15425 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
15426 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
15427 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
15428 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
15429 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
15430 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
15431 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
15432 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
15433 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
15434 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
15435 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
15436 default: printf (_("<unknown: %x>"), bit); break;
15444 print_gnu_property_note (Elf_Internal_Note * pnote)
15446 unsigned char * ptr = (unsigned char *) pnote->descdata;
15447 unsigned char * ptr_end = ptr + pnote->descsz;
15448 unsigned int size = is_32bit_elf ? 4 : 8;
15450 printf (_(" Properties: "));
15452 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
15454 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
15458 while (ptr < ptr_end)
15462 unsigned int datasz;
15464 if ((size_t) (ptr_end - ptr) < 8)
15466 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
15470 type = byte_get (ptr, 4);
15471 datasz = byte_get (ptr + 4, 4);
15475 if (datasz > (size_t) (ptr_end - ptr))
15477 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
15482 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
15484 if (elf_header.e_machine == EM_X86_64
15485 || elf_header.e_machine == EM_IAMCU
15486 || elf_header.e_machine == EM_386)
15490 case GNU_PROPERTY_X86_ISA_1_USED:
15491 printf ("x86 ISA used: ");
15493 printf (_("<corrupt length: %#x> "), datasz);
15495 decode_x86_isa (byte_get (ptr, 4));
15498 case GNU_PROPERTY_X86_ISA_1_NEEDED:
15499 printf ("x86 ISA needed: ");
15501 printf (_("<corrupt length: %#x> "), datasz);
15503 decode_x86_isa (byte_get (ptr, 4));
15515 case GNU_PROPERTY_STACK_SIZE:
15516 printf (_("stack size: "));
15517 if (datasz != size)
15518 printf (_("<corrupt length: %#x> "), datasz);
15520 printf ("%#lx", (unsigned long) byte_get (ptr, size));
15523 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
15524 printf ("no copy on protected ");
15526 printf (_("<corrupt length: %#x> "), datasz);
15534 if (type < GNU_PROPERTY_LOPROC)
15535 printf (_("<unknown type %#x data: "), type);
15536 else if (type < GNU_PROPERTY_LOUSER)
15537 printf (_("<procesor-specific type %#x data: "), type);
15539 printf (_("<application-specific type %#x data: "), type);
15540 for (j = 0; j < datasz; ++j)
15541 printf ("%02x ", ptr[j] & 0xff);
15545 ptr += ((datasz + (size - 1)) & ~ (size - 1));
15546 if (ptr == ptr_end)
15560 print_gnu_note (Elf_Internal_Note *pnote)
15562 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
15563 switch (pnote->type)
15565 case NT_GNU_BUILD_ID:
15569 printf (_(" Build ID: "));
15570 for (i = 0; i < pnote->descsz; ++i)
15571 printf ("%02x", pnote->descdata[i] & 0xff);
15576 case NT_GNU_ABI_TAG:
15578 unsigned long os, major, minor, subminor;
15579 const char *osname;
15581 /* PR 17531: file: 030-599401-0.004. */
15582 if (pnote->descsz < 16)
15584 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15588 os = byte_get ((unsigned char *) pnote->descdata, 4);
15589 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15590 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
15591 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
15595 case GNU_ABI_TAG_LINUX:
15598 case GNU_ABI_TAG_HURD:
15601 case GNU_ABI_TAG_SOLARIS:
15602 osname = "Solaris";
15604 case GNU_ABI_TAG_FREEBSD:
15605 osname = "FreeBSD";
15607 case GNU_ABI_TAG_NETBSD:
15610 case GNU_ABI_TAG_SYLLABLE:
15611 osname = "Syllable";
15613 case GNU_ABI_TAG_NACL:
15617 osname = "Unknown";
15621 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
15622 major, minor, subminor);
15626 case NT_GNU_GOLD_VERSION:
15630 printf (_(" Version: "));
15631 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
15632 printf ("%c", pnote->descdata[i]);
15639 unsigned long num_entries, mask;
15641 /* Hardware capabilities information. Word 0 is the number of entries.
15642 Word 1 is a bitmask of enabled entries. The rest of the descriptor
15643 is a series of entries, where each entry is a single byte followed
15644 by a nul terminated string. The byte gives the bit number to test
15645 if enabled in the bitmask. */
15646 printf (_(" Hardware Capabilities: "));
15647 if (pnote->descsz < 8)
15649 printf (_("<corrupt GNU_HWCAP>\n"));
15652 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
15653 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
15654 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
15655 /* FIXME: Add code to display the entries... */
15659 case NT_GNU_PROPERTY_TYPE_0:
15660 print_gnu_property_note (pnote);
15664 /* Handle unrecognised types. An error message should have already been
15665 created by get_gnu_elf_note_type(), so all that we need to do is to
15666 display the data. */
15670 printf (_(" Description data: "));
15671 for (i = 0; i < pnote->descsz; ++i)
15672 printf ("%02x ", pnote->descdata[i] & 0xff);
15681 static const char *
15682 get_v850_elf_note_type (enum v850_notes n_type)
15684 static char buff[64];
15688 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
15689 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
15690 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
15691 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
15692 case V850_NOTE_CACHE_INFO: return _("Use of cache");
15693 case V850_NOTE_MMU_INFO: return _("Use of MMU");
15695 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
15701 print_v850_note (Elf_Internal_Note * pnote)
15705 if (pnote->descsz != 4)
15707 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
15711 printf (_("not set\n"));
15715 switch (pnote->type)
15717 case V850_NOTE_ALIGNMENT:
15720 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
15721 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
15725 case V850_NOTE_DATA_SIZE:
15728 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
15729 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
15733 case V850_NOTE_FPU_INFO:
15736 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
15737 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
15741 case V850_NOTE_MMU_INFO:
15742 case V850_NOTE_CACHE_INFO:
15743 case V850_NOTE_SIMD_INFO:
15744 if (val == EF_RH850_SIMD)
15746 printf (_("yes\n"));
15752 /* An 'unknown note type' message will already have been displayed. */
15756 printf (_("unknown value: %x\n"), val);
15761 process_netbsd_elf_note (Elf_Internal_Note * pnote)
15763 unsigned int version;
15765 switch (pnote->type)
15767 case NT_NETBSD_IDENT:
15768 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
15769 if ((version / 10000) % 100)
15770 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
15771 version, version / 100000000, (version / 1000000) % 100,
15772 (version / 10000) % 100 > 26 ? "Z" : "",
15773 'A' + (version / 10000) % 26);
15775 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
15776 version, version / 100000000, (version / 1000000) % 100,
15777 (version / 100) % 100);
15780 case NT_NETBSD_MARCH:
15781 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
15789 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
15794 static const char *
15795 get_freebsd_elfcore_note_type (unsigned e_type)
15799 case NT_FREEBSD_THRMISC:
15800 return _("NT_THRMISC (thrmisc structure)");
15801 case NT_FREEBSD_PROCSTAT_PROC:
15802 return _("NT_PROCSTAT_PROC (proc data)");
15803 case NT_FREEBSD_PROCSTAT_FILES:
15804 return _("NT_PROCSTAT_FILES (files data)");
15805 case NT_FREEBSD_PROCSTAT_VMMAP:
15806 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15807 case NT_FREEBSD_PROCSTAT_GROUPS:
15808 return _("NT_PROCSTAT_GROUPS (groups data)");
15809 case NT_FREEBSD_PROCSTAT_UMASK:
15810 return _("NT_PROCSTAT_UMASK (umask data)");
15811 case NT_FREEBSD_PROCSTAT_RLIMIT:
15812 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15813 case NT_FREEBSD_PROCSTAT_OSREL:
15814 return _("NT_PROCSTAT_OSREL (osreldate data)");
15815 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
15816 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15817 case NT_FREEBSD_PROCSTAT_AUXV:
15818 return _("NT_PROCSTAT_AUXV (auxv data)");
15820 return get_note_type (e_type);
15823 static const char *
15824 get_netbsd_elfcore_note_type (unsigned e_type)
15826 static char buff[64];
15828 if (e_type == NT_NETBSDCORE_PROCINFO)
15830 /* NetBSD core "procinfo" structure. */
15831 return _("NetBSD procinfo structure");
15834 /* As of Jan 2002 there are no other machine-independent notes
15835 defined for NetBSD core files. If the note type is less
15836 than the start of the machine-dependent note types, we don't
15839 if (e_type < NT_NETBSDCORE_FIRSTMACH)
15841 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15845 switch (elf_header.e_machine)
15847 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15848 and PT_GETFPREGS == mach+2. */
15853 case EM_SPARC32PLUS:
15857 case NT_NETBSDCORE_FIRSTMACH + 0:
15858 return _("PT_GETREGS (reg structure)");
15859 case NT_NETBSDCORE_FIRSTMACH + 2:
15860 return _("PT_GETFPREGS (fpreg structure)");
15866 /* On all other arch's, PT_GETREGS == mach+1 and
15867 PT_GETFPREGS == mach+3. */
15871 case NT_NETBSDCORE_FIRSTMACH + 1:
15872 return _("PT_GETREGS (reg structure)");
15873 case NT_NETBSDCORE_FIRSTMACH + 3:
15874 return _("PT_GETFPREGS (fpreg structure)");
15880 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
15881 e_type - NT_NETBSDCORE_FIRSTMACH);
15885 static const char *
15886 get_stapsdt_note_type (unsigned e_type)
15888 static char buff[64];
15893 return _("NT_STAPSDT (SystemTap probe descriptors)");
15899 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15904 print_stapsdt_note (Elf_Internal_Note *pnote)
15906 int addr_size = is_32bit_elf ? 4 : 8;
15907 char *data = pnote->descdata;
15908 char *data_end = pnote->descdata + pnote->descsz;
15909 bfd_vma pc, base_addr, semaphore;
15910 char *provider, *probe, *arg_fmt;
15912 pc = byte_get ((unsigned char *) data, addr_size);
15914 base_addr = byte_get ((unsigned char *) data, addr_size);
15916 semaphore = byte_get ((unsigned char *) data, addr_size);
15920 data += strlen (data) + 1;
15922 data += strlen (data) + 1;
15924 data += strlen (data) + 1;
15926 printf (_(" Provider: %s\n"), provider);
15927 printf (_(" Name: %s\n"), probe);
15928 printf (_(" Location: "));
15929 print_vma (pc, FULL_HEX);
15930 printf (_(", Base: "));
15931 print_vma (base_addr, FULL_HEX);
15932 printf (_(", Semaphore: "));
15933 print_vma (semaphore, FULL_HEX);
15935 printf (_(" Arguments: %s\n"), arg_fmt);
15937 return data == data_end;
15940 static const char *
15941 get_ia64_vms_note_type (unsigned e_type)
15943 static char buff[64];
15948 return _("NT_VMS_MHD (module header)");
15950 return _("NT_VMS_LNM (language name)");
15952 return _("NT_VMS_SRC (source files)");
15954 return "NT_VMS_TITLE";
15956 return _("NT_VMS_EIDC (consistency check)");
15957 case NT_VMS_FPMODE:
15958 return _("NT_VMS_FPMODE (FP mode)");
15959 case NT_VMS_LINKTIME:
15960 return "NT_VMS_LINKTIME";
15961 case NT_VMS_IMGNAM:
15962 return _("NT_VMS_IMGNAM (image name)");
15964 return _("NT_VMS_IMGID (image id)");
15965 case NT_VMS_LINKID:
15966 return _("NT_VMS_LINKID (link id)");
15967 case NT_VMS_IMGBID:
15968 return _("NT_VMS_IMGBID (build id)");
15969 case NT_VMS_GSTNAM:
15970 return _("NT_VMS_GSTNAM (sym table name)");
15971 case NT_VMS_ORIG_DYN:
15972 return "NT_VMS_ORIG_DYN";
15973 case NT_VMS_PATCHTIME:
15974 return "NT_VMS_PATCHTIME";
15976 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15982 print_ia64_vms_note (Elf_Internal_Note * pnote)
15984 switch (pnote->type)
15987 if (pnote->descsz > 36)
15989 size_t l = strlen (pnote->descdata + 34);
15990 printf (_(" Creation date : %.17s\n"), pnote->descdata);
15991 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
15992 printf (_(" Module name : %s\n"), pnote->descdata + 34);
15993 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
15996 printf (_(" Invalid size\n"));
15999 printf (_(" Language: %s\n"), pnote->descdata);
16002 case NT_VMS_FPMODE:
16003 printf (_(" Floating Point mode: "));
16004 printf ("0x%016" BFD_VMA_FMT "x\n",
16005 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
16007 case NT_VMS_LINKTIME:
16008 printf (_(" Link time: "));
16010 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16013 case NT_VMS_PATCHTIME:
16014 printf (_(" Patch time: "));
16016 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16019 case NT_VMS_ORIG_DYN:
16020 printf (_(" Major id: %u, minor id: %u\n"),
16021 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16022 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
16023 printf (_(" Last modified : "));
16025 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
16026 printf (_("\n Link flags : "));
16027 printf ("0x%016" BFD_VMA_FMT "x\n",
16028 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
16029 printf (_(" Header flags: 0x%08x\n"),
16030 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
16031 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16034 case NT_VMS_IMGNAM:
16035 printf (_(" Image name: %s\n"), pnote->descdata);
16037 case NT_VMS_GSTNAM:
16038 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16041 printf (_(" Image id: %s\n"), pnote->descdata);
16043 case NT_VMS_LINKID:
16044 printf (_(" Linker id: %s\n"), pnote->descdata);
16052 /* Find the symbol associated with a build attribute that is attached
16053 to address OFFSET. If PNAME is non-NULL then store the name of
16054 the symbol (if found) in the provided pointer, Returns NULL if a
16055 symbol could not be found. */
16057 static Elf_Internal_Sym *
16058 get_symbol_for_build_attribute (FILE * file,
16059 unsigned long offset,
16060 bfd_boolean is_open_attr,
16061 const char ** pname)
16063 static FILE * saved_file = NULL;
16064 static char * strtab;
16065 static unsigned long strtablen;
16066 static Elf_Internal_Sym * symtab;
16067 static unsigned long nsyms;
16068 Elf_Internal_Sym * saved_sym = NULL;
16069 Elf_Internal_Sym * sym;
16071 if (saved_file == NULL || file != saved_file)
16073 Elf_Internal_Shdr * symsec;
16075 /* Load the symbol and string sections. */
16076 for (symsec = section_headers;
16077 symsec < section_headers + elf_header.e_shnum;
16080 if (symsec->sh_type == SHT_SYMTAB)
16082 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
16084 if (symsec->sh_link < elf_header.e_shnum)
16086 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
16088 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
16089 1, strtab_sec->sh_size,
16090 _("string table"));
16091 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
16098 if (symtab == NULL || strtab == NULL)
16101 /* Find a symbol whose value matches offset. */
16102 for (sym = symtab; sym < symtab + nsyms; sym ++)
16103 if (sym->st_value == offset)
16105 if (sym->st_name >= strtablen)
16106 /* Huh ? This should not happen. */
16109 if (strtab[sym->st_name] == 0)
16112 /* The AArch64 and ARM architectures define mapping symbols
16113 (eg $d, $x, $t) which we want to ignore. */
16114 if (strtab[sym->st_name] == '$'
16115 && strtab[sym->st_name + 1] != 0
16116 && strtab[sym->st_name + 2] == 0)
16121 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16122 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16123 FUNC symbols entirely. */
16124 switch (ELF_ST_TYPE (sym->st_info))
16131 /* If the symbol has a size associated
16132 with it then we can stop searching. */
16133 sym = symtab + nsyms;
16138 /* Ignore function symbols. */
16145 switch (ELF_ST_BIND (sym->st_info))
16148 if (saved_sym == NULL
16149 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
16154 if (saved_sym == NULL)
16164 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
16172 if (saved_sym && pname)
16173 * pname = strtab + saved_sym->st_name;
16179 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
16182 static unsigned long global_offset = 0;
16183 static unsigned long global_end = 0;
16184 static unsigned long func_offset = 0;
16185 static unsigned long func_end = 0;
16187 Elf_Internal_Sym * sym;
16189 unsigned long start;
16191 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
16193 switch (pnote->descsz)
16196 /* A zero-length description means that the range of
16197 the previous note of the same type should be used. */
16200 if (global_end > global_offset)
16201 printf (_(" Applies to region from %#lx to %#lx\n"),
16202 global_offset, global_end);
16204 printf (_(" Applies to region from %#lx\n"), global_offset);
16208 if (func_end > func_offset)
16209 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
16211 printf (_(" Applies to region from %#lx\n"), func_offset);
16216 start = byte_get ((unsigned char *) pnote->descdata, 4);
16223 /* FIXME: We should check that version 3+ notes are being used here... */
16224 start = byte_get ((unsigned char *) pnote->descdata, 4);
16225 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16229 start = byte_get ((unsigned char *) pnote->descdata, 8);
16235 start = byte_get ((unsigned char *) pnote->descdata, 8);
16236 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
16240 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
16241 printf (_(" <invalid descsz>"));
16246 sym = get_symbol_for_build_attribute (file, start, is_open_attr, & name);
16247 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
16248 in order to avoid them being confused with the start address of the
16249 first function in the file... */
16250 if (sym == NULL && is_open_attr)
16251 sym = get_symbol_for_build_attribute (file, start + 2, is_open_attr,
16254 if (end == 0 && sym != NULL && sym->st_size > 0)
16255 end = start + sym->st_size;
16259 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
16260 if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
16261 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
16262 global_end + 1, start - 1);
16264 printf (_(" Applies to region from %#lx"), start);
16265 global_offset = start;
16269 printf (_(" to %#lx"), end);
16275 printf (_(" Applies to region from %#lx"), start);
16276 func_offset = start;
16280 printf (_(" to %#lx"), end);
16286 printf (_(" (%s)"), name);
16293 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
16295 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
16296 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
16297 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
16299 char name_attribute;
16300 const char * expected_types;
16301 const char * name = pnote->namedata;
16305 if (name == NULL || pnote->namesz < 2)
16307 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
16308 print_symbol (-20, _(" <corrupt name field>"));
16317 /* Version 2 of the spec adds a "GA" prefix to the name field. */
16318 if (name[0] == 'G' && name[1] == 'A')
16320 if (pnote->namesz < 4)
16322 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
16323 print_symbol (-20, _(" <corrupt name>"));
16332 switch ((name_type = * name))
16334 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16335 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16336 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16337 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16338 printf ("%c", * name);
16342 error (_("unrecognised attribute type in name field: %d\n"), name_type);
16343 print_symbol (-20, _("<unknown name type>"));
16350 switch ((name_attribute = * name))
16352 case GNU_BUILD_ATTRIBUTE_VERSION:
16353 text = _("<version>");
16354 expected_types = string_expected;
16357 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16358 text = _("<stack prot>");
16359 expected_types = "!+*";
16362 case GNU_BUILD_ATTRIBUTE_RELRO:
16363 text = _("<relro>");
16364 expected_types = bool_expected;
16367 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
16368 text = _("<stack size>");
16369 expected_types = number_expected;
16372 case GNU_BUILD_ATTRIBUTE_TOOL:
16373 text = _("<tool>");
16374 expected_types = string_expected;
16377 case GNU_BUILD_ATTRIBUTE_ABI:
16379 expected_types = "$*";
16382 case GNU_BUILD_ATTRIBUTE_PIC:
16384 expected_types = number_expected;
16387 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
16388 text = _("<short enum>");
16389 expected_types = bool_expected;
16393 if (ISPRINT (* name))
16395 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
16397 if (len > left && ! do_wide)
16399 printf ("%.*s:", len, name);
16405 static char tmpbuf [128];
16407 error (_("unrecognised byte in name field: %d\n"), * name);
16408 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
16412 expected_types = "*$!+";
16417 left -= printf ("%s", text);
16419 if (strchr (expected_types, name_type) == NULL)
16420 warn (_("attribute does not have an expected type (%c)\n"), name_type);
16422 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
16424 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16425 (unsigned long) pnote->namesz,
16426 (long) (name - pnote->namedata));
16430 if (left < 1 && ! do_wide)
16435 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16437 unsigned int bytes;
16438 unsigned long long val = 0;
16439 unsigned int shift = 0;
16440 char * decoded = NULL;
16442 bytes = pnote->namesz - (name - pnote->namedata);
16444 /* The -1 is because the name field is always 0 terminated, and we
16445 want to be able to ensure that the shift in the while loop below
16446 will not overflow. */
16449 if (bytes > sizeof (val))
16451 fprintf (stderr, "namesz %lx name %p namedata %p\n",
16452 pnote->namesz, name, pnote->namedata);
16453 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
16455 bytes = sizeof (val);
16457 /* We do not bother to warn if bytes == 0 as this can
16458 happen with some early versions of the gcc plugin. */
16462 unsigned long byte = (* name ++) & 0xff;
16464 val |= byte << shift;
16468 switch (name_attribute)
16470 case GNU_BUILD_ATTRIBUTE_PIC:
16473 case 0: decoded = "static"; break;
16474 case 1: decoded = "pic"; break;
16475 case 2: decoded = "PIC"; break;
16476 case 3: decoded = "pie"; break;
16477 case 4: decoded = "PIE"; break;
16481 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16484 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
16485 case 0: decoded = "off"; break;
16486 case 1: decoded = "on"; break;
16487 case 2: decoded = "all"; break;
16488 case 3: decoded = "strong"; break;
16489 case 4: decoded = "explicit"; break;
16497 if (decoded != NULL)
16499 print_symbol (-left, decoded);
16510 left -= printf ("0x%llx", val);
16512 left -= printf ("0x%-.*llx", left, val);
16516 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16517 left -= print_symbol (- left, name);
16519 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16520 left -= print_symbol (- left, "true");
16522 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16523 left -= print_symbol (- left, "false");
16527 if (do_wide && left > 0)
16528 printf ("%-*s", left, " ");
16533 /* Note that by the ELF standard, the name field is already null byte
16534 terminated, and namesz includes the terminating null byte.
16535 I.E. the value of namesz for the name "FSF" is 4.
16537 If the value of namesz is zero, there is no name present. */
16540 process_note (Elf_Internal_Note * pnote,
16543 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16546 if (pnote->namesz == 0)
16547 /* If there is no note name, then use the default set of
16548 note type strings. */
16549 nt = get_note_type (pnote->type);
16551 else if (const_strneq (pnote->namedata, "GNU"))
16552 /* GNU-specific object file notes. */
16553 nt = get_gnu_elf_note_type (pnote->type);
16555 else if (const_strneq (pnote->namedata, "FreeBSD"))
16556 /* FreeBSD-specific core file notes. */
16557 nt = get_freebsd_elfcore_note_type (pnote->type);
16559 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
16560 /* NetBSD-specific core file notes. */
16561 nt = get_netbsd_elfcore_note_type (pnote->type);
16563 else if (const_strneq (pnote->namedata, "NetBSD"))
16564 /* NetBSD-specific core file notes. */
16565 return process_netbsd_elf_note (pnote);
16567 else if (strneq (pnote->namedata, "SPU/", 4))
16569 /* SPU-specific core file notes. */
16570 nt = pnote->namedata + 4;
16574 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16575 /* VMS/ia64-specific file notes. */
16576 nt = get_ia64_vms_note_type (pnote->type);
16578 else if (const_strneq (pnote->namedata, "stapsdt"))
16579 nt = get_stapsdt_note_type (pnote->type);
16582 /* Don't recognize this note name; just use the default set of
16583 note type strings. */
16584 nt = get_note_type (pnote->type);
16588 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
16589 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
16590 print_gnu_build_attribute_name (pnote);
16592 print_symbol (-20, name);
16595 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
16597 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
16599 if (const_strneq (pnote->namedata, "IPF/VMS"))
16600 return print_ia64_vms_note (pnote);
16601 else if (const_strneq (pnote->namedata, "GNU"))
16602 return print_gnu_note (pnote);
16603 else if (const_strneq (pnote->namedata, "stapsdt"))
16604 return print_stapsdt_note (pnote);
16605 else if (const_strneq (pnote->namedata, "CORE"))
16606 return print_core_note (pnote);
16607 else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
16608 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
16609 return print_gnu_build_attribute_description (pnote, file);
16615 printf (_(" description data: "));
16616 for (i = 0; i < pnote->descsz; i++)
16617 printf ("%02x ", pnote->descdata[i]);
16627 process_notes_at (FILE * file,
16628 Elf_Internal_Shdr * section,
16633 Elf_External_Note * pnotes;
16634 Elf_External_Note * external;
16636 bfd_boolean res = TRUE;
16643 pnotes = (Elf_External_Note *) get_section_contents (section, file);
16645 apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
16650 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16653 /* FIXME: Core notes seem to be produced with
16654 4-byte alignment even on 64-bit systems. */
16655 if (elf_header.e_type == ET_CORE)
16658 align = is_32bit_elf ? 4 : 4;
16660 if (pnotes == NULL)
16666 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
16668 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16669 (unsigned long) offset, (unsigned long) length);
16671 /* NB: Some note sections may have alignment value of 0 or 1. gABI
16672 specifies that notes should be aligned to 4 bytes in 32-bit
16673 objects and to 8 bytes in 64-bit objects. As a Linux extension,
16674 we also support 4 byte alignment in 64-bit objects. If section
16675 alignment is less than 4, we treate alignment as 4 bytes. */
16678 else if (align != 4 && align != 8)
16680 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
16685 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16687 end = (char *) pnotes + length;
16688 while ((char *) external < end)
16690 Elf_Internal_Note inote;
16693 char * temp = NULL;
16694 size_t data_remaining = end - (char *) external;
16696 if (!is_ia64_vms ())
16698 /* PR binutils/15191
16699 Make sure that there is enough data to read. */
16700 min_notesz = offsetof (Elf_External_Note, name);
16701 if (data_remaining < min_notesz)
16703 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16704 (int) data_remaining);
16707 inote.type = BYTE_GET (external->type);
16708 inote.namesz = BYTE_GET (external->namesz);
16709 inote.namedata = external->name;
16710 inote.descsz = BYTE_GET (external->descsz);
16711 inote.descdata = ((char *) external
16712 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
16713 /* PR 17531: file: 3443835e. */
16714 if (inote.descdata < (char *) pnotes || inote.descdata > end)
16716 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
16717 inote.namesz, (long)(end - inote.namedata));
16718 inote.descdata = inote.namedata;
16722 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16723 next = ((char *) external
16724 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
16728 Elf64_External_VMS_Note *vms_external;
16730 /* PR binutils/15191
16731 Make sure that there is enough data to read. */
16732 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16733 if (data_remaining < min_notesz)
16735 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16736 (int) data_remaining);
16740 vms_external = (Elf64_External_VMS_Note *) external;
16741 inote.type = BYTE_GET (vms_external->type);
16742 inote.namesz = BYTE_GET (vms_external->namesz);
16743 inote.namedata = vms_external->name;
16744 inote.descsz = BYTE_GET (vms_external->descsz);
16745 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16746 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16747 next = inote.descdata + align_power (inote.descsz, 3);
16750 if (inote.descdata < (char *) external + min_notesz
16751 || next < (char *) external + min_notesz
16752 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16753 || inote.namedata + inote.namesz < inote.namedata
16754 || inote.descdata + inote.descsz < inote.descdata
16755 || data_remaining < (size_t)(next - (char *) external))
16757 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16758 (unsigned long) ((char *) external - (char *) pnotes));
16759 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
16760 inote.type, inote.namesz, inote.descsz, (int) align);
16764 external = (Elf_External_Note *) next;
16766 /* Verify that name is null terminated. It appears that at least
16767 one version of Linux (RedHat 6.0) generates corefiles that don't
16768 comply with the ELF spec by failing to include the null byte in
16770 if (inote.namedata[inote.namesz - 1] != '\0')
16772 temp = (char *) malloc (inote.namesz + 1);
16775 error (_("Out of memory allocating space for inote name\n"));
16780 memcpy (temp, inote.namedata, inote.namesz);
16781 temp[inote.namesz] = 0;
16783 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16784 inote.namedata = temp;
16787 res &= process_note (& inote, file);
16802 process_corefile_note_segments (FILE * file)
16804 Elf_Internal_Phdr * segment;
16808 if (! get_program_headers (file))
16811 for (i = 0, segment = program_headers;
16812 i < elf_header.e_phnum;
16815 if (segment->p_type == PT_NOTE)
16816 res &= process_notes_at (file, NULL,
16817 (bfd_vma) segment->p_offset,
16818 (bfd_vma) segment->p_filesz,
16819 (bfd_vma) segment->p_align);
16826 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
16828 Elf_External_Note * pnotes;
16829 Elf_External_Note * external;
16836 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16838 if (pnotes == NULL)
16842 end = (char*) pnotes + length;
16844 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16845 (unsigned long) offset, (unsigned long) length);
16847 while ((char *) external + sizeof (Elf_External_Note) < end)
16849 Elf_External_Note * next;
16850 Elf_Internal_Note inote;
16852 inote.type = BYTE_GET (external->type);
16853 inote.namesz = BYTE_GET (external->namesz);
16854 inote.namedata = external->name;
16855 inote.descsz = BYTE_GET (external->descsz);
16856 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16857 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16859 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
16861 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
16862 inote.descdata = inote.namedata;
16866 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
16868 if ( ((char *) next > end)
16869 || ((char *) next < (char *) pnotes))
16871 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16872 (unsigned long) ((char *) external - (char *) pnotes));
16873 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16874 inote.type, inote.namesz, inote.descsz);
16880 /* Prevent out-of-bounds indexing. */
16881 if ( inote.namedata + inote.namesz > end
16882 || inote.namedata + inote.namesz < inote.namedata)
16884 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16885 (unsigned long) ((char *) external - (char *) pnotes));
16886 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16887 inote.type, inote.namesz, inote.descsz);
16891 printf (" %s: ", get_v850_elf_note_type (inote.type));
16893 if (! print_v850_note (& inote))
16896 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16897 inote.namesz, inote.descsz);
16907 process_note_sections (FILE * file)
16909 Elf_Internal_Shdr * section;
16914 for (i = 0, section = section_headers;
16915 i < elf_header.e_shnum && section != NULL;
16918 if (section->sh_type == SHT_NOTE)
16920 res &= process_notes_at (file, section,
16921 (bfd_vma) section->sh_offset,
16922 (bfd_vma) section->sh_size,
16923 (bfd_vma) section->sh_addralign);
16927 if (( elf_header.e_machine == EM_V800
16928 || elf_header.e_machine == EM_V850
16929 || elf_header.e_machine == EM_CYGNUS_V850)
16930 && section->sh_type == SHT_RENESAS_INFO)
16932 res &= process_v850_notes (file,
16933 (bfd_vma) section->sh_offset,
16934 (bfd_vma) section->sh_size);
16940 /* Try processing NOTE segments instead. */
16941 return process_corefile_note_segments (file);
16947 process_notes (FILE * file)
16949 /* If we have not been asked to display the notes then do nothing. */
16953 if (elf_header.e_type != ET_CORE)
16954 return process_note_sections (file);
16956 /* No program headers means no NOTE segment. */
16957 if (elf_header.e_phnum > 0)
16958 return process_corefile_note_segments (file);
16960 printf (_("No note segments present in the core file.\n"));
16965 process_arch_specific (FILE * file)
16970 switch (elf_header.e_machine)
16973 return process_arm_specific (file);
16975 case EM_MIPS_RS3_LE:
16976 return process_mips_specific (file);
16979 return process_nds32_specific (file);
16982 return process_power_specific (file);
16986 return process_s390_specific (file);
16989 case EM_SPARC32PLUS:
16991 return process_sparc_specific (file);
16994 return process_tic6x_specific (file);
16997 return process_msp430x_specific (file);
17005 get_file_header (FILE * file)
17007 /* Read in the identity array. */
17008 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17011 /* Determine how to read the rest of the header. */
17012 switch (elf_header.e_ident[EI_DATA])
17014 default: /* fall through */
17015 case ELFDATANONE: /* fall through */
17017 byte_get = byte_get_little_endian;
17018 byte_put = byte_put_little_endian;
17021 byte_get = byte_get_big_endian;
17022 byte_put = byte_put_big_endian;
17026 /* For now we only support 32 bit and 64 bit ELF files. */
17027 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17029 /* Read in the rest of the header. */
17032 Elf32_External_Ehdr ehdr32;
17034 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17037 elf_header.e_type = BYTE_GET (ehdr32.e_type);
17038 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
17039 elf_header.e_version = BYTE_GET (ehdr32.e_version);
17040 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
17041 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
17042 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
17043 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
17044 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
17045 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17046 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
17047 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17048 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
17049 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
17053 Elf64_External_Ehdr ehdr64;
17055 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17056 we will not be able to cope with the 64bit data found in
17057 64 ELF files. Detect this now and abort before we start
17058 overwriting things. */
17059 if (sizeof (bfd_vma) < 8)
17061 error (_("This instance of readelf has been built without support for a\n\
17062 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17066 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
17069 elf_header.e_type = BYTE_GET (ehdr64.e_type);
17070 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
17071 elf_header.e_version = BYTE_GET (ehdr64.e_version);
17072 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
17073 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
17074 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
17075 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
17076 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
17077 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17078 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
17079 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17080 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
17081 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
17084 if (elf_header.e_shoff)
17086 /* There may be some extensions in the first section header. Don't
17087 bomb if we can't read it. */
17089 get_32bit_section_headers (file, TRUE);
17091 get_64bit_section_headers (file, TRUE);
17097 /* Process one ELF object file according to the command line options.
17098 This file may actually be stored in an archive. The file is
17099 positioned at the start of the ELF object. */
17102 process_object (char * file_name, FILE * file)
17106 if (! get_file_header (file))
17108 error (_("%s: Failed to read file header\n"), file_name);
17112 /* Initialise per file variables. */
17113 for (i = ARRAY_SIZE (version_info); i--;)
17114 version_info[i] = 0;
17116 for (i = ARRAY_SIZE (dynamic_info); i--;)
17117 dynamic_info[i] = 0;
17118 dynamic_info_DT_GNU_HASH = 0;
17120 /* Process the file. */
17122 printf (_("\nFile: %s\n"), file_name);
17124 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17125 Note we do this even if cmdline_dump_sects is empty because we
17126 must make sure that the dump_sets array is zeroed out before each
17127 object file is processed. */
17128 if (num_dump_sects > num_cmdline_dump_sects)
17129 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
17131 if (num_cmdline_dump_sects > 0)
17133 if (num_dump_sects == 0)
17134 /* A sneaky way of allocating the dump_sects array. */
17135 request_dump_bynumber (num_cmdline_dump_sects, 0);
17137 assert (num_dump_sects >= num_cmdline_dump_sects);
17138 memcpy (dump_sects, cmdline_dump_sects,
17139 num_cmdline_dump_sects * sizeof (* dump_sects));
17142 if (! process_file_header ())
17145 if (! process_section_headers (file))
17147 /* Without loaded section headers we cannot process lots of
17149 do_unwind = do_version = do_dump = do_arch = 0;
17151 if (! do_using_dynamic)
17152 do_syms = do_dyn_syms = do_reloc = 0;
17155 if (! process_section_groups (file))
17157 /* Without loaded section groups we cannot process unwind. */
17161 if (process_program_headers (file))
17162 process_dynamic_section (file);
17164 process_relocs (file);
17166 process_unwind (file);
17168 process_symbol_table (file);
17170 process_syminfo (file);
17172 process_version_sections (file);
17174 process_section_contents (file);
17176 process_notes (file);
17178 process_gnu_liblist (file);
17180 process_arch_specific (file);
17182 if (program_headers)
17184 free (program_headers);
17185 program_headers = NULL;
17188 if (section_headers)
17190 free (section_headers);
17191 section_headers = NULL;
17196 free (string_table);
17197 string_table = NULL;
17198 string_table_length = 0;
17201 if (dynamic_strings)
17203 free (dynamic_strings);
17204 dynamic_strings = NULL;
17205 dynamic_strings_length = 0;
17208 if (dynamic_symbols)
17210 free (dynamic_symbols);
17211 dynamic_symbols = NULL;
17212 num_dynamic_syms = 0;
17215 if (dynamic_syminfo)
17217 free (dynamic_syminfo);
17218 dynamic_syminfo = NULL;
17221 if (dynamic_section)
17223 free (dynamic_section);
17224 dynamic_section = NULL;
17227 if (section_headers_groups)
17229 free (section_headers_groups);
17230 section_headers_groups = NULL;
17233 if (section_groups)
17235 struct group_list * g;
17236 struct group_list * next;
17238 for (i = 0; i < group_count; i++)
17240 for (g = section_groups [i].root; g != NULL; g = next)
17247 free (section_groups);
17248 section_groups = NULL;
17251 free_debug_memory ();
17256 /* Process an ELF archive.
17257 On entry the file is positioned just after the ARMAG string. */
17260 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17262 struct archive_info arch;
17263 struct archive_info nested_arch;
17269 /* The ARCH structure is used to hold information about this archive. */
17270 arch.file_name = NULL;
17272 arch.index_array = NULL;
17273 arch.sym_table = NULL;
17274 arch.longnames = NULL;
17276 /* The NESTED_ARCH structure is used as a single-item cache of information
17277 about a nested archive (when members of a thin archive reside within
17278 another regular archive file). */
17279 nested_arch.file_name = NULL;
17280 nested_arch.file = NULL;
17281 nested_arch.index_array = NULL;
17282 nested_arch.sym_table = NULL;
17283 nested_arch.longnames = NULL;
17285 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17291 if (do_archive_index)
17293 if (arch.sym_table == NULL)
17294 error (_("%s: unable to dump the index as none was found\n"), file_name);
17297 unsigned long i, l;
17298 unsigned long current_pos;
17300 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17301 file_name, (unsigned long) arch.index_num, arch.sym_size);
17302 current_pos = ftell (file);
17304 for (i = l = 0; i < arch.index_num; i++)
17306 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17308 char * member_name;
17310 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17312 if (member_name != NULL)
17314 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17316 if (qualified_name != NULL)
17318 printf (_("Contents of binary %s at offset "), qualified_name);
17319 (void) print_vma (arch.index_array[i], PREFIX_HEX);
17321 free (qualified_name);
17326 if (l >= arch.sym_size)
17328 error (_("%s: end of the symbol table reached before the end of the index\n"),
17332 /* PR 17531: file: 0b6630b2. */
17333 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17334 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
17337 if (arch.uses_64bit_indicies)
17342 if (l < arch.sym_size)
17343 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17344 file_name, arch.sym_size - l);
17346 if (fseek (file, current_pos, SEEK_SET) != 0)
17348 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
17354 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17355 && !do_segments && !do_header && !do_dump && !do_version
17356 && !do_histogram && !do_debugging && !do_arch && !do_notes
17357 && !do_section_groups && !do_dyn_syms)
17359 ret = 0; /* Archive index only. */
17370 char * qualified_name;
17372 /* Read the next archive header. */
17373 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17375 error (_("%s: failed to seek to next archive header\n"), file_name);
17378 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17379 if (got != sizeof arch.arhdr)
17383 error (_("%s: failed to read archive header\n"), file_name);
17387 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17389 error (_("%s: did not find a valid archive header\n"), arch.file_name);
17394 arch.next_arhdr_offset += sizeof arch.arhdr;
17396 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17397 if (archive_file_size & 01)
17398 ++archive_file_size;
17400 name = get_archive_member_name (&arch, &nested_arch);
17403 error (_("%s: bad archive file name\n"), file_name);
17407 namelen = strlen (name);
17409 qualified_name = make_qualified_name (&arch, &nested_arch, name);
17410 if (qualified_name == NULL)
17412 error (_("%s: bad archive file name\n"), file_name);
17417 if (is_thin_archive && arch.nested_member_origin == 0)
17419 /* This is a proxy for an external member of a thin archive. */
17420 FILE * member_file;
17421 char * member_file_name = adjust_relative_path (file_name, name, namelen);
17422 if (member_file_name == NULL)
17428 member_file = fopen (member_file_name, "rb");
17429 if (member_file == NULL)
17431 error (_("Input file '%s' is not readable.\n"), member_file_name);
17432 free (member_file_name);
17437 archive_file_offset = arch.nested_member_origin;
17439 ret |= process_object (qualified_name, member_file);
17441 fclose (member_file);
17442 free (member_file_name);
17444 else if (is_thin_archive)
17446 /* PR 15140: Allow for corrupt thin archives. */
17447 if (nested_arch.file == NULL)
17449 error (_("%s: contains corrupt thin archive: %s\n"),
17455 /* This is a proxy for a member of a nested archive. */
17456 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17458 /* The nested archive file will have been opened and setup by
17459 get_archive_member_name. */
17460 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17462 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
17467 ret |= process_object (qualified_name, nested_arch.file);
17471 archive_file_offset = arch.next_arhdr_offset;
17472 arch.next_arhdr_offset += archive_file_size;
17474 ret |= process_object (qualified_name, file);
17477 if (dump_sects != NULL)
17481 num_dump_sects = 0;
17484 free (qualified_name);
17488 if (nested_arch.file != NULL)
17489 fclose (nested_arch.file);
17490 release_archive (&nested_arch);
17491 release_archive (&arch);
17497 process_file (char * file_name)
17500 struct stat statbuf;
17501 char armag[SARMAG];
17504 if (stat (file_name, &statbuf) < 0)
17506 if (errno == ENOENT)
17507 error (_("'%s': No such file\n"), file_name);
17509 error (_("Could not locate '%s'. System error message: %s\n"),
17510 file_name, strerror (errno));
17514 if (! S_ISREG (statbuf.st_mode))
17516 error (_("'%s' is not an ordinary file\n"), file_name);
17520 file = fopen (file_name, "rb");
17523 error (_("Input file '%s' is not readable.\n"), file_name);
17527 if (fread (armag, SARMAG, 1, file) != 1)
17529 error (_("%s: Failed to read file's magic number\n"), file_name);
17534 current_file_size = (bfd_size_type) statbuf.st_size;
17536 if (memcmp (armag, ARMAG, SARMAG) == 0)
17537 ret = process_archive (file_name, file, FALSE);
17538 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
17539 ret = process_archive (file_name, file, TRUE);
17542 if (do_archive_index)
17543 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17547 archive_file_size = archive_file_offset = 0;
17548 ret = process_object (file_name, file);
17553 current_file_size = 0;
17557 #ifdef SUPPORT_DISASSEMBLY
17558 /* Needed by the i386 disassembler. For extra credit, someone could
17559 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17563 print_address (unsigned int addr, FILE * outfile)
17565 fprintf (outfile,"0x%8.8x", addr);
17568 /* Needed by the i386 disassembler. */
17570 db_task_printsym (unsigned int addr)
17572 print_address (addr, stderr);
17577 main (int argc, char ** argv)
17581 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17582 setlocale (LC_MESSAGES, "");
17584 #if defined (HAVE_SETLOCALE)
17585 setlocale (LC_CTYPE, "");
17587 bindtextdomain (PACKAGE, LOCALEDIR);
17588 textdomain (PACKAGE);
17590 expandargv (&argc, &argv);
17592 parse_args (argc, argv);
17594 if (num_dump_sects > 0)
17596 /* Make a copy of the dump_sects array. */
17597 cmdline_dump_sects = (dump_type *)
17598 malloc (num_dump_sects * sizeof (* dump_sects));
17599 if (cmdline_dump_sects == NULL)
17600 error (_("Out of memory allocating dump request table.\n"));
17603 memcpy (cmdline_dump_sects, dump_sects,
17604 num_dump_sects * sizeof (* dump_sects));
17605 num_cmdline_dump_sects = num_dump_sects;
17609 if (optind < (argc - 1))
17611 else if (optind >= argc)
17613 warn (_("Nothing to do.\n"));
17618 while (optind < argc)
17619 err |= process_file (argv[optind++]);
17621 if (dump_sects != NULL)
17623 if (cmdline_dump_sects != NULL)
17624 free (cmdline_dump_sects);