1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/mcore.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
136 #include "elf/nios2.h"
137 #include "elf/or1k.h"
140 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 char * program_name = "readelf";
170 static unsigned long archive_file_offset;
171 static unsigned long archive_file_size;
172 static bfd_size_type current_file_size;
173 static unsigned long dynamic_addr;
174 static bfd_size_type dynamic_size;
175 static size_t dynamic_nent;
176 static char * dynamic_strings;
177 static unsigned long dynamic_strings_length;
178 static char * string_table;
179 static unsigned long string_table_length;
180 static unsigned long num_dynamic_syms;
181 static Elf_Internal_Sym * dynamic_symbols;
182 static Elf_Internal_Syminfo * dynamic_syminfo;
183 static unsigned long dynamic_syminfo_offset;
184 static unsigned int dynamic_syminfo_nent;
185 static char program_interpreter[PATH_MAX];
186 static bfd_vma dynamic_info[DT_ENCODING];
187 static bfd_vma dynamic_info_DT_GNU_HASH;
188 static bfd_vma version_info[16];
189 static Elf_Internal_Ehdr elf_header;
190 static Elf_Internal_Shdr * section_headers;
191 static Elf_Internal_Phdr * program_headers;
192 static Elf_Internal_Dyn * dynamic_section;
193 static Elf_Internal_Shdr * symtab_shndx_hdr;
194 static int show_name;
195 static int do_dynamic;
197 static int do_dyn_syms;
199 static int do_sections;
200 static int do_section_groups;
201 static int do_section_details;
202 static int do_segments;
203 static int do_unwind;
204 static int do_using_dynamic;
205 static int do_header;
207 static int do_version;
208 static int do_histogram;
209 static int do_debugging;
212 static int do_archive_index;
213 static int is_32bit_elf;
217 struct group_list * next;
218 unsigned int section_index;
223 struct group_list * root;
224 unsigned int group_index;
227 static size_t group_count;
228 static struct group * section_groups;
229 static struct group ** section_headers_groups;
232 /* Flag bits indicating particular types of dump. */
233 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
234 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
237 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
239 typedef unsigned char dump_type;
241 /* A linked list of the section names for which dumps were requested. */
242 struct dump_list_entry
246 struct dump_list_entry * next;
248 static struct dump_list_entry * dump_sects_byname;
250 /* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252 static dump_type * cmdline_dump_sects = NULL;
253 static unsigned int num_cmdline_dump_sects = 0;
255 /* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
260 static dump_type * dump_sects = NULL;
261 static unsigned int num_dump_sects = 0;
264 /* How to print a vma value. */
265 typedef enum print_mode
277 /* Versioned symbol info. */
278 enum versioned_symbol_info
285 static const char *get_symbol_version_string
286 (FILE *file, int is_dynsym, const char *strtab,
287 unsigned long int strtab_size, unsigned int si,
288 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
289 unsigned short *vna_other);
293 #define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
297 : string_table + (X)->sh_name))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
305 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
310 #define REMOVE_ARCH_BITS(ADDR) \
313 if (elf_header.e_machine == EM_ARM) \
318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
323 and REASON is not NULL then emit an error message using REASON as part of the
327 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
328 bfd_size_type nmemb, const char * reason)
331 bfd_size_type amt = size * nmemb;
333 if (size == 0 || nmemb == 0)
336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type)
340 && ( (bfd_size_type) ((size_t) size) != size
341 || (bfd_size_type) ((size_t) nmemb) != nmemb))
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb, (unsigned long long) size, reason);
349 /* Check for size overflow. */
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb, (unsigned long long) size, reason);
358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt > current_file_size
361 || offset + archive_file_offset + amt > current_file_size)
364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt, reason);
369 if (fseek (file, archive_file_offset + offset, SEEK_SET))
372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset + offset, reason);
380 /* Check for overflow. */
381 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
382 /* + 1 so that we can '\0' terminate invalid string table sections. */
383 mvar = malloc ((size_t) amt + 1);
388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt, reason);
393 ((char *) mvar)[amt] = '\0';
396 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt, reason);
409 /* Print a VMA value. */
412 print_vma (bfd_vma vma, print_mode mode)
425 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
432 return printf ("%5" BFD_VMA_FMT "d", vma);
440 return nc + printf ("%" BFD_VMA_FMT "x", vma);
443 return printf ("%" BFD_VMA_FMT "d", vma);
446 return printf ("%" BFD_VMA_FMT "u", vma);
451 /* Display a symbol on stdout. Handles the display of control characters and
452 multibye characters (assuming the host environment supports them).
454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
459 Returns the number of emitted characters. */
462 print_symbol (int width, const char *symbol)
464 bfd_boolean extra_padding = FALSE;
466 #ifdef HAVE_MBSTATE_T
473 /* Keep the width positive. This also helps. */
475 extra_padding = TRUE;
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining = INT_MAX;
484 width_remaining = width;
486 #ifdef HAVE_MBSTATE_T
487 /* Initialise the multibyte conversion state. */
488 memset (& state, 0, sizeof (state));
491 while (width_remaining)
494 const char c = *symbol++;
499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
504 if (width_remaining < 2)
507 printf ("^%c", c + 0x40);
508 width_remaining -= 2;
511 else if (ISPRINT (c))
519 #ifdef HAVE_MBSTATE_T
522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol - 1);
527 #ifdef HAVE_MBSTATE_T
528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
531 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
535 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
540 if (extra_padding && num_printed < width)
542 /* Fill in the remaining spaces. */
543 printf ("%-*s", width - num_printed, " ");
550 /* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
555 printable_section_name (Elf_Internal_Shdr * sec)
557 #define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
559 const char * name = SECTION_NAME (sec);
560 char * buf = sec_name_buf;
562 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
564 while ((c = * name ++) != 0)
575 else if (ISPRINT (c))
582 static char hex[17] = "0123456789ABCDEF";
587 * buf ++ = hex[(c & 0xf0) >> 4];
588 * buf ++ = hex[c & 0x0f];
602 printable_section_name_from_index (unsigned long ndx)
604 if (ndx >= elf_header.e_shnum)
605 return _("<corrupt>");
607 return printable_section_name (section_headers + ndx);
610 /* Return a pointer to section NAME, or NULL if no such section exists. */
612 static Elf_Internal_Shdr *
613 find_section (const char * name)
617 for (i = 0; i < elf_header.e_shnum; i++)
618 if (streq (SECTION_NAME (section_headers + i), name))
619 return section_headers + i;
624 /* Return a pointer to a section containing ADDR, or NULL if no such
627 static Elf_Internal_Shdr *
628 find_section_by_address (bfd_vma addr)
632 for (i = 0; i < elf_header.e_shnum; i++)
634 Elf_Internal_Shdr *sec = section_headers + i;
635 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
642 static Elf_Internal_Shdr *
643 find_section_by_type (unsigned int type)
647 for (i = 0; i < elf_header.e_shnum; i++)
649 Elf_Internal_Shdr *sec = section_headers + i;
650 if (sec->sh_type == type)
657 /* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
660 static Elf_Internal_Shdr *
661 find_section_in_set (const char * name, unsigned int * set)
667 while ((i = *set++) > 0)
668 if (streq (SECTION_NAME (section_headers + i), name))
669 return section_headers + i;
672 return find_section (name);
675 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
678 static inline unsigned long
679 read_uleb128 (unsigned char *data,
680 unsigned int *length_return,
681 const unsigned char * const end)
683 return read_leb128 (data, length_return, FALSE, end);
686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
693 return elf_header.e_machine == EM_IA_64
694 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
697 /* Guess the relocation size commonly used by the specific machines. */
700 guess_is_rela (unsigned int e_machine)
704 /* Targets that use REL relocations. */
719 /* Targets that use RELA relocations. */
723 case EM_ADAPTEVA_EPIPHANY:
725 case EM_ALTERA_NIOS2:
745 case EM_LATTICEMICO32:
754 case EM_CYGNUS_MN10200:
756 case EM_CYGNUS_MN10300:
790 case EM_MICROBLAZE_OLD:
811 warn (_("Don't know about relocations on this machine architecture\n"));
817 slurp_rela_relocs (FILE * file,
818 unsigned long rel_offset,
819 unsigned long rel_size,
820 Elf_Internal_Rela ** relasp,
821 unsigned long * nrelasp)
823 Elf_Internal_Rela * relas;
829 Elf32_External_Rela * erelas;
831 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
832 rel_size, _("32-bit relocation data"));
836 nrelas = rel_size / sizeof (Elf32_External_Rela);
838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
844 error (_("out of memory parsing relocs\n"));
848 for (i = 0; i < nrelas; i++)
850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
859 Elf64_External_Rela * erelas;
861 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
862 rel_size, _("64-bit relocation data"));
866 nrelas = rel_size / sizeof (Elf64_External_Rela);
868 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
869 sizeof (Elf_Internal_Rela));
874 error (_("out of memory parsing relocs\n"));
878 for (i = 0; i < nrelas; i++)
880 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
881 relas[i].r_info = BYTE_GET (erelas[i].r_info);
882 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
888 if (elf_header.e_machine == EM_MIPS
889 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
896 bfd_vma inf = relas[i].r_info;
897 inf = (((inf & 0xffffffff) << 32)
898 | ((inf >> 56) & 0xff)
899 | ((inf >> 40) & 0xff00)
900 | ((inf >> 24) & 0xff0000)
901 | ((inf >> 8) & 0xff000000));
902 relas[i].r_info = inf;
915 slurp_rel_relocs (FILE * file,
916 unsigned long rel_offset,
917 unsigned long rel_size,
918 Elf_Internal_Rela ** relsp,
919 unsigned long * nrelsp)
921 Elf_Internal_Rela * rels;
927 Elf32_External_Rel * erels;
929 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
930 rel_size, _("32-bit relocation data"));
934 nrels = rel_size / sizeof (Elf32_External_Rel);
936 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
941 error (_("out of memory parsing relocs\n"));
945 for (i = 0; i < nrels; i++)
947 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
948 rels[i].r_info = BYTE_GET (erels[i].r_info);
949 rels[i].r_addend = 0;
956 Elf64_External_Rel * erels;
958 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
959 rel_size, _("64-bit relocation data"));
963 nrels = rel_size / sizeof (Elf64_External_Rel);
965 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
970 error (_("out of memory parsing relocs\n"));
974 for (i = 0; i < nrels; i++)
976 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
977 rels[i].r_info = BYTE_GET (erels[i].r_info);
978 rels[i].r_addend = 0;
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
984 if (elf_header.e_machine == EM_MIPS
985 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
992 bfd_vma inf = rels[i].r_info;
993 inf = (((inf & 0xffffffff) << 32)
994 | ((inf >> 56) & 0xff)
995 | ((inf >> 40) & 0xff00)
996 | ((inf >> 24) & 0xff0000)
997 | ((inf >> 8) & 0xff000000));
998 rels[i].r_info = inf;
1010 /* Returns the reloc type extracted from the reloc info field. */
1013 get_reloc_type (bfd_vma reloc_info)
1016 return ELF32_R_TYPE (reloc_info);
1018 switch (elf_header.e_machine)
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info);
1025 return ELF64_R_TYPE_ID (reloc_info);
1028 return ELF64_R_TYPE (reloc_info);
1032 /* Return the symbol index extracted from the reloc info field. */
1035 get_reloc_symindex (bfd_vma reloc_info)
1037 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1044 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1051 /* Display the contents of the relocation data found at the specified
1055 dump_relocations (FILE * file,
1056 unsigned long rel_offset,
1057 unsigned long rel_size,
1058 Elf_Internal_Sym * symtab,
1059 unsigned long nsyms,
1061 unsigned long strtablen,
1066 Elf_Internal_Rela * rels;
1068 if (is_rela == UNKNOWN)
1069 is_rela = guess_is_rela (elf_header.e_machine);
1073 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1078 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1117 for (i = 0; i < rel_size; i++)
1122 bfd_vma symtab_index;
1125 offset = rels[i].r_offset;
1126 inf = rels[i].r_info;
1128 type = get_reloc_type (inf);
1129 symtab_index = get_reloc_symindex (inf);
1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset & 0xffffffff,
1135 (unsigned long) inf & 0xffffffff);
1139 #if BFD_HOST_64BIT_LONG
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
1144 #elif BFD_HOST_64BIT_LONG_LONG
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1160 _bfd_int64_high (offset),
1161 _bfd_int64_low (offset),
1162 _bfd_int64_high (inf),
1163 _bfd_int64_low (inf));
1167 switch (elf_header.e_machine)
1174 rtype = elf_aarch64_reloc_type (type);
1178 case EM_CYGNUS_M32R:
1179 rtype = elf_m32r_reloc_type (type);
1184 rtype = elf_i386_reloc_type (type);
1189 rtype = elf_m68hc11_reloc_type (type);
1193 rtype = elf_m68k_reloc_type (type);
1197 rtype = elf_i960_reloc_type (type);
1202 rtype = elf_avr_reloc_type (type);
1205 case EM_OLD_SPARCV9:
1206 case EM_SPARC32PLUS:
1209 rtype = elf_sparc_reloc_type (type);
1213 rtype = elf_spu_reloc_type (type);
1217 rtype = v800_reloc_type (type);
1220 case EM_CYGNUS_V850:
1221 rtype = v850_reloc_type (type);
1225 case EM_CYGNUS_D10V:
1226 rtype = elf_d10v_reloc_type (type);
1230 case EM_CYGNUS_D30V:
1231 rtype = elf_d30v_reloc_type (type);
1235 rtype = elf_dlx_reloc_type (type);
1239 rtype = elf_sh_reloc_type (type);
1243 case EM_CYGNUS_MN10300:
1244 rtype = elf_mn10300_reloc_type (type);
1248 case EM_CYGNUS_MN10200:
1249 rtype = elf_mn10200_reloc_type (type);
1253 case EM_CYGNUS_FR30:
1254 rtype = elf_fr30_reloc_type (type);
1258 rtype = elf_frv_reloc_type (type);
1262 rtype = elf_ft32_reloc_type (type);
1266 rtype = elf_mcore_reloc_type (type);
1270 rtype = elf_mmix_reloc_type (type);
1274 rtype = elf_moxie_reloc_type (type);
1278 if (uses_msp430x_relocs ())
1280 rtype = elf_msp430x_reloc_type (type);
1284 rtype = elf_msp430_reloc_type (type);
1288 rtype = elf_nds32_reloc_type (type);
1292 rtype = elf_ppc_reloc_type (type);
1296 rtype = elf_ppc64_reloc_type (type);
1300 case EM_MIPS_RS3_LE:
1301 rtype = elf_mips_reloc_type (type);
1305 rtype = elf_alpha_reloc_type (type);
1309 rtype = elf_arm_reloc_type (type);
1313 rtype = elf_arc_reloc_type (type);
1317 rtype = elf_hppa_reloc_type (type);
1323 rtype = elf_h8_reloc_type (type);
1327 rtype = elf_or1k_reloc_type (type);
1332 rtype = elf_pj_reloc_type (type);
1335 rtype = elf_ia64_reloc_type (type);
1339 rtype = elf_cris_reloc_type (type);
1343 rtype = elf_i860_reloc_type (type);
1349 rtype = elf_x86_64_reloc_type (type);
1353 rtype = i370_reloc_type (type);
1358 rtype = elf_s390_reloc_type (type);
1362 rtype = elf_score_reloc_type (type);
1366 rtype = elf_xstormy16_reloc_type (type);
1370 rtype = elf_crx_reloc_type (type);
1374 rtype = elf_vax_reloc_type (type);
1378 rtype = elf_visium_reloc_type (type);
1381 case EM_ADAPTEVA_EPIPHANY:
1382 rtype = elf_epiphany_reloc_type (type);
1387 rtype = elf_ip2k_reloc_type (type);
1391 rtype = elf_iq2000_reloc_type (type);
1396 rtype = elf_xtensa_reloc_type (type);
1399 case EM_LATTICEMICO32:
1400 rtype = elf_lm32_reloc_type (type);
1405 rtype = elf_m32c_reloc_type (type);
1409 rtype = elf_mt_reloc_type (type);
1413 rtype = elf_bfin_reloc_type (type);
1417 rtype = elf_mep_reloc_type (type);
1421 rtype = elf_cr16_reloc_type (type);
1425 case EM_MICROBLAZE_OLD:
1426 rtype = elf_microblaze_reloc_type (type);
1430 rtype = elf_rl78_reloc_type (type);
1434 rtype = elf_rx_reloc_type (type);
1438 rtype = elf_metag_reloc_type (type);
1443 rtype = elf_xc16x_reloc_type (type);
1447 rtype = elf_tic6x_reloc_type (type);
1451 rtype = elf_tilegx_reloc_type (type);
1455 rtype = elf_tilepro_reloc_type (type);
1459 rtype = elf_xgate_reloc_type (type);
1462 case EM_ALTERA_NIOS2:
1463 rtype = elf_nios2_reloc_type (type);
1468 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1470 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1472 if (elf_header.e_machine == EM_ALPHA
1474 && streq (rtype, "R_ALPHA_LITUSE")
1477 switch (rels[i].r_addend)
1479 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1480 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486 default: rtype = NULL;
1489 printf (" (%s)", rtype);
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels[i].r_addend);
1497 else if (symtab_index)
1499 if (symtab == NULL || symtab_index >= nsyms)
1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1503 Elf_Internal_Sym * psym;
1504 const char * version_string;
1505 enum versioned_symbol_info sym_info;
1506 unsigned short vna_other;
1508 psym = symtab + symtab_index;
1511 = get_symbol_version_string (file, is_dynsym,
1520 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1524 unsigned int width = is_32bit_elf ? 8 : 14;
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1537 || psym->st_name == 0
1538 || psym->st_name >= strtablen)
1541 name = strtab + psym->st_name;
1543 len = print_symbol (width, name);
1545 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1547 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1551 print_vma (psym->st_value, LONG_HEX);
1553 printf (is_32bit_elf ? " " : " ");
1556 if (psym->st_name == 0)
1558 const char * sec_name = "<null>";
1561 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1563 if (psym->st_shndx < elf_header.e_shnum)
1564 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1565 else if (psym->st_shndx == SHN_ABS)
1567 else if (psym->st_shndx == SHN_COMMON)
1568 sec_name = "COMMON";
1569 else if ((elf_header.e_machine == EM_MIPS
1570 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571 || (elf_header.e_machine == EM_TI_C6000
1572 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1573 sec_name = "SCOMMON";
1574 else if (elf_header.e_machine == EM_MIPS
1575 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576 sec_name = "SUNDEF";
1577 else if ((elf_header.e_machine == EM_X86_64
1578 || elf_header.e_machine == EM_L1OM
1579 || elf_header.e_machine == EM_K1OM)
1580 && psym->st_shndx == SHN_X86_64_LCOMMON)
1581 sec_name = "LARGE_COMMON";
1582 else if (elf_header.e_machine == EM_IA_64
1583 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585 sec_name = "ANSI_COM";
1586 else if (is_ia64_vms ()
1587 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588 sec_name = "VMS_SYMVEC";
1591 sprintf (name_buf, "<section 0x%x>",
1592 (unsigned int) psym->st_shndx);
1593 sec_name = name_buf;
1596 print_symbol (22, sec_name);
1598 else if (strtab == NULL)
1599 printf (_("<string table index: %3ld>"), psym->st_name);
1600 else if (psym->st_name >= strtablen)
1601 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1604 print_symbol (22, strtab + psym->st_name);
1606 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1612 bfd_signed_vma off = rels[i].r_addend;
1614 /* PR 17531: file: 2e63226f. */
1615 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1616 printf (" + %" BFD_VMA_FMT "x", off);
1618 printf (" - %" BFD_VMA_FMT "x", - off);
1620 printf (" + %" BFD_VMA_FMT "x", off);
1626 bfd_signed_vma off = rels[i].r_addend;
1628 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1629 /* PR 17531: file: 2e63226f. */
1630 if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
1631 printf ("%" BFD_VMA_FMT "x", off);
1633 printf ("-%" BFD_VMA_FMT "x", - off);
1635 printf ("%" BFD_VMA_FMT "x", off);
1638 if (elf_header.e_machine == EM_SPARCV9
1640 && streq (rtype, "R_SPARC_OLO10"))
1641 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1646 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1648 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1649 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1650 const char * rtype2 = elf_mips_reloc_type (type2);
1651 const char * rtype3 = elf_mips_reloc_type (type3);
1653 printf (" Type2: ");
1656 printf (_("unrecognized: %-7lx"),
1657 (unsigned long) type2 & 0xffffffff);
1659 printf ("%-17.17s", rtype2);
1661 printf ("\n Type3: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type3 & 0xffffffff);
1667 printf ("%-17.17s", rtype3);
1678 get_mips_dynamic_type (unsigned long type)
1682 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1683 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1684 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1685 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1686 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1687 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1688 case DT_MIPS_MSYM: return "MIPS_MSYM";
1689 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1690 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1691 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1692 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1693 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1694 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1695 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1696 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1697 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1698 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1699 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1725 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1733 get_sparc64_dynamic_type (unsigned long type)
1737 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1744 get_ppc_dynamic_type (unsigned long type)
1748 case DT_PPC_GOT: return "PPC_GOT";
1749 case DT_PPC_OPT: return "PPC_OPT";
1756 get_ppc64_dynamic_type (unsigned long type)
1760 case DT_PPC64_GLINK: return "PPC64_GLINK";
1761 case DT_PPC64_OPD: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1763 case DT_PPC64_OPT: return "PPC64_OPT";
1770 get_parisc_dynamic_type (unsigned long type)
1774 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1787 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT: return "PLT";
1795 case DT_PLT_SIZE: return "PLT_SIZE";
1796 case DT_DLT: return "DLT";
1797 case DT_DLT_SIZE: return "DLT_SIZE";
1804 get_ia64_dynamic_type (unsigned long type)
1808 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1845 get_alpha_dynamic_type (unsigned long type)
1849 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1856 get_score_dynamic_type (unsigned long type)
1860 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1872 get_tic6x_dynamic_type (unsigned long type)
1876 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1888 get_nios2_dynamic_type (unsigned long type)
1892 case DT_NIOS2_GP: return "NIOS2_GP";
1899 get_dynamic_type (unsigned long type)
1901 static char buff[64];
1905 case DT_NULL: return "NULL";
1906 case DT_NEEDED: return "NEEDED";
1907 case DT_PLTRELSZ: return "PLTRELSZ";
1908 case DT_PLTGOT: return "PLTGOT";
1909 case DT_HASH: return "HASH";
1910 case DT_STRTAB: return "STRTAB";
1911 case DT_SYMTAB: return "SYMTAB";
1912 case DT_RELA: return "RELA";
1913 case DT_RELASZ: return "RELASZ";
1914 case DT_RELAENT: return "RELAENT";
1915 case DT_STRSZ: return "STRSZ";
1916 case DT_SYMENT: return "SYMENT";
1917 case DT_INIT: return "INIT";
1918 case DT_FINI: return "FINI";
1919 case DT_SONAME: return "SONAME";
1920 case DT_RPATH: return "RPATH";
1921 case DT_SYMBOLIC: return "SYMBOLIC";
1922 case DT_REL: return "REL";
1923 case DT_RELSZ: return "RELSZ";
1924 case DT_RELENT: return "RELENT";
1925 case DT_PLTREL: return "PLTREL";
1926 case DT_DEBUG: return "DEBUG";
1927 case DT_TEXTREL: return "TEXTREL";
1928 case DT_JMPREL: return "JMPREL";
1929 case DT_BIND_NOW: return "BIND_NOW";
1930 case DT_INIT_ARRAY: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1934 case DT_RUNPATH: return "RUNPATH";
1935 case DT_FLAGS: return "FLAGS";
1937 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1940 case DT_CHECKSUM: return "CHECKSUM";
1941 case DT_PLTPADSZ: return "PLTPADSZ";
1942 case DT_MOVEENT: return "MOVEENT";
1943 case DT_MOVESZ: return "MOVESZ";
1944 case DT_FEATURE: return "FEATURE";
1945 case DT_POSFLAG_1: return "POSFLAG_1";
1946 case DT_SYMINSZ: return "SYMINSZ";
1947 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1949 case DT_ADDRRNGLO: return "ADDRRNGLO";
1950 case DT_CONFIG: return "CONFIG";
1951 case DT_DEPAUDIT: return "DEPAUDIT";
1952 case DT_AUDIT: return "AUDIT";
1953 case DT_PLTPAD: return "PLTPAD";
1954 case DT_MOVETAB: return "MOVETAB";
1955 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1957 case DT_VERSYM: return "VERSYM";
1959 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1961 case DT_RELACOUNT: return "RELACOUNT";
1962 case DT_RELCOUNT: return "RELCOUNT";
1963 case DT_FLAGS_1: return "FLAGS_1";
1964 case DT_VERDEF: return "VERDEF";
1965 case DT_VERDEFNUM: return "VERDEFNUM";
1966 case DT_VERNEED: return "VERNEED";
1967 case DT_VERNEEDNUM: return "VERNEEDNUM";
1969 case DT_AUXILIARY: return "AUXILIARY";
1970 case DT_USED: return "USED";
1971 case DT_FILTER: return "FILTER";
1973 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1978 case DT_GNU_HASH: return "GNU_HASH";
1981 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1983 const char * result;
1985 switch (elf_header.e_machine)
1988 case EM_MIPS_RS3_LE:
1989 result = get_mips_dynamic_type (type);
1992 result = get_sparc64_dynamic_type (type);
1995 result = get_ppc_dynamic_type (type);
1998 result = get_ppc64_dynamic_type (type);
2001 result = get_ia64_dynamic_type (type);
2004 result = get_alpha_dynamic_type (type);
2007 result = get_score_dynamic_type (type);
2010 result = get_tic6x_dynamic_type (type);
2012 case EM_ALTERA_NIOS2:
2013 result = get_nios2_dynamic_type (type);
2023 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2025 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2026 || (elf_header.e_machine == EM_PARISC
2027 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2029 const char * result;
2031 switch (elf_header.e_machine)
2034 result = get_parisc_dynamic_type (type);
2037 result = get_ia64_dynamic_type (type);
2047 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2051 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2058 get_file_type (unsigned e_type)
2060 static char buff[32];
2064 case ET_NONE: return _("NONE (None)");
2065 case ET_REL: return _("REL (Relocatable file)");
2066 case ET_EXEC: return _("EXEC (Executable file)");
2067 case ET_DYN: return _("DYN (Shared object file)");
2068 case ET_CORE: return _("CORE (Core file)");
2071 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2072 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2073 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2074 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2076 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2082 get_machine_name (unsigned e_machine)
2084 static char buff[64]; /* XXX */
2088 case EM_NONE: return _("None");
2089 case EM_AARCH64: return "AArch64";
2090 case EM_M32: return "WE32100";
2091 case EM_SPARC: return "Sparc";
2092 case EM_SPU: return "SPU";
2093 case EM_386: return "Intel 80386";
2094 case EM_68K: return "MC68000";
2095 case EM_88K: return "MC88000";
2096 case EM_486: return "Intel 80486";
2097 case EM_860: return "Intel 80860";
2098 case EM_MIPS: return "MIPS R3000";
2099 case EM_S370: return "IBM System/370";
2100 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2101 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2102 case EM_PARISC: return "HPPA";
2103 case EM_PPC_OLD: return "Power PC (old)";
2104 case EM_SPARC32PLUS: return "Sparc v8+" ;
2105 case EM_960: return "Intel 90860";
2106 case EM_PPC: return "PowerPC";
2107 case EM_PPC64: return "PowerPC64";
2108 case EM_FR20: return "Fujitsu FR20";
2109 case EM_FT32: return "FTDI FT32";
2110 case EM_RH32: return "TRW RH32";
2111 case EM_MCORE: return "MCORE";
2112 case EM_ARM: return "ARM";
2113 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2114 case EM_SH: return "Renesas / SuperH SH";
2115 case EM_SPARCV9: return "Sparc v9";
2116 case EM_TRICORE: return "Siemens Tricore";
2117 case EM_ARC: return "ARC";
2118 case EM_H8_300: return "Renesas H8/300";
2119 case EM_H8_300H: return "Renesas H8/300H";
2120 case EM_H8S: return "Renesas H8S";
2121 case EM_H8_500: return "Renesas H8/500";
2122 case EM_IA_64: return "Intel IA-64";
2123 case EM_MIPS_X: return "Stanford MIPS-X";
2124 case EM_COLDFIRE: return "Motorola Coldfire";
2125 case EM_ALPHA: return "Alpha";
2126 case EM_CYGNUS_D10V:
2127 case EM_D10V: return "d10v";
2128 case EM_CYGNUS_D30V:
2129 case EM_D30V: return "d30v";
2130 case EM_CYGNUS_M32R:
2131 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2132 case EM_CYGNUS_V850:
2133 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2134 case EM_V850: return "Renesas V850";
2135 case EM_CYGNUS_MN10300:
2136 case EM_MN10300: return "mn10300";
2137 case EM_CYGNUS_MN10200:
2138 case EM_MN10200: return "mn10200";
2139 case EM_MOXIE: return "Moxie";
2140 case EM_CYGNUS_FR30:
2141 case EM_FR30: return "Fujitsu FR30";
2142 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2144 case EM_PJ: return "picoJava";
2145 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP: return "Siemens PCP";
2147 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE: return "Motorola Star*Core processor";
2150 case EM_ME16: return "Toyota ME16 processor";
2151 case EM_ST100: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2153 case EM_PDSP: return "Sony DSP processor";
2154 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2156 case EM_FX66: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2160 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2161 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX: return "Silicon Graphics SVx";
2165 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX: return "Digital VAX";
2167 case EM_VISIUM: return "CDS VISIUMcore processor";
2169 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2170 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2171 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2174 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2175 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2176 case EM_PRISM: return "Vitesse Prism";
2177 case EM_X86_64: return "Advanced Micro Devices X86-64";
2178 case EM_L1OM: return "Intel L1OM";
2179 case EM_K1OM: return "Intel K1OM";
2181 case EM_S390: return "IBM S/390";
2182 case EM_SCORE: return "SUNPLUS S+Core";
2183 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2184 case EM_OR1K: return "OpenRISC 1000";
2185 case EM_ARC_A5: return "ARC International ARCompact processor";
2186 case EM_CRX: return "National Semiconductor CRX microprocessor";
2187 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2188 case EM_DLX: return "OpenDLX";
2190 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2191 case EM_IQ2000: return "Vitesse IQ2000";
2193 case EM_XTENSA: return "Tensilica Xtensa Processor";
2194 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K: return "National Semiconductor 32000 series";
2197 case EM_TPC: return "Tenor Network TPC processor";
2198 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX: return "MAX Processor";
2200 case EM_CR: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16: return "Fujitsu F2MC16";
2202 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2203 case EM_LATTICEMICO32: return "Lattice Mico32";
2205 case EM_M32C: return "Renesas M32c";
2206 case EM_MT: return "Morpho Techologies MT processor";
2207 case EM_BLACKFIN: return "Analog Devices Blackfin";
2208 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP: return "Sharp embedded microprocessor";
2210 case EM_ARCA: return "Arca RISC microprocessor";
2211 case EM_UNICORE: return "Unicore";
2212 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2214 case EM_NIOS32: return "Altera Nios";
2215 case EM_ALTERA_NIOS2: return "Altera Nios II";
2217 case EM_XC16X: return "Infineon Technologies xc16x";
2218 case EM_M16C: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000: return "Altium TSK3000 core";
2222 case EM_RS08: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17: return "Seiko Epson C17 family";
2227 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2232 case EM_R32C: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2235 case EM_8051: return "Intel 8051 and variants";
2236 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2243 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2246 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2247 case EM_RL78: return "Renesas RL78";
2248 case EM_RX: return "Renesas RX";
2249 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2250 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2258 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2259 case EM_CUDA: return "NVIDIA CUDA architecture";
2260 case EM_XGATE: return "Motorola XGATE embedded processor";
2262 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2268 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2273 eabi = EF_ARM_EABI_VERSION (e_flags);
2274 e_flags &= ~ EF_ARM_EABIMASK;
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags & EF_ARM_RELEXEC)
2279 strcat (buf, ", relocatable executable");
2280 e_flags &= ~ EF_ARM_RELEXEC;
2283 if (e_flags & EF_ARM_HASENTRY)
2285 strcat (buf, ", has entry point");
2286 e_flags &= ~ EF_ARM_HASENTRY;
2289 /* Now handle EABI specific flags. */
2293 strcat (buf, ", <unrecognized EABI>");
2298 case EF_ARM_EABI_VER1:
2299 strcat (buf, ", Version1 EABI");
2304 /* Process flags one bit at a time. */
2305 flag = e_flags & - e_flags;
2310 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2311 strcat (buf, ", sorted symbol tables");
2321 case EF_ARM_EABI_VER2:
2322 strcat (buf, ", Version2 EABI");
2327 /* Process flags one bit at a time. */
2328 flag = e_flags & - e_flags;
2333 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf, ", sorted symbol tables");
2337 case EF_ARM_DYNSYMSUSESEGIDX:
2338 strcat (buf, ", dynamic symbols use segment index");
2341 case EF_ARM_MAPSYMSFIRST:
2342 strcat (buf, ", mapping symbols precede others");
2352 case EF_ARM_EABI_VER3:
2353 strcat (buf, ", Version3 EABI");
2356 case EF_ARM_EABI_VER4:
2357 strcat (buf, ", Version4 EABI");
2362 /* Process flags one bit at a time. */
2363 flag = e_flags & - e_flags;
2369 strcat (buf, ", BE8");
2373 strcat (buf, ", LE8");
2384 case EF_ARM_EABI_VER5:
2385 strcat (buf, ", Version5 EABI");
2390 /* Process flags one bit at a time. */
2391 flag = e_flags & - e_flags;
2397 strcat (buf, ", BE8");
2401 strcat (buf, ", LE8");
2404 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf, ", soft-float ABI");
2408 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf, ", hard-float ABI");
2419 case EF_ARM_EABI_UNKNOWN:
2420 strcat (buf, ", GNU EABI");
2425 /* Process flags one bit at a time. */
2426 flag = e_flags & - e_flags;
2431 case EF_ARM_INTERWORK:
2432 strcat (buf, ", interworking enabled");
2435 case EF_ARM_APCS_26:
2436 strcat (buf, ", uses APCS/26");
2439 case EF_ARM_APCS_FLOAT:
2440 strcat (buf, ", uses APCS/float");
2444 strcat (buf, ", position independent");
2448 strcat (buf, ", 8 bit structure alignment");
2451 case EF_ARM_NEW_ABI:
2452 strcat (buf, ", uses new ABI");
2455 case EF_ARM_OLD_ABI:
2456 strcat (buf, ", uses old ABI");
2459 case EF_ARM_SOFT_FLOAT:
2460 strcat (buf, ", software FP");
2463 case EF_ARM_VFP_FLOAT:
2464 strcat (buf, ", VFP");
2467 case EF_ARM_MAVERICK_FLOAT:
2468 strcat (buf, ", Maverick FP");
2479 strcat (buf,_(", <unknown>"));
2483 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2485 --size; /* Leave space for null terminator. */
2487 switch (e_flags & EF_AVR_MACH)
2489 case E_AVR_MACH_AVR1:
2490 strncat (buf, ", avr:1", size);
2492 case E_AVR_MACH_AVR2:
2493 strncat (buf, ", avr:2", size);
2495 case E_AVR_MACH_AVR25:
2496 strncat (buf, ", avr:25", size);
2498 case E_AVR_MACH_AVR3:
2499 strncat (buf, ", avr:3", size);
2501 case E_AVR_MACH_AVR31:
2502 strncat (buf, ", avr:31", size);
2504 case E_AVR_MACH_AVR35:
2505 strncat (buf, ", avr:35", size);
2507 case E_AVR_MACH_AVR4:
2508 strncat (buf, ", avr:4", size);
2510 case E_AVR_MACH_AVR5:
2511 strncat (buf, ", avr:5", size);
2513 case E_AVR_MACH_AVR51:
2514 strncat (buf, ", avr:51", size);
2516 case E_AVR_MACH_AVR6:
2517 strncat (buf, ", avr:6", size);
2519 case E_AVR_MACH_AVRTINY:
2520 strncat (buf, ", avr:100", size);
2522 case E_AVR_MACH_XMEGA1:
2523 strncat (buf, ", avr:101", size);
2525 case E_AVR_MACH_XMEGA2:
2526 strncat (buf, ", avr:102", size);
2528 case E_AVR_MACH_XMEGA3:
2529 strncat (buf, ", avr:103", size);
2531 case E_AVR_MACH_XMEGA4:
2532 strncat (buf, ", avr:104", size);
2534 case E_AVR_MACH_XMEGA5:
2535 strncat (buf, ", avr:105", size);
2537 case E_AVR_MACH_XMEGA6:
2538 strncat (buf, ", avr:106", size);
2540 case E_AVR_MACH_XMEGA7:
2541 strncat (buf, ", avr:107", size);
2544 strncat (buf, ", avr:<unknown>", size);
2548 size -= strlen (buf);
2549 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2550 strncat (buf, ", link-relax", size);
2554 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2563 static const char *ABI_STRINGS[] =
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
2572 static const char *VER_STRINGS[] =
2574 "Andes ELF V1.3 or older",
2578 static const char *ARCH_STRINGS[] =
2587 abi = EF_NDS_ABI & e_flags;
2588 arch = EF_NDS_ARCH & e_flags;
2589 config = EF_NDS_INST & e_flags;
2590 version = EF_NDS32_ELF_VERSION & e_flags;
2592 memset (buf, 0, size);
2599 case E_NDS_ABI_V2FP:
2600 case E_NDS_ABI_AABI:
2601 case E_NDS_ABI_V2FP_PLUS:
2602 /* In case there are holes in the array. */
2603 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2607 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2613 case E_NDS32_ELF_VER_1_2:
2614 case E_NDS32_ELF_VER_1_3:
2615 case E_NDS32_ELF_VER_1_4:
2616 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2620 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2624 if (E_NDS_ABI_V0 == abi)
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch == E_NDS_ARCH_STAR_V1_0)
2629 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2635 case E_NDS_ARCH_STAR_V1_0:
2636 case E_NDS_ARCH_STAR_V2_0:
2637 case E_NDS_ARCH_STAR_V3_0:
2638 case E_NDS_ARCH_STAR_V3_M:
2639 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2643 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch == E_NDS_ARCH_STAR_V1_0)
2652 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2653 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2655 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2656 r += snprintf (buf + r, size -r, ", MAC");
2658 if (config & E_NDS32_HAS_DIV_INST)
2659 r += snprintf (buf + r, size -r, ", DIV");
2661 if (config & E_NDS32_HAS_16BIT_INST)
2662 r += snprintf (buf + r, size -r, ", 16b");
2666 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2668 if (version <= E_NDS32_ELF_VER_1_3)
2669 r += snprintf (buf + r, size -r, ", [B8]");
2671 r += snprintf (buf + r, size -r, ", EX9");
2674 if (config & E_NDS32_HAS_MAC_DX_INST)
2675 r += snprintf (buf + r, size -r, ", MAC_DX");
2677 if (config & E_NDS32_HAS_DIV_DX_INST)
2678 r += snprintf (buf + r, size -r, ", DIV_DX");
2680 if (config & E_NDS32_HAS_16BIT_INST)
2682 if (version <= E_NDS32_ELF_VER_1_3)
2683 r += snprintf (buf + r, size -r, ", 16b");
2685 r += snprintf (buf + r, size -r, ", IFC");
2689 if (config & E_NDS32_HAS_EXT_INST)
2690 r += snprintf (buf + r, size -r, ", PERF1");
2692 if (config & E_NDS32_HAS_EXT2_INST)
2693 r += snprintf (buf + r, size -r, ", PERF2");
2695 if (config & E_NDS32_HAS_FPU_INST)
2698 r += snprintf (buf + r, size -r, ", FPU_SP");
2701 if (config & E_NDS32_HAS_FPU_DP_INST)
2704 r += snprintf (buf + r, size -r, ", FPU_DP");
2707 if (config & E_NDS32_HAS_FPU_MAC_INST)
2710 r += snprintf (buf + r, size -r, ", FPU_MAC");
2715 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2717 case E_NDS32_FPU_REG_8SP_4DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2720 case E_NDS32_FPU_REG_16SP_8DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2723 case E_NDS32_FPU_REG_32SP_16DP:
2724 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2726 case E_NDS32_FPU_REG_32SP_32DP:
2727 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2732 if (config & E_NDS32_HAS_AUDIO_INST)
2733 r += snprintf (buf + r, size -r, ", AUDIO");
2735 if (config & E_NDS32_HAS_STRING_INST)
2736 r += snprintf (buf + r, size -r, ", STR");
2738 if (config & E_NDS32_HAS_REDUCED_REGS)
2739 r += snprintf (buf + r, size -r, ", 16REG");
2741 if (config & E_NDS32_HAS_VIDEO_INST)
2743 if (version <= E_NDS32_ELF_VER_1_3)
2744 r += snprintf (buf + r, size -r, ", VIDEO");
2746 r += snprintf (buf + r, size -r, ", SATURATION");
2749 if (config & E_NDS32_HAS_ENCRIPT_INST)
2750 r += snprintf (buf + r, size -r, ", ENCRP");
2752 if (config & E_NDS32_HAS_L2C_INST)
2753 r += snprintf (buf + r, size -r, ", L2C");
2757 get_machine_flags (unsigned e_flags, unsigned e_machine)
2759 static char buf[1024];
2771 decode_ARM_machine_flags (e_flags, buf);
2775 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2779 if (e_flags & EF_BFIN_PIC)
2780 strcat (buf, ", PIC");
2782 if (e_flags & EF_BFIN_FDPIC)
2783 strcat (buf, ", FDPIC");
2785 if (e_flags & EF_BFIN_CODE_IN_L1)
2786 strcat (buf, ", code in L1");
2788 if (e_flags & EF_BFIN_DATA_IN_L1)
2789 strcat (buf, ", data in L1");
2794 switch (e_flags & EF_FRV_CPU_MASK)
2796 case EF_FRV_CPU_GENERIC:
2800 strcat (buf, ", fr???");
2803 case EF_FRV_CPU_FR300:
2804 strcat (buf, ", fr300");
2807 case EF_FRV_CPU_FR400:
2808 strcat (buf, ", fr400");
2810 case EF_FRV_CPU_FR405:
2811 strcat (buf, ", fr405");
2814 case EF_FRV_CPU_FR450:
2815 strcat (buf, ", fr450");
2818 case EF_FRV_CPU_FR500:
2819 strcat (buf, ", fr500");
2821 case EF_FRV_CPU_FR550:
2822 strcat (buf, ", fr550");
2825 case EF_FRV_CPU_SIMPLE:
2826 strcat (buf, ", simple");
2828 case EF_FRV_CPU_TOMCAT:
2829 strcat (buf, ", tomcat");
2835 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2836 strcat (buf, ", m68000");
2837 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2838 strcat (buf, ", cpu32");
2839 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2840 strcat (buf, ", fido_a");
2843 char const * isa = _("unknown");
2844 char const * mac = _("unknown mac");
2845 char const * additional = NULL;
2847 switch (e_flags & EF_M68K_CF_ISA_MASK)
2849 case EF_M68K_CF_ISA_A_NODIV:
2851 additional = ", nodiv";
2853 case EF_M68K_CF_ISA_A:
2856 case EF_M68K_CF_ISA_A_PLUS:
2859 case EF_M68K_CF_ISA_B_NOUSP:
2861 additional = ", nousp";
2863 case EF_M68K_CF_ISA_B:
2866 case EF_M68K_CF_ISA_C:
2869 case EF_M68K_CF_ISA_C_NODIV:
2871 additional = ", nodiv";
2874 strcat (buf, ", cf, isa ");
2877 strcat (buf, additional);
2878 if (e_flags & EF_M68K_CF_FLOAT)
2879 strcat (buf, ", float");
2880 switch (e_flags & EF_M68K_CF_MAC_MASK)
2885 case EF_M68K_CF_MAC:
2888 case EF_M68K_CF_EMAC:
2891 case EF_M68K_CF_EMAC_B:
2904 if (e_flags & EF_PPC_EMB)
2905 strcat (buf, ", emb");
2907 if (e_flags & EF_PPC_RELOCATABLE)
2908 strcat (buf, _(", relocatable"));
2910 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2911 strcat (buf, _(", relocatable-lib"));
2915 if (e_flags & EF_PPC64_ABI)
2917 char abi[] = ", abiv0";
2919 abi[6] += e_flags & EF_PPC64_ABI;
2925 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2926 strcat (buf, ", RH850 ABI");
2928 if (e_flags & EF_V800_850E3)
2929 strcat (buf, ", V3 architecture");
2931 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2932 strcat (buf, ", FPU not used");
2934 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2935 strcat (buf, ", regmode: COMMON");
2937 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2938 strcat (buf, ", r4 not used");
2940 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2941 strcat (buf, ", r30 not used");
2943 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2944 strcat (buf, ", r5 not used");
2946 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2947 strcat (buf, ", r2 not used");
2949 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2951 switch (e_flags & - e_flags)
2953 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2954 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2955 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2956 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2957 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2958 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2959 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2960 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2961 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2962 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2963 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2964 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2965 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2966 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2967 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2968 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2975 case EM_CYGNUS_V850:
2976 switch (e_flags & EF_V850_ARCH)
2978 case E_V850E3V5_ARCH:
2979 strcat (buf, ", v850e3v5");
2981 case E_V850E2V3_ARCH:
2982 strcat (buf, ", v850e2v3");
2985 strcat (buf, ", v850e2");
2988 strcat (buf, ", v850e1");
2991 strcat (buf, ", v850e");
2994 strcat (buf, ", v850");
2997 strcat (buf, _(", unknown v850 architecture variant"));
3003 case EM_CYGNUS_M32R:
3004 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3005 strcat (buf, ", m32r");
3009 case EM_MIPS_RS3_LE:
3010 if (e_flags & EF_MIPS_NOREORDER)
3011 strcat (buf, ", noreorder");
3013 if (e_flags & EF_MIPS_PIC)
3014 strcat (buf, ", pic");
3016 if (e_flags & EF_MIPS_CPIC)
3017 strcat (buf, ", cpic");
3019 if (e_flags & EF_MIPS_UCODE)
3020 strcat (buf, ", ugen_reserved");
3022 if (e_flags & EF_MIPS_ABI2)
3023 strcat (buf, ", abi2");
3025 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3026 strcat (buf, ", odk first");
3028 if (e_flags & EF_MIPS_32BITMODE)
3029 strcat (buf, ", 32bitmode");
3031 if (e_flags & EF_MIPS_NAN2008)
3032 strcat (buf, ", nan2008");
3034 if (e_flags & EF_MIPS_FP64)
3035 strcat (buf, ", fp64");
3037 switch ((e_flags & EF_MIPS_MACH))
3039 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3040 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3041 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3042 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3043 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3044 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3045 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3046 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3047 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3048 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3049 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3050 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3051 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3052 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3053 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3054 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3055 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3057 /* We simply ignore the field in this case to avoid confusion:
3058 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3061 default: strcat (buf, _(", unknown CPU")); break;
3064 switch ((e_flags & EF_MIPS_ABI))
3066 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3067 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3068 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3069 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3071 /* We simply ignore the field in this case to avoid confusion:
3072 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3073 This means it is likely to be an o32 file, but not for
3076 default: strcat (buf, _(", unknown ABI")); break;
3079 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3080 strcat (buf, ", mdmx");
3082 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3083 strcat (buf, ", mips16");
3085 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3086 strcat (buf, ", micromips");
3088 switch ((e_flags & EF_MIPS_ARCH))
3090 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3091 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3092 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3093 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3094 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3095 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3096 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3097 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3098 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3099 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3100 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3101 default: strcat (buf, _(", unknown ISA")); break;
3106 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3110 switch ((e_flags & EF_SH_MACH_MASK))
3112 case EF_SH1: strcat (buf, ", sh1"); break;
3113 case EF_SH2: strcat (buf, ", sh2"); break;
3114 case EF_SH3: strcat (buf, ", sh3"); break;
3115 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3116 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3117 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3118 case EF_SH3E: strcat (buf, ", sh3e"); break;
3119 case EF_SH4: strcat (buf, ", sh4"); break;
3120 case EF_SH5: strcat (buf, ", sh5"); break;
3121 case EF_SH2E: strcat (buf, ", sh2e"); break;
3122 case EF_SH4A: strcat (buf, ", sh4a"); break;
3123 case EF_SH2A: strcat (buf, ", sh2a"); break;
3124 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3125 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3126 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3127 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3128 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3129 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3130 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3131 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3132 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3133 default: strcat (buf, _(", unknown ISA")); break;
3136 if (e_flags & EF_SH_PIC)
3137 strcat (buf, ", pic");
3139 if (e_flags & EF_SH_FDPIC)
3140 strcat (buf, ", fdpic");
3144 if (e_flags & EF_OR1K_NODELAY)
3145 strcat (buf, ", no delay");
3149 if (e_flags & EF_SPARC_32PLUS)
3150 strcat (buf, ", v8+");
3152 if (e_flags & EF_SPARC_SUN_US1)
3153 strcat (buf, ", ultrasparcI");
3155 if (e_flags & EF_SPARC_SUN_US3)
3156 strcat (buf, ", ultrasparcIII");
3158 if (e_flags & EF_SPARC_HAL_R1)
3159 strcat (buf, ", halr1");
3161 if (e_flags & EF_SPARC_LEDATA)
3162 strcat (buf, ", ledata");
3164 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3165 strcat (buf, ", tso");
3167 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3168 strcat (buf, ", pso");
3170 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3171 strcat (buf, ", rmo");
3175 switch (e_flags & EF_PARISC_ARCH)
3177 case EFA_PARISC_1_0:
3178 strcpy (buf, ", PA-RISC 1.0");
3180 case EFA_PARISC_1_1:
3181 strcpy (buf, ", PA-RISC 1.1");
3183 case EFA_PARISC_2_0:
3184 strcpy (buf, ", PA-RISC 2.0");
3189 if (e_flags & EF_PARISC_TRAPNIL)
3190 strcat (buf, ", trapnil");
3191 if (e_flags & EF_PARISC_EXT)
3192 strcat (buf, ", ext");
3193 if (e_flags & EF_PARISC_LSB)
3194 strcat (buf, ", lsb");
3195 if (e_flags & EF_PARISC_WIDE)
3196 strcat (buf, ", wide");
3197 if (e_flags & EF_PARISC_NO_KABP)
3198 strcat (buf, ", no kabp");
3199 if (e_flags & EF_PARISC_LAZYSWAP)
3200 strcat (buf, ", lazyswap");
3205 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3206 strcat (buf, ", new calling convention");
3208 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3209 strcat (buf, ", gnu calling convention");
3213 if ((e_flags & EF_IA_64_ABI64))
3214 strcat (buf, ", 64-bit");
3216 strcat (buf, ", 32-bit");
3217 if ((e_flags & EF_IA_64_REDUCEDFP))
3218 strcat (buf, ", reduced fp model");
3219 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3220 strcat (buf, ", no function descriptors, constant gp");
3221 else if ((e_flags & EF_IA_64_CONS_GP))
3222 strcat (buf, ", constant gp");
3223 if ((e_flags & EF_IA_64_ABSOLUTE))
3224 strcat (buf, ", absolute");
3225 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3227 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3228 strcat (buf, ", vms_linkages");
3229 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3231 case EF_IA_64_VMS_COMCOD_SUCCESS:
3233 case EF_IA_64_VMS_COMCOD_WARNING:
3234 strcat (buf, ", warning");
3236 case EF_IA_64_VMS_COMCOD_ERROR:
3237 strcat (buf, ", error");
3239 case EF_IA_64_VMS_COMCOD_ABORT:
3240 strcat (buf, ", abort");
3243 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3244 e_flags & EF_IA_64_VMS_COMCOD);
3245 strcat (buf, ", <unknown>");
3251 if ((e_flags & EF_VAX_NONPIC))
3252 strcat (buf, ", non-PIC");
3253 if ((e_flags & EF_VAX_DFLOAT))
3254 strcat (buf, ", D-Float");
3255 if ((e_flags & EF_VAX_GFLOAT))
3256 strcat (buf, ", G-Float");
3260 if (e_flags & EF_VISIUM_ARCH_MCM)
3261 strcat (buf, ", mcm");
3262 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3263 strcat (buf, ", mcm24");
3264 if (e_flags & EF_VISIUM_ARCH_GR6)
3265 strcat (buf, ", gr6");
3269 if (e_flags & E_FLAG_RL78_G10)
3270 strcat (buf, ", G10");
3271 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3272 strcat (buf, ", 64-bit doubles");
3276 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3277 strcat (buf, ", 64-bit doubles");
3278 if (e_flags & E_FLAG_RX_DSP)
3279 strcat (buf, ", dsp");
3280 if (e_flags & E_FLAG_RX_PID)
3281 strcat (buf, ", pid");
3282 if (e_flags & E_FLAG_RX_ABI)
3283 strcat (buf, ", RX ABI");
3287 if (e_flags & EF_S390_HIGH_GPRS)
3288 strcat (buf, ", highgprs");
3292 if ((e_flags & EF_C6000_REL))
3293 strcat (buf, ", relocatable module");
3297 strcat (buf, _(": architecture variant: "));
3298 switch (e_flags & EF_MSP430_MACH)
3300 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3301 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3302 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3303 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3304 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3305 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3306 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3307 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3308 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3309 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3310 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3311 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3312 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3313 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3314 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3316 strcat (buf, _(": unknown")); break;
3319 if (e_flags & ~ EF_MSP430_MACH)
3320 strcat (buf, _(": unknown extra flag bits also present"));
3328 get_osabi_name (unsigned int osabi)
3330 static char buff[32];
3334 case ELFOSABI_NONE: return "UNIX - System V";
3335 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3336 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3337 case ELFOSABI_GNU: return "UNIX - GNU";
3338 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3339 case ELFOSABI_AIX: return "UNIX - AIX";
3340 case ELFOSABI_IRIX: return "UNIX - IRIX";
3341 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3342 case ELFOSABI_TRU64: return "UNIX - TRU64";
3343 case ELFOSABI_MODESTO: return "Novell - Modesto";
3344 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3345 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3346 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3347 case ELFOSABI_AROS: return "AROS";
3348 case ELFOSABI_FENIXOS: return "FenixOS";
3351 switch (elf_header.e_machine)
3356 case ELFOSABI_ARM: return "ARM";
3367 case ELFOSABI_STANDALONE: return _("Standalone App");
3376 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3377 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3386 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3392 get_aarch64_segment_type (unsigned long type)
3396 case PT_AARCH64_ARCHEXT:
3397 return "AARCH64_ARCHEXT";
3406 get_arm_segment_type (unsigned long type)
3420 get_mips_segment_type (unsigned long type)
3424 case PT_MIPS_REGINFO:
3426 case PT_MIPS_RTPROC:
3428 case PT_MIPS_OPTIONS:
3430 case PT_MIPS_ABIFLAGS:
3440 get_parisc_segment_type (unsigned long type)
3444 case PT_HP_TLS: return "HP_TLS";
3445 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3446 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3447 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3448 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3449 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3450 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3451 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3452 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3453 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3454 case PT_HP_PARALLEL: return "HP_PARALLEL";
3455 case PT_HP_FASTBIND: return "HP_FASTBIND";
3456 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3457 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3458 case PT_HP_STACK: return "HP_STACK";
3459 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3460 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3461 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3462 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3471 get_ia64_segment_type (unsigned long type)
3475 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3476 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3477 case PT_HP_TLS: return "HP_TLS";
3478 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3479 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3480 case PT_IA_64_HP_STACK: return "HP_STACK";
3489 get_tic6x_segment_type (unsigned long type)
3493 case PT_C6000_PHATTR: return "C6000_PHATTR";
3502 get_segment_type (unsigned long p_type)
3504 static char buff[32];
3508 case PT_NULL: return "NULL";
3509 case PT_LOAD: return "LOAD";
3510 case PT_DYNAMIC: return "DYNAMIC";
3511 case PT_INTERP: return "INTERP";
3512 case PT_NOTE: return "NOTE";
3513 case PT_SHLIB: return "SHLIB";
3514 case PT_PHDR: return "PHDR";
3515 case PT_TLS: return "TLS";
3517 case PT_GNU_EH_FRAME:
3518 return "GNU_EH_FRAME";
3519 case PT_GNU_STACK: return "GNU_STACK";
3520 case PT_GNU_RELRO: return "GNU_RELRO";
3523 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3525 const char * result;
3527 switch (elf_header.e_machine)
3530 result = get_aarch64_segment_type (p_type);
3533 result = get_arm_segment_type (p_type);
3536 case EM_MIPS_RS3_LE:
3537 result = get_mips_segment_type (p_type);
3540 result = get_parisc_segment_type (p_type);
3543 result = get_ia64_segment_type (p_type);
3546 result = get_tic6x_segment_type (p_type);
3556 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3558 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3560 const char * result;
3562 switch (elf_header.e_machine)
3565 result = get_parisc_segment_type (p_type);
3568 result = get_ia64_segment_type (p_type);
3578 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3581 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3588 get_mips_section_type_name (unsigned int sh_type)
3592 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3593 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3594 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3595 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3596 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3597 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3598 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3599 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3600 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3601 case SHT_MIPS_RELD: return "MIPS_RELD";
3602 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3603 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3604 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3605 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3606 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3607 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3608 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3609 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3610 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3611 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3612 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3613 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3614 case SHT_MIPS_LINE: return "MIPS_LINE";
3615 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3616 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3617 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3618 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3619 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3620 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3621 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3622 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3623 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3624 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3625 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3626 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3627 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3628 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3629 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3630 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3631 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3639 get_parisc_section_type_name (unsigned int sh_type)
3643 case SHT_PARISC_EXT: return "PARISC_EXT";
3644 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3645 case SHT_PARISC_DOC: return "PARISC_DOC";
3646 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3647 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3648 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3649 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3657 get_ia64_section_type_name (unsigned int sh_type)
3659 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3660 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3661 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3665 case SHT_IA_64_EXT: return "IA_64_EXT";
3666 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3667 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3668 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3669 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3670 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3671 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3672 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3673 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3674 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3682 get_x86_64_section_type_name (unsigned int sh_type)
3686 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3694 get_aarch64_section_type_name (unsigned int sh_type)
3698 case SHT_AARCH64_ATTRIBUTES:
3699 return "AARCH64_ATTRIBUTES";
3707 get_arm_section_type_name (unsigned int sh_type)
3711 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3712 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3713 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3714 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3715 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3723 get_tic6x_section_type_name (unsigned int sh_type)
3727 case SHT_C6000_UNWIND:
3728 return "C6000_UNWIND";
3729 case SHT_C6000_PREEMPTMAP:
3730 return "C6000_PREEMPTMAP";
3731 case SHT_C6000_ATTRIBUTES:
3732 return "C6000_ATTRIBUTES";
3737 case SHT_TI_HANDLER:
3738 return "TI_HANDLER";
3739 case SHT_TI_INITINFO:
3740 return "TI_INITINFO";
3741 case SHT_TI_PHATTRS:
3742 return "TI_PHATTRS";
3750 get_msp430x_section_type_name (unsigned int sh_type)
3754 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3755 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3756 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3757 default: return NULL;
3762 get_section_type_name (unsigned int sh_type)
3764 static char buff[32];
3768 case SHT_NULL: return "NULL";
3769 case SHT_PROGBITS: return "PROGBITS";
3770 case SHT_SYMTAB: return "SYMTAB";
3771 case SHT_STRTAB: return "STRTAB";
3772 case SHT_RELA: return "RELA";
3773 case SHT_HASH: return "HASH";
3774 case SHT_DYNAMIC: return "DYNAMIC";
3775 case SHT_NOTE: return "NOTE";
3776 case SHT_NOBITS: return "NOBITS";
3777 case SHT_REL: return "REL";
3778 case SHT_SHLIB: return "SHLIB";
3779 case SHT_DYNSYM: return "DYNSYM";
3780 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3781 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3782 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3783 case SHT_GNU_HASH: return "GNU_HASH";
3784 case SHT_GROUP: return "GROUP";
3785 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3786 case SHT_GNU_verdef: return "VERDEF";
3787 case SHT_GNU_verneed: return "VERNEED";
3788 case SHT_GNU_versym: return "VERSYM";
3789 case 0x6ffffff0: return "VERSYM";
3790 case 0x6ffffffc: return "VERDEF";
3791 case 0x7ffffffd: return "AUXILIARY";
3792 case 0x7fffffff: return "FILTER";
3793 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3796 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3798 const char * result;
3800 switch (elf_header.e_machine)
3803 case EM_MIPS_RS3_LE:
3804 result = get_mips_section_type_name (sh_type);
3807 result = get_parisc_section_type_name (sh_type);
3810 result = get_ia64_section_type_name (sh_type);
3815 result = get_x86_64_section_type_name (sh_type);
3818 result = get_aarch64_section_type_name (sh_type);
3821 result = get_arm_section_type_name (sh_type);
3824 result = get_tic6x_section_type_name (sh_type);
3827 result = get_msp430x_section_type_name (sh_type);
3837 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3839 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3841 const char * result;
3843 switch (elf_header.e_machine)
3846 result = get_ia64_section_type_name (sh_type);
3856 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3858 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3859 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3861 /* This message is probably going to be displayed in a 15
3862 character wide field, so put the hex value first. */
3863 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3869 #define OPTION_DEBUG_DUMP 512
3870 #define OPTION_DYN_SYMS 513
3871 #define OPTION_DWARF_DEPTH 514
3872 #define OPTION_DWARF_START 515
3873 #define OPTION_DWARF_CHECK 516
3875 static struct option options[] =
3877 {"all", no_argument, 0, 'a'},
3878 {"file-header", no_argument, 0, 'h'},
3879 {"program-headers", no_argument, 0, 'l'},
3880 {"headers", no_argument, 0, 'e'},
3881 {"histogram", no_argument, 0, 'I'},
3882 {"segments", no_argument, 0, 'l'},
3883 {"sections", no_argument, 0, 'S'},
3884 {"section-headers", no_argument, 0, 'S'},
3885 {"section-groups", no_argument, 0, 'g'},
3886 {"section-details", no_argument, 0, 't'},
3887 {"full-section-name",no_argument, 0, 'N'},
3888 {"symbols", no_argument, 0, 's'},
3889 {"syms", no_argument, 0, 's'},
3890 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3891 {"relocs", no_argument, 0, 'r'},
3892 {"notes", no_argument, 0, 'n'},
3893 {"dynamic", no_argument, 0, 'd'},
3894 {"arch-specific", no_argument, 0, 'A'},
3895 {"version-info", no_argument, 0, 'V'},
3896 {"use-dynamic", no_argument, 0, 'D'},
3897 {"unwind", no_argument, 0, 'u'},
3898 {"archive-index", no_argument, 0, 'c'},
3899 {"hex-dump", required_argument, 0, 'x'},
3900 {"relocated-dump", required_argument, 0, 'R'},
3901 {"string-dump", required_argument, 0, 'p'},
3902 #ifdef SUPPORT_DISASSEMBLY
3903 {"instruction-dump", required_argument, 0, 'i'},
3905 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3907 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3908 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3909 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3911 {"version", no_argument, 0, 'v'},
3912 {"wide", no_argument, 0, 'W'},
3913 {"help", no_argument, 0, 'H'},
3914 {0, no_argument, 0, 0}
3918 usage (FILE * stream)
3920 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3921 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3922 fprintf (stream, _(" Options are:\n\
3923 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3924 -h --file-header Display the ELF file header\n\
3925 -l --program-headers Display the program headers\n\
3926 --segments An alias for --program-headers\n\
3927 -S --section-headers Display the sections' header\n\
3928 --sections An alias for --section-headers\n\
3929 -g --section-groups Display the section groups\n\
3930 -t --section-details Display the section details\n\
3931 -e --headers Equivalent to: -h -l -S\n\
3932 -s --syms Display the symbol table\n\
3933 --symbols An alias for --syms\n\
3934 --dyn-syms Display the dynamic symbol table\n\
3935 -n --notes Display the core notes (if present)\n\
3936 -r --relocs Display the relocations (if present)\n\
3937 -u --unwind Display the unwind info (if present)\n\
3938 -d --dynamic Display the dynamic section (if present)\n\
3939 -V --version-info Display the version sections (if present)\n\
3940 -A --arch-specific Display architecture specific information (if any)\n\
3941 -c --archive-index Display the symbol/file index in an archive\n\
3942 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3943 -x --hex-dump=<number|name>\n\
3944 Dump the contents of section <number|name> as bytes\n\
3945 -p --string-dump=<number|name>\n\
3946 Dump the contents of section <number|name> as strings\n\
3947 -R --relocated-dump=<number|name>\n\
3948 Dump the contents of section <number|name> as relocated bytes\n\
3949 -w[lLiaprmfFsoRt] or\n\
3950 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3951 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3952 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3954 Display the contents of DWARF2 debug sections\n"));
3955 fprintf (stream, _("\
3956 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3957 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3959 #ifdef SUPPORT_DISASSEMBLY
3960 fprintf (stream, _("\
3961 -i --instruction-dump=<number|name>\n\
3962 Disassemble the contents of section <number|name>\n"));
3964 fprintf (stream, _("\
3965 -I --histogram Display histogram of bucket list lengths\n\
3966 -W --wide Allow output width to exceed 80 characters\n\
3967 @<file> Read options from <file>\n\
3968 -H --help Display this information\n\
3969 -v --version Display the version number of readelf\n"));
3971 if (REPORT_BUGS_TO[0] && stream == stdout)
3972 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3974 exit (stream == stdout ? 0 : 1);
3977 /* Record the fact that the user wants the contents of section number
3978 SECTION to be displayed using the method(s) encoded as flags bits
3979 in TYPE. Note, TYPE can be zero if we are creating the array for
3983 request_dump_bynumber (unsigned int section, dump_type type)
3985 if (section >= num_dump_sects)
3987 dump_type * new_dump_sects;
3989 new_dump_sects = (dump_type *) calloc (section + 1,
3990 sizeof (* dump_sects));
3992 if (new_dump_sects == NULL)
3993 error (_("Out of memory allocating dump request table.\n"));
3996 /* Copy current flag settings. */
3997 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4001 dump_sects = new_dump_sects;
4002 num_dump_sects = section + 1;
4007 dump_sects[section] |= type;
4012 /* Request a dump by section name. */
4015 request_dump_byname (const char * section, dump_type type)
4017 struct dump_list_entry * new_request;
4019 new_request = (struct dump_list_entry *)
4020 malloc (sizeof (struct dump_list_entry));
4022 error (_("Out of memory allocating dump request table.\n"));
4024 new_request->name = strdup (section);
4025 if (!new_request->name)
4026 error (_("Out of memory allocating dump request table.\n"));
4028 new_request->type = type;
4030 new_request->next = dump_sects_byname;
4031 dump_sects_byname = new_request;
4035 request_dump (dump_type type)
4041 section = strtoul (optarg, & cp, 0);
4043 if (! *cp && section >= 0)
4044 request_dump_bynumber (section, type);
4046 request_dump_byname (optarg, type);
4051 parse_args (int argc, char ** argv)
4058 while ((c = getopt_long
4059 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4077 do_section_groups++;
4085 do_section_groups++;
4090 do_section_details++;
4134 request_dump (HEX_DUMP);
4137 request_dump (STRING_DUMP);
4140 request_dump (RELOC_DUMP);
4147 dwarf_select_sections_all ();
4152 dwarf_select_sections_by_letters (optarg);
4155 case OPTION_DEBUG_DUMP:
4162 dwarf_select_sections_by_names (optarg);
4165 case OPTION_DWARF_DEPTH:
4169 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4172 case OPTION_DWARF_START:
4176 dwarf_start_die = strtoul (optarg, & cp, 0);
4179 case OPTION_DWARF_CHECK:
4182 case OPTION_DYN_SYMS:
4185 #ifdef SUPPORT_DISASSEMBLY
4187 request_dump (DISASS_DUMP);
4191 print_version (program_name);
4200 /* xgettext:c-format */
4201 error (_("Invalid option '-%c'\n"), c);
4208 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4209 && !do_segments && !do_header && !do_dump && !do_version
4210 && !do_histogram && !do_debugging && !do_arch && !do_notes
4211 && !do_section_groups && !do_archive_index
4216 warn (_("Nothing to do.\n"));
4222 get_elf_class (unsigned int elf_class)
4224 static char buff[32];
4228 case ELFCLASSNONE: return _("none");
4229 case ELFCLASS32: return "ELF32";
4230 case ELFCLASS64: return "ELF64";
4232 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4238 get_data_encoding (unsigned int encoding)
4240 static char buff[32];
4244 case ELFDATANONE: return _("none");
4245 case ELFDATA2LSB: return _("2's complement, little endian");
4246 case ELFDATA2MSB: return _("2's complement, big endian");
4248 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4253 /* Decode the data held in 'elf_header'. */
4256 process_file_header (void)
4258 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4259 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4260 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4261 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4264 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4268 init_dwarf_regnames (elf_header.e_machine);
4274 printf (_("ELF Header:\n"));
4275 printf (_(" Magic: "));
4276 for (i = 0; i < EI_NIDENT; i++)
4277 printf ("%2.2x ", elf_header.e_ident[i]);
4279 printf (_(" Class: %s\n"),
4280 get_elf_class (elf_header.e_ident[EI_CLASS]));
4281 printf (_(" Data: %s\n"),
4282 get_data_encoding (elf_header.e_ident[EI_DATA]));
4283 printf (_(" Version: %d %s\n"),
4284 elf_header.e_ident[EI_VERSION],
4285 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4287 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4288 ? _("<unknown: %lx>")
4290 printf (_(" OS/ABI: %s\n"),
4291 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4292 printf (_(" ABI Version: %d\n"),
4293 elf_header.e_ident[EI_ABIVERSION]);
4294 printf (_(" Type: %s\n"),
4295 get_file_type (elf_header.e_type));
4296 printf (_(" Machine: %s\n"),
4297 get_machine_name (elf_header.e_machine));
4298 printf (_(" Version: 0x%lx\n"),
4299 (unsigned long) elf_header.e_version);
4301 printf (_(" Entry point address: "));
4302 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4303 printf (_("\n Start of program headers: "));
4304 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4305 printf (_(" (bytes into file)\n Start of section headers: "));
4306 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4307 printf (_(" (bytes into file)\n"));
4309 printf (_(" Flags: 0x%lx%s\n"),
4310 (unsigned long) elf_header.e_flags,
4311 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4312 printf (_(" Size of this header: %ld (bytes)\n"),
4313 (long) elf_header.e_ehsize);
4314 printf (_(" Size of program headers: %ld (bytes)\n"),
4315 (long) elf_header.e_phentsize);
4316 printf (_(" Number of program headers: %ld"),
4317 (long) elf_header.e_phnum);
4318 if (section_headers != NULL
4319 && elf_header.e_phnum == PN_XNUM
4320 && section_headers[0].sh_info != 0)
4321 printf (" (%ld)", (long) section_headers[0].sh_info);
4322 putc ('\n', stdout);
4323 printf (_(" Size of section headers: %ld (bytes)\n"),
4324 (long) elf_header.e_shentsize);
4325 printf (_(" Number of section headers: %ld"),
4326 (long) elf_header.e_shnum);
4327 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4328 printf (" (%ld)", (long) section_headers[0].sh_size);
4329 putc ('\n', stdout);
4330 printf (_(" Section header string table index: %ld"),
4331 (long) elf_header.e_shstrndx);
4332 if (section_headers != NULL
4333 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4334 printf (" (%u)", section_headers[0].sh_link);
4335 else if (elf_header.e_shstrndx != SHN_UNDEF
4336 && elf_header.e_shstrndx >= elf_header.e_shnum)
4337 printf (_(" <corrupt: out of range>"));
4338 putc ('\n', stdout);
4341 if (section_headers != NULL)
4343 if (elf_header.e_phnum == PN_XNUM
4344 && section_headers[0].sh_info != 0)
4345 elf_header.e_phnum = section_headers[0].sh_info;
4346 if (elf_header.e_shnum == SHN_UNDEF)
4347 elf_header.e_shnum = section_headers[0].sh_size;
4348 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4349 elf_header.e_shstrndx = section_headers[0].sh_link;
4350 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4351 elf_header.e_shstrndx = SHN_UNDEF;
4352 free (section_headers);
4353 section_headers = NULL;
4360 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4362 Elf32_External_Phdr * phdrs;
4363 Elf32_External_Phdr * external;
4364 Elf_Internal_Phdr * internal;
4366 unsigned int size = elf_header.e_phentsize;
4367 unsigned int num = elf_header.e_phnum;
4369 /* PR binutils/17531: Cope with unexpected section header sizes. */
4370 if (size == 0 || num == 0)
4372 if (size < sizeof * phdrs)
4374 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4377 if (size > sizeof * phdrs)
4378 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4380 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4381 size, num, _("program headers"));
4385 for (i = 0, internal = pheaders, external = phdrs;
4386 i < elf_header.e_phnum;
4387 i++, internal++, external++)
4389 internal->p_type = BYTE_GET (external->p_type);
4390 internal->p_offset = BYTE_GET (external->p_offset);
4391 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4392 internal->p_paddr = BYTE_GET (external->p_paddr);
4393 internal->p_filesz = BYTE_GET (external->p_filesz);
4394 internal->p_memsz = BYTE_GET (external->p_memsz);
4395 internal->p_flags = BYTE_GET (external->p_flags);
4396 internal->p_align = BYTE_GET (external->p_align);
4404 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4406 Elf64_External_Phdr * phdrs;
4407 Elf64_External_Phdr * external;
4408 Elf_Internal_Phdr * internal;
4410 unsigned int size = elf_header.e_phentsize;
4411 unsigned int num = elf_header.e_phnum;
4413 /* PR binutils/17531: Cope with unexpected section header sizes. */
4414 if (size == 0 || num == 0)
4416 if (size < sizeof * phdrs)
4418 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4421 if (size > sizeof * phdrs)
4422 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4424 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4425 size, num, _("program headers"));
4429 for (i = 0, internal = pheaders, external = phdrs;
4430 i < elf_header.e_phnum;
4431 i++, internal++, external++)
4433 internal->p_type = BYTE_GET (external->p_type);
4434 internal->p_flags = BYTE_GET (external->p_flags);
4435 internal->p_offset = BYTE_GET (external->p_offset);
4436 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4437 internal->p_paddr = BYTE_GET (external->p_paddr);
4438 internal->p_filesz = BYTE_GET (external->p_filesz);
4439 internal->p_memsz = BYTE_GET (external->p_memsz);
4440 internal->p_align = BYTE_GET (external->p_align);
4447 /* Returns 1 if the program headers were read into `program_headers'. */
4450 get_program_headers (FILE * file)
4452 Elf_Internal_Phdr * phdrs;
4454 /* Check cache of prior read. */
4455 if (program_headers != NULL)
4458 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4459 sizeof (Elf_Internal_Phdr));
4463 error (_("Out of memory reading %u program headers\n"),
4464 elf_header.e_phnum);
4469 ? get_32bit_program_headers (file, phdrs)
4470 : get_64bit_program_headers (file, phdrs))
4472 program_headers = phdrs;
4480 /* Returns 1 if the program headers were loaded. */
4483 process_program_headers (FILE * file)
4485 Elf_Internal_Phdr * segment;
4488 if (elf_header.e_phnum == 0)
4490 /* PR binutils/12467. */
4491 if (elf_header.e_phoff != 0)
4492 warn (_("possibly corrupt ELF header - it has a non-zero program"
4493 " header offset, but no program headers\n"));
4494 else if (do_segments)
4495 printf (_("\nThere are no program headers in this file.\n"));
4499 if (do_segments && !do_header)
4501 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4502 printf (_("Entry point "));
4503 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4504 printf (_("\nThere are %d program headers, starting at offset "),
4505 elf_header.e_phnum);
4506 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4510 if (! get_program_headers (file))
4515 if (elf_header.e_phnum > 1)
4516 printf (_("\nProgram Headers:\n"));
4518 printf (_("\nProgram Headers:\n"));
4522 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4525 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4529 (_(" Type Offset VirtAddr PhysAddr\n"));
4531 (_(" FileSiz MemSiz Flags Align\n"));
4538 for (i = 0, segment = program_headers;
4539 i < elf_header.e_phnum;
4544 printf (" %-14.14s ", get_segment_type (segment->p_type));
4548 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4549 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4550 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4551 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4552 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4554 (segment->p_flags & PF_R ? 'R' : ' '),
4555 (segment->p_flags & PF_W ? 'W' : ' '),
4556 (segment->p_flags & PF_X ? 'E' : ' '));
4557 printf ("%#lx", (unsigned long) segment->p_align);
4561 if ((unsigned long) segment->p_offset == segment->p_offset)
4562 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4565 print_vma (segment->p_offset, FULL_HEX);
4569 print_vma (segment->p_vaddr, FULL_HEX);
4571 print_vma (segment->p_paddr, FULL_HEX);
4574 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4575 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4578 print_vma (segment->p_filesz, FULL_HEX);
4582 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4583 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4586 print_vma (segment->p_memsz, FULL_HEX);
4590 (segment->p_flags & PF_R ? 'R' : ' '),
4591 (segment->p_flags & PF_W ? 'W' : ' '),
4592 (segment->p_flags & PF_X ? 'E' : ' '));
4594 if ((unsigned long) segment->p_align == segment->p_align)
4595 printf ("%#lx", (unsigned long) segment->p_align);
4598 print_vma (segment->p_align, PREFIX_HEX);
4603 print_vma (segment->p_offset, FULL_HEX);
4605 print_vma (segment->p_vaddr, FULL_HEX);
4607 print_vma (segment->p_paddr, FULL_HEX);
4609 print_vma (segment->p_filesz, FULL_HEX);
4611 print_vma (segment->p_memsz, FULL_HEX);
4613 (segment->p_flags & PF_R ? 'R' : ' '),
4614 (segment->p_flags & PF_W ? 'W' : ' '),
4615 (segment->p_flags & PF_X ? 'E' : ' '));
4616 print_vma (segment->p_align, HEX);
4621 putc ('\n', stdout);
4623 switch (segment->p_type)
4627 error (_("more than one dynamic segment\n"));
4629 /* By default, assume that the .dynamic section is the first
4630 section in the DYNAMIC segment. */
4631 dynamic_addr = segment->p_offset;
4632 dynamic_size = segment->p_filesz;
4633 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4634 if (dynamic_addr + dynamic_size >= current_file_size)
4636 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4637 dynamic_addr = dynamic_size = 0;
4640 /* Try to locate the .dynamic section. If there is
4641 a section header table, we can easily locate it. */
4642 if (section_headers != NULL)
4644 Elf_Internal_Shdr * sec;
4646 sec = find_section (".dynamic");
4647 if (sec == NULL || sec->sh_size == 0)
4649 /* A corresponding .dynamic section is expected, but on
4650 IA-64/OpenVMS it is OK for it to be missing. */
4651 if (!is_ia64_vms ())
4652 error (_("no .dynamic section in the dynamic segment\n"));
4656 if (sec->sh_type == SHT_NOBITS)
4662 dynamic_addr = sec->sh_offset;
4663 dynamic_size = sec->sh_size;
4665 if (dynamic_addr < segment->p_offset
4666 || dynamic_addr > segment->p_offset + segment->p_filesz)
4667 warn (_("the .dynamic section is not contained"
4668 " within the dynamic segment\n"));
4669 else if (dynamic_addr > segment->p_offset)
4670 warn (_("the .dynamic section is not the first section"
4671 " in the dynamic segment.\n"));
4676 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4678 error (_("Unable to find program interpreter name\n"));
4682 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4684 if (ret >= (int) sizeof (fmt) || ret < 0)
4685 error (_("Internal error: failed to create format string to display program interpreter\n"));
4687 program_interpreter[0] = 0;
4688 if (fscanf (file, fmt, program_interpreter) <= 0)
4689 error (_("Unable to read program interpreter name\n"));
4692 printf (_(" [Requesting program interpreter: %s]\n"),
4693 program_interpreter);
4699 if (do_segments && section_headers != NULL && string_table != NULL)
4701 printf (_("\n Section to Segment mapping:\n"));
4702 printf (_(" Segment Sections...\n"));
4704 for (i = 0; i < elf_header.e_phnum; i++)
4707 Elf_Internal_Shdr * section;
4709 segment = program_headers + i;
4710 section = section_headers + 1;
4712 printf (" %2.2d ", i);
4714 for (j = 1; j < elf_header.e_shnum; j++, section++)
4716 if (!ELF_TBSS_SPECIAL (section, segment)
4717 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4718 printf ("%s ", printable_section_name (section));
4729 /* Find the file offset corresponding to VMA by using the program headers. */
4732 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4734 Elf_Internal_Phdr * seg;
4736 if (! get_program_headers (file))
4738 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4742 for (seg = program_headers;
4743 seg < program_headers + elf_header.e_phnum;
4746 if (seg->p_type != PT_LOAD)
4749 if (vma >= (seg->p_vaddr & -seg->p_align)
4750 && vma + size <= seg->p_vaddr + seg->p_filesz)
4751 return vma - seg->p_vaddr + seg->p_offset;
4754 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4755 (unsigned long) vma);
4760 /* Allocate memory and load the sections headers into the global pointer
4761 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4762 generate any error messages if the load fails. */
4765 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4767 Elf32_External_Shdr * shdrs;
4768 Elf_Internal_Shdr * internal;
4770 unsigned int size = elf_header.e_shentsize;
4771 unsigned int num = probe ? 1 : elf_header.e_shnum;
4773 /* PR binutils/17531: Cope with unexpected section header sizes. */
4774 if (size == 0 || num == 0)
4776 if (size < sizeof * shdrs)
4779 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4782 if (!probe && size > sizeof * shdrs)
4783 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4785 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4787 probe ? NULL : _("section headers"));
4791 if (section_headers != NULL)
4792 free (section_headers);
4793 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4794 sizeof (Elf_Internal_Shdr));
4795 if (section_headers == NULL)
4798 error (_("Out of memory reading %u section headers\n"), num);
4802 for (i = 0, internal = section_headers;
4806 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4807 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4808 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4809 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4810 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4811 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4812 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4813 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4814 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4815 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4823 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4825 Elf64_External_Shdr * shdrs;
4826 Elf_Internal_Shdr * internal;
4828 unsigned int size = elf_header.e_shentsize;
4829 unsigned int num = probe ? 1 : elf_header.e_shnum;
4831 /* PR binutils/17531: Cope with unexpected section header sizes. */
4832 if (size == 0 || num == 0)
4834 if (size < sizeof * shdrs)
4837 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4840 if (! probe && size > sizeof * shdrs)
4841 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4843 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4845 probe ? NULL : _("section headers"));
4849 if (section_headers != NULL)
4850 free (section_headers);
4851 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4852 sizeof (Elf_Internal_Shdr));
4853 if (section_headers == NULL)
4856 error (_("Out of memory reading %u section headers\n"), num);
4860 for (i = 0, internal = section_headers;
4864 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4865 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4866 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4867 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4868 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4869 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4870 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4871 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4872 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4873 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4880 static Elf_Internal_Sym *
4881 get_32bit_elf_symbols (FILE * file,
4882 Elf_Internal_Shdr * section,
4883 unsigned long * num_syms_return)
4885 unsigned long number = 0;
4886 Elf32_External_Sym * esyms = NULL;
4887 Elf_External_Sym_Shndx * shndx = NULL;
4888 Elf_Internal_Sym * isyms = NULL;
4889 Elf_Internal_Sym * psym;
4892 if (section->sh_size == 0)
4894 if (num_syms_return != NULL)
4895 * num_syms_return = 0;
4899 /* Run some sanity checks first. */
4900 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4902 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4903 printable_section_name (section), (unsigned long) section->sh_entsize);
4907 if (section->sh_size > current_file_size)
4909 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4910 printable_section_name (section), (unsigned long) section->sh_size);
4914 number = section->sh_size / section->sh_entsize;
4916 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4918 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4919 (unsigned long) section->sh_size,
4920 printable_section_name (section),
4921 (unsigned long) section->sh_entsize);
4925 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4926 section->sh_size, _("symbols"));
4931 if (symtab_shndx_hdr != NULL
4932 && (symtab_shndx_hdr->sh_link
4933 == (unsigned long) (section - section_headers)))
4935 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4936 symtab_shndx_hdr->sh_offset,
4937 1, symtab_shndx_hdr->sh_size,
4938 _("symbol table section indicies"));
4941 /* PR17531: file: heap-buffer-overflow */
4942 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4944 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4945 printable_section_name (symtab_shndx_hdr),
4946 (unsigned long) symtab_shndx_hdr->sh_size,
4947 (unsigned long) section->sh_size);
4952 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4956 error (_("Out of memory reading %lu symbols\n"),
4957 (unsigned long) number);
4961 for (j = 0, psym = isyms; j < number; j++, psym++)
4963 psym->st_name = BYTE_GET (esyms[j].st_name);
4964 psym->st_value = BYTE_GET (esyms[j].st_value);
4965 psym->st_size = BYTE_GET (esyms[j].st_size);
4966 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4967 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4969 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4970 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4971 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4972 psym->st_info = BYTE_GET (esyms[j].st_info);
4973 psym->st_other = BYTE_GET (esyms[j].st_other);
4982 if (num_syms_return != NULL)
4983 * num_syms_return = isyms == NULL ? 0 : number;
4988 static Elf_Internal_Sym *
4989 get_64bit_elf_symbols (FILE * file,
4990 Elf_Internal_Shdr * section,
4991 unsigned long * num_syms_return)
4993 unsigned long number = 0;
4994 Elf64_External_Sym * esyms = NULL;
4995 Elf_External_Sym_Shndx * shndx = NULL;
4996 Elf_Internal_Sym * isyms = NULL;
4997 Elf_Internal_Sym * psym;
5000 if (section->sh_size == 0)
5002 if (num_syms_return != NULL)
5003 * num_syms_return = 0;
5007 /* Run some sanity checks first. */
5008 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5010 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5011 printable_section_name (section),
5012 (unsigned long) section->sh_entsize);
5016 if (section->sh_size > current_file_size)
5018 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5019 printable_section_name (section),
5020 (unsigned long) section->sh_size);
5024 number = section->sh_size / section->sh_entsize;
5026 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5028 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5029 (unsigned long) section->sh_size,
5030 printable_section_name (section),
5031 (unsigned long) section->sh_entsize);
5035 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5036 section->sh_size, _("symbols"));
5040 if (symtab_shndx_hdr != NULL
5041 && (symtab_shndx_hdr->sh_link
5042 == (unsigned long) (section - section_headers)))
5044 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5045 symtab_shndx_hdr->sh_offset,
5046 1, symtab_shndx_hdr->sh_size,
5047 _("symbol table section indicies"));
5050 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5052 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5053 printable_section_name (symtab_shndx_hdr),
5054 (unsigned long) symtab_shndx_hdr->sh_size,
5055 (unsigned long) section->sh_size);
5060 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5064 error (_("Out of memory reading %lu symbols\n"),
5065 (unsigned long) number);
5069 for (j = 0, psym = isyms; j < number; j++, psym++)
5071 psym->st_name = BYTE_GET (esyms[j].st_name);
5072 psym->st_info = BYTE_GET (esyms[j].st_info);
5073 psym->st_other = BYTE_GET (esyms[j].st_other);
5074 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5076 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5078 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5079 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5080 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5082 psym->st_value = BYTE_GET (esyms[j].st_value);
5083 psym->st_size = BYTE_GET (esyms[j].st_size);
5092 if (num_syms_return != NULL)
5093 * num_syms_return = isyms == NULL ? 0 : number;
5099 get_elf_section_flags (bfd_vma sh_flags)
5101 static char buff[1024];
5103 int field_size = is_32bit_elf ? 8 : 16;
5105 int size = sizeof (buff) - (field_size + 4 + 1);
5106 bfd_vma os_flags = 0;
5107 bfd_vma proc_flags = 0;
5108 bfd_vma unknown_flags = 0;
5116 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5117 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5118 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5119 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5120 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5121 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5122 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5123 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5124 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5125 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5126 /* IA-64 specific. */
5127 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5128 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5129 /* IA-64 OpenVMS specific. */
5130 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5131 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5132 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5133 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5134 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5135 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5137 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5138 /* SPARC specific. */
5139 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5142 if (do_section_details)
5144 sprintf (buff, "[%*.*lx]: ",
5145 field_size, field_size, (unsigned long) sh_flags);
5146 p += field_size + 4;
5153 flag = sh_flags & - sh_flags;
5156 if (do_section_details)
5160 case SHF_WRITE: sindex = 0; break;
5161 case SHF_ALLOC: sindex = 1; break;
5162 case SHF_EXECINSTR: sindex = 2; break;
5163 case SHF_MERGE: sindex = 3; break;
5164 case SHF_STRINGS: sindex = 4; break;
5165 case SHF_INFO_LINK: sindex = 5; break;
5166 case SHF_LINK_ORDER: sindex = 6; break;
5167 case SHF_OS_NONCONFORMING: sindex = 7; break;
5168 case SHF_GROUP: sindex = 8; break;
5169 case SHF_TLS: sindex = 9; break;
5170 case SHF_EXCLUDE: sindex = 18; break;
5174 switch (elf_header.e_machine)
5177 if (flag == SHF_IA_64_SHORT)
5179 else if (flag == SHF_IA_64_NORECOV)
5182 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5185 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5186 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5187 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5188 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5189 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5190 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5201 case EM_OLD_SPARCV9:
5202 case EM_SPARC32PLUS:
5205 if (flag == SHF_ORDERED)
5215 if (p != buff + field_size + 4)
5217 if (size < (10 + 2))
5219 warn (_("Internal error: not enough buffer room for section flag info"));
5220 return _("<unknown>");
5227 size -= flags [sindex].len;
5228 p = stpcpy (p, flags [sindex].str);
5230 else if (flag & SHF_MASKOS)
5232 else if (flag & SHF_MASKPROC)
5235 unknown_flags |= flag;
5241 case SHF_WRITE: *p = 'W'; break;
5242 case SHF_ALLOC: *p = 'A'; break;
5243 case SHF_EXECINSTR: *p = 'X'; break;
5244 case SHF_MERGE: *p = 'M'; break;
5245 case SHF_STRINGS: *p = 'S'; break;
5246 case SHF_INFO_LINK: *p = 'I'; break;
5247 case SHF_LINK_ORDER: *p = 'L'; break;
5248 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5249 case SHF_GROUP: *p = 'G'; break;
5250 case SHF_TLS: *p = 'T'; break;
5251 case SHF_EXCLUDE: *p = 'E'; break;
5254 if ((elf_header.e_machine == EM_X86_64
5255 || elf_header.e_machine == EM_L1OM
5256 || elf_header.e_machine == EM_K1OM)
5257 && flag == SHF_X86_64_LARGE)
5259 else if (flag & SHF_MASKOS)
5262 sh_flags &= ~ SHF_MASKOS;
5264 else if (flag & SHF_MASKPROC)
5267 sh_flags &= ~ SHF_MASKPROC;
5277 if (do_section_details)
5281 size -= 5 + field_size;
5282 if (p != buff + field_size + 4)
5286 warn (_("Internal error: not enough buffer room for section flag info"));
5287 return _("<unknown>");
5293 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5294 (unsigned long) os_flags);
5295 p += 5 + field_size;
5299 size -= 7 + field_size;
5300 if (p != buff + field_size + 4)
5304 warn (_("Internal error: not enough buffer room for section flag info"));
5305 return _("<unknown>");
5311 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5312 (unsigned long) proc_flags);
5313 p += 7 + field_size;
5317 size -= 10 + field_size;
5318 if (p != buff + field_size + 4)
5322 warn (_("Internal error: not enough buffer room for section flag info"));
5323 return _("<unknown>");
5329 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5330 (unsigned long) unknown_flags);
5331 p += 10 + field_size;
5340 process_section_headers (FILE * file)
5342 Elf_Internal_Shdr * section;
5345 section_headers = NULL;
5347 if (elf_header.e_shnum == 0)
5349 /* PR binutils/12467. */
5350 if (elf_header.e_shoff != 0)
5351 warn (_("possibly corrupt ELF file header - it has a non-zero"
5352 " section header offset, but no section headers\n"));
5353 else if (do_sections)
5354 printf (_("\nThere are no sections in this file.\n"));
5359 if (do_sections && !do_header)
5360 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5361 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5365 if (! get_32bit_section_headers (file, FALSE))
5368 else if (! get_64bit_section_headers (file, FALSE))
5371 /* Read in the string table, so that we have names to display. */
5372 if (elf_header.e_shstrndx != SHN_UNDEF
5373 && elf_header.e_shstrndx < elf_header.e_shnum)
5375 section = section_headers + elf_header.e_shstrndx;
5377 if (section->sh_size != 0)
5379 string_table = (char *) get_data (NULL, file, section->sh_offset,
5380 1, section->sh_size,
5383 string_table_length = string_table != NULL ? section->sh_size : 0;
5387 /* Scan the sections for the dynamic symbol table
5388 and dynamic string table and debug sections. */
5389 dynamic_symbols = NULL;
5390 dynamic_strings = NULL;
5391 dynamic_syminfo = NULL;
5392 symtab_shndx_hdr = NULL;
5394 eh_addr_size = is_32bit_elf ? 4 : 8;
5395 switch (elf_header.e_machine)
5398 case EM_MIPS_RS3_LE:
5399 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5400 FDE addresses. However, the ABI also has a semi-official ILP32
5401 variant for which the normal FDE address size rules apply.
5403 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5404 section, where XX is the size of longs in bits. Unfortunately,
5405 earlier compilers provided no way of distinguishing ILP32 objects
5406 from LP64 objects, so if there's any doubt, we should assume that
5407 the official LP64 form is being used. */
5408 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5409 && find_section (".gcc_compiled_long32") == NULL)
5415 switch (elf_header.e_flags & EF_H8_MACH)
5417 case E_H8_MACH_H8300:
5418 case E_H8_MACH_H8300HN:
5419 case E_H8_MACH_H8300SN:
5420 case E_H8_MACH_H8300SXN:
5423 case E_H8_MACH_H8300H:
5424 case E_H8_MACH_H8300S:
5425 case E_H8_MACH_H8300SX:
5433 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5435 case EF_M32C_CPU_M16C:
5442 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5445 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5446 if (section->sh_entsize != expected_entsize) \
5449 sprintf_vma (buf, section->sh_entsize); \
5450 /* Note: coded this way so that there is a single string for \
5452 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5453 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5454 (unsigned) expected_entsize); \
5455 section->sh_entsize = expected_entsize; \
5460 #define CHECK_ENTSIZE(section, i, type) \
5461 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5462 sizeof (Elf64_External_##type))
5464 for (i = 0, section = section_headers;
5465 i < elf_header.e_shnum;
5468 char * name = SECTION_NAME (section);
5470 if (section->sh_type == SHT_DYNSYM)
5472 if (dynamic_symbols != NULL)
5474 error (_("File contains multiple dynamic symbol tables\n"));
5478 CHECK_ENTSIZE (section, i, Sym);
5479 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5481 else if (section->sh_type == SHT_STRTAB
5482 && streq (name, ".dynstr"))
5484 if (dynamic_strings != NULL)
5486 error (_("File contains multiple dynamic string tables\n"));
5490 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5491 1, section->sh_size,
5492 _("dynamic strings"));
5493 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5495 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5497 if (symtab_shndx_hdr != NULL)
5499 error (_("File contains multiple symtab shndx tables\n"));
5502 symtab_shndx_hdr = section;
5504 else if (section->sh_type == SHT_SYMTAB)
5505 CHECK_ENTSIZE (section, i, Sym);
5506 else if (section->sh_type == SHT_GROUP)
5507 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5508 else if (section->sh_type == SHT_REL)
5509 CHECK_ENTSIZE (section, i, Rel);
5510 else if (section->sh_type == SHT_RELA)
5511 CHECK_ENTSIZE (section, i, Rela);
5512 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5513 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5514 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5515 || do_debug_str || do_debug_loc || do_debug_ranges
5516 || do_debug_addr || do_debug_cu_index)
5517 && (const_strneq (name, ".debug_")
5518 || const_strneq (name, ".zdebug_")))
5521 name += sizeof (".zdebug_") - 1;
5523 name += sizeof (".debug_") - 1;
5526 || (do_debug_info && const_strneq (name, "info"))
5527 || (do_debug_info && const_strneq (name, "types"))
5528 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5529 || (do_debug_lines && strcmp (name, "line") == 0)
5530 || (do_debug_lines && const_strneq (name, "line."))
5531 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5532 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5533 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5534 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5535 || (do_debug_aranges && const_strneq (name, "aranges"))
5536 || (do_debug_ranges && const_strneq (name, "ranges"))
5537 || (do_debug_frames && const_strneq (name, "frame"))
5538 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5539 || (do_debug_macinfo && const_strneq (name, "macro"))
5540 || (do_debug_str && const_strneq (name, "str"))
5541 || (do_debug_loc && const_strneq (name, "loc"))
5542 || (do_debug_addr && const_strneq (name, "addr"))
5543 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5544 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5546 request_dump_bynumber (i, DEBUG_DUMP);
5548 /* Linkonce section to be combined with .debug_info at link time. */
5549 else if ((do_debugging || do_debug_info)
5550 && const_strneq (name, ".gnu.linkonce.wi."))
5551 request_dump_bynumber (i, DEBUG_DUMP);
5552 else if (do_debug_frames && streq (name, ".eh_frame"))
5553 request_dump_bynumber (i, DEBUG_DUMP);
5554 else if (do_gdb_index && streq (name, ".gdb_index"))
5555 request_dump_bynumber (i, DEBUG_DUMP);
5556 /* Trace sections for Itanium VMS. */
5557 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5558 || do_trace_aranges)
5559 && const_strneq (name, ".trace_"))
5561 name += sizeof (".trace_") - 1;
5564 || (do_trace_info && streq (name, "info"))
5565 || (do_trace_abbrevs && streq (name, "abbrev"))
5566 || (do_trace_aranges && streq (name, "aranges"))
5568 request_dump_bynumber (i, DEBUG_DUMP);
5575 if (elf_header.e_shnum > 1)
5576 printf (_("\nSection Headers:\n"));
5578 printf (_("\nSection Header:\n"));
5582 if (do_section_details)
5584 printf (_(" [Nr] Name\n"));
5585 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5589 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5593 if (do_section_details)
5595 printf (_(" [Nr] Name\n"));
5596 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5600 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5604 if (do_section_details)
5606 printf (_(" [Nr] Name\n"));
5607 printf (_(" Type Address Offset Link\n"));
5608 printf (_(" Size EntSize Info Align\n"));
5612 printf (_(" [Nr] Name Type Address Offset\n"));
5613 printf (_(" Size EntSize Flags Link Info Align\n"));
5617 if (do_section_details)
5618 printf (_(" Flags\n"));
5620 for (i = 0, section = section_headers;
5621 i < elf_header.e_shnum;
5624 printf (" [%2u] ", i);
5625 if (do_section_details)
5626 printf ("%s\n ", printable_section_name (section));
5628 print_symbol (-17, SECTION_NAME (section));
5630 printf (do_wide ? " %-15s " : " %-15.15s ",
5631 get_section_type_name (section->sh_type));
5635 const char * link_too_big = NULL;
5637 print_vma (section->sh_addr, LONG_HEX);
5639 printf ( " %6.6lx %6.6lx %2.2lx",
5640 (unsigned long) section->sh_offset,
5641 (unsigned long) section->sh_size,
5642 (unsigned long) section->sh_entsize);
5644 if (do_section_details)
5645 fputs (" ", stdout);
5647 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5649 if (section->sh_link >= elf_header.e_shnum)
5652 /* The sh_link value is out of range. Normally this indicates
5653 an error but it can have special values in Solaris binaries. */
5654 switch (elf_header.e_machine)
5661 case EM_OLD_SPARCV9:
5662 case EM_SPARC32PLUS:
5665 if (section->sh_link == (SHN_BEFORE & 0xffff))
5666 link_too_big = "BEFORE";
5667 else if (section->sh_link == (SHN_AFTER & 0xffff))
5668 link_too_big = "AFTER";
5675 if (do_section_details)
5677 if (link_too_big != NULL && * link_too_big)
5678 printf ("<%s> ", link_too_big);
5680 printf ("%2u ", section->sh_link);
5681 printf ("%3u %2lu\n", section->sh_info,
5682 (unsigned long) section->sh_addralign);
5685 printf ("%2u %3u %2lu\n",
5688 (unsigned long) section->sh_addralign);
5690 if (link_too_big && ! * link_too_big)
5691 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5692 i, section->sh_link);
5696 print_vma (section->sh_addr, LONG_HEX);
5698 if ((long) section->sh_offset == section->sh_offset)
5699 printf (" %6.6lx", (unsigned long) section->sh_offset);
5703 print_vma (section->sh_offset, LONG_HEX);
5706 if ((unsigned long) section->sh_size == section->sh_size)
5707 printf (" %6.6lx", (unsigned long) section->sh_size);
5711 print_vma (section->sh_size, LONG_HEX);
5714 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5715 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5719 print_vma (section->sh_entsize, LONG_HEX);
5722 if (do_section_details)
5723 fputs (" ", stdout);
5725 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5727 printf ("%2u %3u ", section->sh_link, section->sh_info);
5729 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5730 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5733 print_vma (section->sh_addralign, DEC);
5737 else if (do_section_details)
5739 printf (" %-15.15s ",
5740 get_section_type_name (section->sh_type));
5741 print_vma (section->sh_addr, LONG_HEX);
5742 if ((long) section->sh_offset == section->sh_offset)
5743 printf (" %16.16lx", (unsigned long) section->sh_offset);
5747 print_vma (section->sh_offset, LONG_HEX);
5749 printf (" %u\n ", section->sh_link);
5750 print_vma (section->sh_size, LONG_HEX);
5752 print_vma (section->sh_entsize, LONG_HEX);
5754 printf (" %-16u %lu\n",
5756 (unsigned long) section->sh_addralign);
5761 print_vma (section->sh_addr, LONG_HEX);
5762 if ((long) section->sh_offset == section->sh_offset)
5763 printf (" %8.8lx", (unsigned long) section->sh_offset);
5767 print_vma (section->sh_offset, LONG_HEX);
5770 print_vma (section->sh_size, LONG_HEX);
5772 print_vma (section->sh_entsize, LONG_HEX);
5774 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5776 printf (" %2u %3u %lu\n",
5779 (unsigned long) section->sh_addralign);
5782 if (do_section_details)
5783 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5786 if (!do_section_details)
5788 if (elf_header.e_machine == EM_X86_64
5789 || elf_header.e_machine == EM_L1OM
5790 || elf_header.e_machine == EM_K1OM)
5791 printf (_("Key to Flags:\n\
5792 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5793 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5794 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5796 printf (_("Key to Flags:\n\
5797 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5798 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5799 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5806 get_group_flags (unsigned int flags)
5808 static char buff[32];
5818 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5825 process_section_groups (FILE * file)
5827 Elf_Internal_Shdr * section;
5829 struct group * group;
5830 Elf_Internal_Shdr * symtab_sec;
5831 Elf_Internal_Shdr * strtab_sec;
5832 Elf_Internal_Sym * symtab;
5833 unsigned long num_syms;
5837 /* Don't process section groups unless needed. */
5838 if (!do_unwind && !do_section_groups)
5841 if (elf_header.e_shnum == 0)
5843 if (do_section_groups)
5844 printf (_("\nThere are no sections to group in this file.\n"));
5849 if (section_headers == NULL)
5851 error (_("Section headers are not available!\n"));
5852 /* PR 13622: This can happen with a corrupt ELF header. */
5856 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5857 sizeof (struct group *));
5859 if (section_headers_groups == NULL)
5861 error (_("Out of memory reading %u section group headers\n"),
5862 elf_header.e_shnum);
5866 /* Scan the sections for the group section. */
5868 for (i = 0, section = section_headers;
5869 i < elf_header.e_shnum;
5871 if (section->sh_type == SHT_GROUP)
5874 if (group_count == 0)
5876 if (do_section_groups)
5877 printf (_("\nThere are no section groups in this file.\n"));
5882 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5884 if (section_groups == NULL)
5886 error (_("Out of memory reading %lu groups\n"),
5887 (unsigned long) group_count);
5897 for (i = 0, section = section_headers, group = section_groups;
5898 i < elf_header.e_shnum;
5901 if (section->sh_type == SHT_GROUP)
5903 const char * name = printable_section_name (section);
5904 const char * group_name;
5905 unsigned char * start;
5906 unsigned char * indices;
5907 unsigned int entry, j, size;
5908 Elf_Internal_Shdr * sec;
5909 Elf_Internal_Sym * sym;
5911 /* Get the symbol table. */
5912 if (section->sh_link >= elf_header.e_shnum
5913 || ((sec = section_headers + section->sh_link)->sh_type
5916 error (_("Bad sh_link in group section `%s'\n"), name);
5920 if (symtab_sec != sec)
5925 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5930 error (_("Corrupt header in group section `%s'\n"), name);
5934 if (section->sh_info >= num_syms)
5936 error (_("Bad sh_info in group section `%s'\n"), name);
5940 sym = symtab + section->sh_info;
5942 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5944 if (sym->st_shndx == 0
5945 || sym->st_shndx >= elf_header.e_shnum)
5947 error (_("Bad sh_info in group section `%s'\n"), name);
5951 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5960 /* Get the string table. */
5961 if (symtab_sec->sh_link >= elf_header.e_shnum)
5970 != (sec = section_headers + symtab_sec->sh_link))
5976 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5977 1, strtab_sec->sh_size,
5979 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5981 group_name = sym->st_name < strtab_size
5982 ? strtab + sym->st_name : _("<corrupt>");
5985 /* PR 17531: file: loop. */
5986 if (section->sh_entsize > section->sh_size)
5988 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5989 printable_section_name (section),
5990 (unsigned long) section->sh_entsize,
5991 (unsigned long) section->sh_size);
5995 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5996 1, section->sh_size,
6002 size = (section->sh_size / section->sh_entsize) - 1;
6003 entry = byte_get (indices, 4);
6006 if (do_section_groups)
6008 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6009 get_group_flags (entry), i, name, group_name, size);
6011 printf (_(" [Index] Name\n"));
6014 group->group_index = i;
6016 for (j = 0; j < size; j++)
6018 struct group_list * g;
6020 entry = byte_get (indices, 4);
6023 if (entry >= elf_header.e_shnum)
6025 static unsigned num_group_errors = 0;
6027 if (num_group_errors ++ < 10)
6029 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6030 entry, i, elf_header.e_shnum - 1);
6031 if (num_group_errors == 10)
6032 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6037 if (section_headers_groups [entry] != NULL)
6041 static unsigned num_errs = 0;
6043 if (num_errs ++ < 10)
6045 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6047 section_headers_groups [entry]->group_index);
6049 warn (_("Further error messages about already contained group sections suppressed\n"));
6055 /* Intel C/C++ compiler may put section 0 in a
6056 section group. We just warn it the first time
6057 and ignore it afterwards. */
6058 static int warned = 0;
6061 error (_("section 0 in group section [%5u]\n"),
6062 section_headers_groups [entry]->group_index);
6068 section_headers_groups [entry] = group;
6070 if (do_section_groups)
6072 sec = section_headers + entry;
6073 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6076 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6077 g->section_index = entry;
6078 g->next = group->root;
6096 /* Data used to display dynamic fixups. */
6098 struct ia64_vms_dynfixup
6100 bfd_vma needed_ident; /* Library ident number. */
6101 bfd_vma needed; /* Index in the dstrtab of the library name. */
6102 bfd_vma fixup_needed; /* Index of the library. */
6103 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6104 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6107 /* Data used to display dynamic relocations. */
6109 struct ia64_vms_dynimgrela
6111 bfd_vma img_rela_cnt; /* Number of relocations. */
6112 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6115 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6119 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6120 const char *strtab, unsigned int strtab_sz)
6122 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6124 const char *lib_name;
6126 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6127 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6128 _("dynamic section image fixups"));
6132 if (fixup->needed < strtab_sz)
6133 lib_name = strtab + fixup->needed;
6136 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6137 (unsigned long) fixup->needed);
6140 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6141 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6143 (_("Seg Offset Type SymVec DataType\n"));
6145 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6150 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6151 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6152 type = BYTE_GET (imfs [i].type);
6153 rtype = elf_ia64_reloc_type (type);
6155 printf (" 0x%08x ", type);
6157 printf (" %-32s ", rtype);
6158 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6159 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6165 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6168 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6170 Elf64_External_VMS_IMAGE_RELA *imrs;
6173 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6174 1, imgrela->img_rela_cnt * sizeof (*imrs),
6175 _("dynamic section image relocations"));
6179 printf (_("\nImage relocs\n"));
6181 (_("Seg Offset Type Addend Seg Sym Off\n"));
6183 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6188 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6189 printf ("%08" BFD_VMA_FMT "x ",
6190 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6191 type = BYTE_GET (imrs [i].type);
6192 rtype = elf_ia64_reloc_type (type);
6194 printf ("0x%08x ", type);
6196 printf ("%-31s ", rtype);
6197 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6198 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6199 printf ("%08" BFD_VMA_FMT "x\n",
6200 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6206 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6209 process_ia64_vms_dynamic_relocs (FILE *file)
6211 struct ia64_vms_dynfixup fixup;
6212 struct ia64_vms_dynimgrela imgrela;
6213 Elf_Internal_Dyn *entry;
6215 bfd_vma strtab_off = 0;
6216 bfd_vma strtab_sz = 0;
6217 char *strtab = NULL;
6219 memset (&fixup, 0, sizeof (fixup));
6220 memset (&imgrela, 0, sizeof (imgrela));
6222 /* Note: the order of the entries is specified by the OpenVMS specs. */
6223 for (entry = dynamic_section;
6224 entry < dynamic_section + dynamic_nent;
6227 switch (entry->d_tag)
6229 case DT_IA_64_VMS_STRTAB_OFFSET:
6230 strtab_off = entry->d_un.d_val;
6233 strtab_sz = entry->d_un.d_val;
6235 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6236 1, strtab_sz, _("dynamic string section"));
6239 case DT_IA_64_VMS_NEEDED_IDENT:
6240 fixup.needed_ident = entry->d_un.d_val;
6243 fixup.needed = entry->d_un.d_val;
6245 case DT_IA_64_VMS_FIXUP_NEEDED:
6246 fixup.fixup_needed = entry->d_un.d_val;
6248 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6249 fixup.fixup_rela_cnt = entry->d_un.d_val;
6251 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6252 fixup.fixup_rela_off = entry->d_un.d_val;
6254 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6257 case DT_IA_64_VMS_IMG_RELA_CNT:
6258 imgrela.img_rela_cnt = entry->d_un.d_val;
6260 case DT_IA_64_VMS_IMG_RELA_OFF:
6261 imgrela.img_rela_off = entry->d_un.d_val;
6263 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6283 } dynamic_relocations [] =
6285 { "REL", DT_REL, DT_RELSZ, FALSE },
6286 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6287 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6290 /* Process the reloc section. */
6293 process_relocs (FILE * file)
6295 unsigned long rel_size;
6296 unsigned long rel_offset;
6302 if (do_using_dynamic)
6306 int has_dynamic_reloc;
6309 has_dynamic_reloc = 0;
6311 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6313 is_rela = dynamic_relocations [i].rela;
6314 name = dynamic_relocations [i].name;
6315 rel_size = dynamic_info [dynamic_relocations [i].size];
6316 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6318 has_dynamic_reloc |= rel_size;
6320 if (is_rela == UNKNOWN)
6322 if (dynamic_relocations [i].reloc == DT_JMPREL)
6323 switch (dynamic_info[DT_PLTREL])
6337 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6338 name, rel_offset, rel_size);
6340 dump_relocations (file,
6341 offset_from_vma (file, rel_offset, rel_size),
6343 dynamic_symbols, num_dynamic_syms,
6344 dynamic_strings, dynamic_strings_length,
6350 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6352 if (! has_dynamic_reloc)
6353 printf (_("\nThere are no dynamic relocations in this file.\n"));
6357 Elf_Internal_Shdr * section;
6361 for (i = 0, section = section_headers;
6362 i < elf_header.e_shnum;
6365 if ( section->sh_type != SHT_RELA
6366 && section->sh_type != SHT_REL)
6369 rel_offset = section->sh_offset;
6370 rel_size = section->sh_size;
6374 Elf_Internal_Shdr * strsec;
6377 printf (_("\nRelocation section "));
6379 if (string_table == NULL)
6380 printf ("%d", section->sh_name);
6382 printf ("'%s'", printable_section_name (section));
6384 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6385 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6387 is_rela = section->sh_type == SHT_RELA;
6389 if (section->sh_link != 0
6390 && section->sh_link < elf_header.e_shnum)
6392 Elf_Internal_Shdr * symsec;
6393 Elf_Internal_Sym * symtab;
6394 unsigned long nsyms;
6395 unsigned long strtablen = 0;
6396 char * strtab = NULL;
6398 symsec = section_headers + section->sh_link;
6399 if (symsec->sh_type != SHT_SYMTAB
6400 && symsec->sh_type != SHT_DYNSYM)
6403 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6408 if (symsec->sh_link != 0
6409 && symsec->sh_link < elf_header.e_shnum)
6411 strsec = section_headers + symsec->sh_link;
6413 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6416 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6419 dump_relocations (file, rel_offset, rel_size,
6420 symtab, nsyms, strtab, strtablen,
6422 symsec->sh_type == SHT_DYNSYM);
6428 dump_relocations (file, rel_offset, rel_size,
6429 NULL, 0, NULL, 0, is_rela, 0);
6436 printf (_("\nThere are no relocations in this file.\n"));
6442 /* An absolute address consists of a section and an offset. If the
6443 section is NULL, the offset itself is the address, otherwise, the
6444 address equals to LOAD_ADDRESS(section) + offset. */
6448 unsigned short section;
6452 #define ABSADDR(a) \
6454 ? section_headers [(a).section].sh_addr + (a).offset \
6457 /* Find the nearest symbol at or below ADDR. Returns the symbol
6458 name, if found, and the offset from the symbol to ADDR. */
6461 find_symbol_for_address (Elf_Internal_Sym * symtab,
6462 unsigned long nsyms,
6463 const char * strtab,
6464 unsigned long strtab_size,
6465 struct absaddr addr,
6466 const char ** symname,
6469 bfd_vma dist = 0x100000;
6470 Elf_Internal_Sym * sym;
6471 Elf_Internal_Sym * beg;
6472 Elf_Internal_Sym * end;
6473 Elf_Internal_Sym * best = NULL;
6475 REMOVE_ARCH_BITS (addr.offset);
6477 end = symtab + nsyms;
6483 sym = beg + (end - beg) / 2;
6485 value = sym->st_value;
6486 REMOVE_ARCH_BITS (value);
6488 if (sym->st_name != 0
6489 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6490 && addr.offset >= value
6491 && addr.offset - value < dist)
6494 dist = addr.offset - value;
6499 if (addr.offset < value)
6507 *symname = (best->st_name >= strtab_size
6508 ? _("<corrupt>") : strtab + best->st_name);
6514 *offset = addr.offset;
6518 symcmp (const void *p, const void *q)
6520 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
6521 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
6523 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
6526 /* Process the unwind section. */
6528 #include "unwind-ia64.h"
6530 struct ia64_unw_table_entry
6532 struct absaddr start;
6534 struct absaddr info;
6537 struct ia64_unw_aux_info
6539 struct ia64_unw_table_entry *table; /* Unwind table. */
6540 unsigned long table_len; /* Length of unwind table. */
6541 unsigned char * info; /* Unwind info. */
6542 unsigned long info_size; /* Size of unwind info. */
6543 bfd_vma info_addr; /* Starting address of unwind info. */
6544 bfd_vma seg_base; /* Starting address of segment. */
6545 Elf_Internal_Sym * symtab; /* The symbol table. */
6546 unsigned long nsyms; /* Number of symbols. */
6547 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6548 unsigned long nfuns; /* Number of entries in funtab. */
6549 char * strtab; /* The string table. */
6550 unsigned long strtab_size; /* Size of string table. */
6554 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6556 struct ia64_unw_table_entry * tp;
6557 unsigned long j, nfuns;
6560 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6561 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6562 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6563 aux->funtab[nfuns++] = aux->symtab[j];
6565 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6567 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6571 const unsigned char * dp;
6572 const unsigned char * head;
6573 const unsigned char * end;
6574 const char * procname;
6576 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6577 aux->strtab_size, tp->start, &procname, &offset);
6579 fputs ("\n<", stdout);
6583 fputs (procname, stdout);
6586 printf ("+%lx", (unsigned long) offset);
6589 fputs (">: [", stdout);
6590 print_vma (tp->start.offset, PREFIX_HEX);
6591 fputc ('-', stdout);
6592 print_vma (tp->end.offset, PREFIX_HEX);
6593 printf ("], info at +0x%lx\n",
6594 (unsigned long) (tp->info.offset - aux->seg_base));
6596 /* PR 17531: file: 86232b32. */
6597 if (aux->info == NULL)
6600 /* PR 17531: file: 0997b4d1. */
6601 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6603 warn (_("Invalid offset %lx in table entry %ld\n"),
6604 (long) tp->info.offset, (long) (tp - aux->table));
6608 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6609 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6611 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6612 (unsigned) UNW_VER (stamp),
6613 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6614 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6615 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6616 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6618 if (UNW_VER (stamp) != 1)
6620 printf (_("\tUnknown version.\n"));
6625 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6626 /* PR 17531: file: 16ceda89. */
6627 if (end > aux->info + aux->info_size)
6628 end = aux->info + aux->info_size;
6629 for (dp = head + 8; dp < end;)
6630 dp = unw_decode (dp, in_body, & in_body);
6637 slurp_ia64_unwind_table (FILE * file,
6638 struct ia64_unw_aux_info * aux,
6639 Elf_Internal_Shdr * sec)
6641 unsigned long size, nrelas, i;
6642 Elf_Internal_Phdr * seg;
6643 struct ia64_unw_table_entry * tep;
6644 Elf_Internal_Shdr * relsec;
6645 Elf_Internal_Rela * rela;
6646 Elf_Internal_Rela * rp;
6647 unsigned char * table;
6649 Elf_Internal_Sym * sym;
6650 const char * relname;
6654 /* First, find the starting address of the segment that includes
6657 if (elf_header.e_phnum)
6659 if (! get_program_headers (file))
6662 for (seg = program_headers;
6663 seg < program_headers + elf_header.e_phnum;
6666 if (seg->p_type != PT_LOAD)
6669 if (sec->sh_addr >= seg->p_vaddr
6670 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6672 aux->seg_base = seg->p_vaddr;
6678 /* Second, build the unwind table from the contents of the unwind section: */
6679 size = sec->sh_size;
6680 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6685 aux->table_len = size / (3 * eh_addr_size);
6686 aux->table = (struct ia64_unw_table_entry *)
6687 xcmalloc (aux->table_len, sizeof (aux->table[0]));
6690 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6692 tep->start.section = SHN_UNDEF;
6693 tep->end.section = SHN_UNDEF;
6694 tep->info.section = SHN_UNDEF;
6695 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6696 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6697 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6698 tep->start.offset += aux->seg_base;
6699 tep->end.offset += aux->seg_base;
6700 tep->info.offset += aux->seg_base;
6704 /* Third, apply any relocations to the unwind table: */
6705 for (relsec = section_headers;
6706 relsec < section_headers + elf_header.e_shnum;
6709 if (relsec->sh_type != SHT_RELA
6710 || relsec->sh_info >= elf_header.e_shnum
6711 || section_headers + relsec->sh_info != sec)
6714 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6723 for (rp = rela; rp < rela + nrelas; ++rp)
6725 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6726 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6728 /* PR 17531: file: 9fa67536. */
6729 if (relname == NULL)
6731 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6735 if (! const_strneq (relname, "R_IA64_SEGREL"))
6737 warn (_("Skipping unexpected relocation type: %s\n"), relname);
6741 i = rp->r_offset / (3 * eh_addr_size);
6743 /* PR 17531: file: 5bc8d9bf. */
6744 if (i >= aux->table_len)
6746 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6750 switch (rp->r_offset / eh_addr_size % 3)
6753 aux->table[i].start.section = sym->st_shndx;
6754 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6757 aux->table[i].end.section = sym->st_shndx;
6758 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6761 aux->table[i].info.section = sym->st_shndx;
6762 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6776 ia64_process_unwind (FILE * file)
6778 Elf_Internal_Shdr * sec;
6779 Elf_Internal_Shdr * unwsec = NULL;
6780 Elf_Internal_Shdr * strsec;
6781 unsigned long i, unwcount = 0, unwstart = 0;
6782 struct ia64_unw_aux_info aux;
6784 memset (& aux, 0, sizeof (aux));
6786 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6788 if (sec->sh_type == SHT_SYMTAB
6789 && sec->sh_link < elf_header.e_shnum)
6791 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6793 strsec = section_headers + sec->sh_link;
6794 if (aux.strtab != NULL)
6796 error (_("Multiple auxillary string tables encountered\n"));
6799 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6802 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6804 else if (sec->sh_type == SHT_IA_64_UNWIND)
6809 printf (_("\nThere are no unwind sections in this file.\n"));
6811 while (unwcount-- > 0)
6816 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6817 i < elf_header.e_shnum; ++i, ++sec)
6818 if (sec->sh_type == SHT_IA_64_UNWIND)
6823 /* We have already counted the number of SHT_IA64_UNWIND
6824 sections so the loop above should never fail. */
6825 assert (unwsec != NULL);
6828 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6830 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6832 /* We need to find which section group it is in. */
6833 struct group_list * g;
6835 if (section_headers_groups == NULL
6836 || section_headers_groups [i] == NULL)
6837 i = elf_header.e_shnum;
6840 g = section_headers_groups [i]->root;
6842 for (; g != NULL; g = g->next)
6844 sec = section_headers + g->section_index;
6846 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6851 i = elf_header.e_shnum;
6854 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6856 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6857 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6858 suffix = SECTION_NAME (unwsec) + len;
6859 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6861 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6862 && streq (SECTION_NAME (sec) + len2, suffix))
6867 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6868 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6869 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6870 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6872 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6873 suffix = SECTION_NAME (unwsec) + len;
6874 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6876 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6877 && streq (SECTION_NAME (sec) + len2, suffix))
6881 if (i == elf_header.e_shnum)
6883 printf (_("\nCould not find unwind info section for "));
6885 if (string_table == NULL)
6886 printf ("%d", unwsec->sh_name);
6888 printf ("'%s'", printable_section_name (unwsec));
6892 aux.info_addr = sec->sh_addr;
6893 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6896 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6898 printf (_("\nUnwind section "));
6900 if (string_table == NULL)
6901 printf ("%d", unwsec->sh_name);
6903 printf ("'%s'", printable_section_name (unwsec));
6905 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6906 (unsigned long) unwsec->sh_offset,
6907 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6909 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6910 && aux.table_len > 0)
6911 dump_ia64_unwind (& aux);
6914 free ((char *) aux.table);
6916 free ((char *) aux.info);
6925 free ((char *) aux.strtab);
6928 struct hppa_unw_table_entry
6930 struct absaddr start;
6932 unsigned int Cannot_unwind:1; /* 0 */
6933 unsigned int Millicode:1; /* 1 */
6934 unsigned int Millicode_save_sr0:1; /* 2 */
6935 unsigned int Region_description:2; /* 3..4 */
6936 unsigned int reserved1:1; /* 5 */
6937 unsigned int Entry_SR:1; /* 6 */
6938 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6939 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6940 unsigned int Args_stored:1; /* 16 */
6941 unsigned int Variable_Frame:1; /* 17 */
6942 unsigned int Separate_Package_Body:1; /* 18 */
6943 unsigned int Frame_Extension_Millicode:1; /* 19 */
6944 unsigned int Stack_Overflow_Check:1; /* 20 */
6945 unsigned int Two_Instruction_SP_Increment:1;/* 21 */
6946 unsigned int Ada_Region:1; /* 22 */
6947 unsigned int cxx_info:1; /* 23 */
6948 unsigned int cxx_try_catch:1; /* 24 */
6949 unsigned int sched_entry_seq:1; /* 25 */
6950 unsigned int reserved2:1; /* 26 */
6951 unsigned int Save_SP:1; /* 27 */
6952 unsigned int Save_RP:1; /* 28 */
6953 unsigned int Save_MRP_in_frame:1; /* 29 */
6954 unsigned int extn_ptr_defined:1; /* 30 */
6955 unsigned int Cleanup_defined:1; /* 31 */
6957 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6958 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6959 unsigned int Large_frame:1; /* 2 */
6960 unsigned int Pseudo_SP_Set:1; /* 3 */
6961 unsigned int reserved4:1; /* 4 */
6962 unsigned int Total_frame_size:27; /* 5..31 */
6965 struct hppa_unw_aux_info
6967 struct hppa_unw_table_entry * table; /* Unwind table. */
6968 unsigned long table_len; /* Length of unwind table. */
6969 bfd_vma seg_base; /* Starting address of segment. */
6970 Elf_Internal_Sym * symtab; /* The symbol table. */
6971 unsigned long nsyms; /* Number of symbols. */
6972 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
6973 unsigned long nfuns; /* Number of entries in funtab. */
6974 char * strtab; /* The string table. */
6975 unsigned long strtab_size; /* Size of string table. */
6979 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6981 struct hppa_unw_table_entry * tp;
6982 unsigned long j, nfuns;
6984 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
6985 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
6986 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
6987 aux->funtab[nfuns++] = aux->symtab[j];
6989 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
6991 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6994 const char * procname;
6996 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
6997 aux->strtab_size, tp->start, &procname,
7000 fputs ("\n<", stdout);
7004 fputs (procname, stdout);
7007 printf ("+%lx", (unsigned long) offset);
7010 fputs (">: [", stdout);
7011 print_vma (tp->start.offset, PREFIX_HEX);
7012 fputc ('-', stdout);
7013 print_vma (tp->end.offset, PREFIX_HEX);
7016 #define PF(_m) if (tp->_m) printf (#_m " ");
7017 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7020 PF(Millicode_save_sr0);
7021 /* PV(Region_description); */
7027 PF(Separate_Package_Body);
7028 PF(Frame_Extension_Millicode);
7029 PF(Stack_Overflow_Check);
7030 PF(Two_Instruction_SP_Increment);
7034 PF(sched_entry_seq);
7037 PF(Save_MRP_in_frame);
7038 PF(extn_ptr_defined);
7039 PF(Cleanup_defined);
7040 PF(MPE_XL_interrupt_marker);
7041 PF(HP_UX_interrupt_marker);
7044 PV(Total_frame_size);
7055 slurp_hppa_unwind_table (FILE * file,
7056 struct hppa_unw_aux_info * aux,
7057 Elf_Internal_Shdr * sec)
7059 unsigned long size, unw_ent_size, nentries, nrelas, i;
7060 Elf_Internal_Phdr * seg;
7061 struct hppa_unw_table_entry * tep;
7062 Elf_Internal_Shdr * relsec;
7063 Elf_Internal_Rela * rela;
7064 Elf_Internal_Rela * rp;
7065 unsigned char * table;
7067 Elf_Internal_Sym * sym;
7068 const char * relname;
7070 /* First, find the starting address of the segment that includes
7073 if (elf_header.e_phnum)
7075 if (! get_program_headers (file))
7078 for (seg = program_headers;
7079 seg < program_headers + elf_header.e_phnum;
7082 if (seg->p_type != PT_LOAD)
7085 if (sec->sh_addr >= seg->p_vaddr
7086 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7088 aux->seg_base = seg->p_vaddr;
7094 /* Second, build the unwind table from the contents of the unwind
7096 size = sec->sh_size;
7097 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7103 nentries = size / unw_ent_size;
7104 size = unw_ent_size * nentries;
7106 tep = aux->table = (struct hppa_unw_table_entry *)
7107 xcmalloc (nentries, sizeof (aux->table[0]));
7109 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7111 unsigned int tmp1, tmp2;
7113 tep->start.section = SHN_UNDEF;
7114 tep->end.section = SHN_UNDEF;
7116 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7117 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7118 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7119 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7121 tep->start.offset += aux->seg_base;
7122 tep->end.offset += aux->seg_base;
7124 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7125 tep->Millicode = (tmp1 >> 30) & 0x1;
7126 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7127 tep->Region_description = (tmp1 >> 27) & 0x3;
7128 tep->reserved1 = (tmp1 >> 26) & 0x1;
7129 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7130 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7131 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7132 tep->Args_stored = (tmp1 >> 15) & 0x1;
7133 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7134 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7135 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7136 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7137 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7138 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7139 tep->cxx_info = (tmp1 >> 8) & 0x1;
7140 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7141 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7142 tep->reserved2 = (tmp1 >> 5) & 0x1;
7143 tep->Save_SP = (tmp1 >> 4) & 0x1;
7144 tep->Save_RP = (tmp1 >> 3) & 0x1;
7145 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7146 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7147 tep->Cleanup_defined = tmp1 & 0x1;
7149 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7150 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7151 tep->Large_frame = (tmp2 >> 29) & 0x1;
7152 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7153 tep->reserved4 = (tmp2 >> 27) & 0x1;
7154 tep->Total_frame_size = tmp2 & 0x7ffffff;
7158 /* Third, apply any relocations to the unwind table. */
7159 for (relsec = section_headers;
7160 relsec < section_headers + elf_header.e_shnum;
7163 if (relsec->sh_type != SHT_RELA
7164 || relsec->sh_info >= elf_header.e_shnum
7165 || section_headers + relsec->sh_info != sec)
7168 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7172 for (rp = rela; rp < rela + nrelas; ++rp)
7174 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7175 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7177 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7178 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7180 warn (_("Skipping unexpected relocation type %s\n"), relname);
7184 i = rp->r_offset / unw_ent_size;
7186 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7189 aux->table[i].start.section = sym->st_shndx;
7190 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7193 aux->table[i].end.section = sym->st_shndx;
7194 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7204 aux->table_len = nentries;
7210 hppa_process_unwind (FILE * file)
7212 struct hppa_unw_aux_info aux;
7213 Elf_Internal_Shdr * unwsec = NULL;
7214 Elf_Internal_Shdr * strsec;
7215 Elf_Internal_Shdr * sec;
7218 if (string_table == NULL)
7221 memset (& aux, 0, sizeof (aux));
7223 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7225 if (sec->sh_type == SHT_SYMTAB
7226 && sec->sh_link < elf_header.e_shnum)
7228 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7230 strsec = section_headers + sec->sh_link;
7231 if (aux.strtab != NULL)
7233 error (_("Multiple auxillary string tables encountered\n"));
7236 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7239 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7241 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7246 printf (_("\nThere are no unwind sections in this file.\n"));
7248 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7250 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7252 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7253 printable_section_name (sec),
7254 (unsigned long) sec->sh_offset,
7255 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7257 slurp_hppa_unwind_table (file, &aux, sec);
7258 if (aux.table_len > 0)
7259 dump_hppa_unwind (&aux);
7262 free ((char *) aux.table);
7270 free ((char *) aux.strtab);
7275 unsigned char * data; /* The unwind data. */
7276 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7277 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7278 unsigned long nrelas; /* The number of relocations. */
7279 unsigned int rel_type; /* REL or RELA ? */
7280 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7283 struct arm_unw_aux_info
7285 FILE * file; /* The file containing the unwind sections. */
7286 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7287 unsigned long nsyms; /* Number of symbols. */
7288 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7289 unsigned long nfuns; /* Number of these symbols. */
7290 char * strtab; /* The file's string table. */
7291 unsigned long strtab_size; /* Size of string table. */
7295 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7296 bfd_vma fn, struct absaddr addr)
7298 const char *procname;
7301 if (addr.section == SHN_UNDEF)
7304 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7305 aux->strtab_size, addr, &procname,
7308 print_vma (fn, PREFIX_HEX);
7312 fputs (" <", stdout);
7313 fputs (procname, stdout);
7316 printf ("+0x%lx", (unsigned long) sym_offset);
7317 fputc ('>', stdout);
7324 arm_free_section (struct arm_section *arm_sec)
7326 if (arm_sec->data != NULL)
7327 free (arm_sec->data);
7329 if (arm_sec->rela != NULL)
7330 free (arm_sec->rela);
7333 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7334 cached section and install SEC instead.
7335 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7336 and return its valued in * WORDP, relocating if necessary.
7337 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7338 relocation's offset in ADDR.
7339 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7340 into the string table of the symbol associated with the reloc. If no
7341 reloc was applied store -1 there.
7342 5) Return TRUE upon success, FALSE otherwise. */
7345 get_unwind_section_word (struct arm_unw_aux_info * aux,
7346 struct arm_section * arm_sec,
7347 Elf_Internal_Shdr * sec,
7348 bfd_vma word_offset,
7349 unsigned int * wordp,
7350 struct absaddr * addr,
7353 Elf_Internal_Rela *rp;
7354 Elf_Internal_Sym *sym;
7355 const char * relname;
7357 bfd_boolean wrapped;
7359 if (sec == NULL || arm_sec == NULL)
7362 addr->section = SHN_UNDEF;
7365 if (sym_name != NULL)
7366 *sym_name = (bfd_vma) -1;
7368 /* If necessary, update the section cache. */
7369 if (sec != arm_sec->sec)
7371 Elf_Internal_Shdr *relsec;
7373 arm_free_section (arm_sec);
7376 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7377 sec->sh_size, _("unwind data"));
7378 arm_sec->rela = NULL;
7379 arm_sec->nrelas = 0;
7381 for (relsec = section_headers;
7382 relsec < section_headers + elf_header.e_shnum;
7385 if (relsec->sh_info >= elf_header.e_shnum
7386 || section_headers + relsec->sh_info != sec
7387 /* PR 15745: Check the section type as well. */
7388 || (relsec->sh_type != SHT_REL
7389 && relsec->sh_type != SHT_RELA))
7392 arm_sec->rel_type = relsec->sh_type;
7393 if (relsec->sh_type == SHT_REL)
7395 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7397 & arm_sec->rela, & arm_sec->nrelas))
7400 else /* relsec->sh_type == SHT_RELA */
7402 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7404 & arm_sec->rela, & arm_sec->nrelas))
7410 arm_sec->next_rela = arm_sec->rela;
7413 /* If there is no unwind data we can do nothing. */
7414 if (arm_sec->data == NULL)
7417 /* If the offset is invalid then fail. */
7418 if (word_offset > sec->sh_size - 4)
7421 /* Get the word at the required offset. */
7422 word = byte_get (arm_sec->data + word_offset, 4);
7424 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7425 if (arm_sec->rela == NULL)
7431 /* Look through the relocs to find the one that applies to the provided offset. */
7433 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7435 bfd_vma prelval, offset;
7437 if (rp->r_offset > word_offset && !wrapped)
7442 if (rp->r_offset > word_offset)
7445 if (rp->r_offset & 3)
7447 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7448 (unsigned long) rp->r_offset);
7452 if (rp->r_offset < word_offset)
7455 /* PR 17531: file: 027-161405-0.004 */
7456 if (aux->symtab == NULL)
7459 if (arm_sec->rel_type == SHT_REL)
7461 offset = word & 0x7fffffff;
7462 if (offset & 0x40000000)
7463 offset |= ~ (bfd_vma) 0x7fffffff;
7465 else if (arm_sec->rel_type == SHT_RELA)
7466 offset = rp->r_addend;
7469 error (_("Unknown section relocation type %d encountered\n"),
7474 /* PR 17531 file: 027-1241568-0.004. */
7475 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7477 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7478 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7482 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7483 offset += sym->st_value;
7484 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7486 /* Check that we are processing the expected reloc type. */
7487 if (elf_header.e_machine == EM_ARM)
7489 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7490 if (relname == NULL)
7492 warn (_("Skipping unknown ARM relocation type: %d\n"),
7493 (int) ELF32_R_TYPE (rp->r_info));
7497 if (streq (relname, "R_ARM_NONE"))
7500 if (! streq (relname, "R_ARM_PREL31"))
7502 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7506 else if (elf_header.e_machine == EM_TI_C6000)
7508 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7509 if (relname == NULL)
7511 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7512 (int) ELF32_R_TYPE (rp->r_info));
7516 if (streq (relname, "R_C6000_NONE"))
7519 if (! streq (relname, "R_C6000_PREL31"))
7521 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7529 /* This function currently only supports ARM and TI unwinders. */
7530 warn (_("Only TI and ARM unwinders are currently supported\n"));
7534 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7535 addr->section = sym->st_shndx;
7536 addr->offset = offset;
7539 * sym_name = sym->st_name;
7544 arm_sec->next_rela = rp;
7549 static const char *tic6x_unwind_regnames[16] =
7551 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7552 "A14", "A13", "A12", "A11", "A10",
7553 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7557 decode_tic6x_unwind_regmask (unsigned int mask)
7561 for (i = 12; mask; mask >>= 1, i--)
7565 fputs (tic6x_unwind_regnames[i], stdout);
7567 fputs (", ", stdout);
7573 if (remaining == 0 && more_words) \
7576 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7577 data_offset, & word, & addr, NULL)) \
7583 #define GET_OP(OP) \
7588 (OP) = word >> 24; \
7593 printf (_("[Truncated opcode]\n")); \
7596 printf ("0x%02x ", OP)
7599 decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
7601 unsigned int remaining,
7602 unsigned int more_words,
7603 bfd_vma data_offset,
7604 Elf_Internal_Shdr * data_sec,
7605 struct arm_section * data_arm_sec)
7607 struct absaddr addr;
7609 /* Decode the unwinding instructions. */
7612 unsigned int op, op2;
7621 printf (" 0x%02x ", op);
7623 if ((op & 0xc0) == 0x00)
7625 int offset = ((op & 0x3f) << 2) + 4;
7627 printf (" vsp = vsp + %d", offset);
7629 else if ((op & 0xc0) == 0x40)
7631 int offset = ((op & 0x3f) << 2) + 4;
7633 printf (" vsp = vsp - %d", offset);
7635 else if ((op & 0xf0) == 0x80)
7638 if (op == 0x80 && op2 == 0)
7639 printf (_("Refuse to unwind"));
7642 unsigned int mask = ((op & 0x0f) << 8) | op2;
7647 for (i = 0; i < 12; i++)
7648 if (mask & (1 << i))
7654 printf ("r%d", 4 + i);
7659 else if ((op & 0xf0) == 0x90)
7661 if (op == 0x9d || op == 0x9f)
7662 printf (_(" [Reserved]"));
7664 printf (" vsp = r%d", op & 0x0f);
7666 else if ((op & 0xf0) == 0xa0)
7668 int end = 4 + (op & 0x07);
7673 for (i = 4; i <= end; i++)
7689 else if (op == 0xb0)
7690 printf (_(" finish"));
7691 else if (op == 0xb1)
7694 if (op2 == 0 || (op2 & 0xf0) != 0)
7695 printf (_("[Spare]"));
7698 unsigned int mask = op2 & 0x0f;
7703 for (i = 0; i < 12; i++)
7704 if (mask & (1 << i))
7715 else if (op == 0xb2)
7717 unsigned char buf[9];
7718 unsigned int i, len;
7719 unsigned long offset;
7721 for (i = 0; i < sizeof (buf); i++)
7724 if ((buf[i] & 0x80) == 0)
7727 if (i == sizeof (buf))
7728 printf (_("corrupt change to vsp"));
7731 offset = read_uleb128 (buf, &len, buf + i + 1);
7732 assert (len == i + 1);
7733 offset = offset * 4 + 0x204;
7734 printf ("vsp = vsp + %ld", offset);
7737 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7739 unsigned int first, last;
7746 printf ("pop {D%d", first);
7748 printf ("-D%d", first + last);
7751 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7753 unsigned int count = op & 0x07;
7757 printf ("-D%d", 8 + count);
7760 else if (op >= 0xc0 && op <= 0xc5)
7762 unsigned int count = op & 0x07;
7764 printf (" pop {wR10");
7766 printf ("-wR%d", 10 + count);
7769 else if (op == 0xc6)
7771 unsigned int first, last;
7776 printf ("pop {wR%d", first);
7778 printf ("-wR%d", first + last);
7781 else if (op == 0xc7)
7784 if (op2 == 0 || (op2 & 0xf0) != 0)
7785 printf (_("[Spare]"));
7788 unsigned int mask = op2 & 0x0f;
7793 for (i = 0; i < 4; i++)
7794 if (mask & (1 << i))
7800 printf ("wCGR%d", i);
7806 printf (_(" [unsupported opcode]"));
7812 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
7814 unsigned int remaining,
7815 unsigned int more_words,
7816 bfd_vma data_offset,
7817 Elf_Internal_Shdr * data_sec,
7818 struct arm_section * data_arm_sec)
7820 struct absaddr addr;
7822 /* Decode the unwinding instructions. */
7825 unsigned int op, op2;
7834 printf (" 0x%02x ", op);
7836 if ((op & 0xc0) == 0x00)
7838 int offset = ((op & 0x3f) << 3) + 8;
7839 printf (" sp = sp + %d", offset);
7841 else if ((op & 0xc0) == 0x80)
7844 if (op == 0x80 && op2 == 0)
7845 printf (_("Refuse to unwind"));
7848 unsigned int mask = ((op & 0x1f) << 8) | op2;
7850 printf ("pop compact {");
7854 decode_tic6x_unwind_regmask (mask);
7858 else if ((op & 0xf0) == 0xc0)
7866 unsigned int offset;
7870 /* Scan entire instruction first so that GET_OP output is not
7871 interleaved with disassembly. */
7873 for (i = 0; nregs < (op & 0xf); i++)
7879 regpos[nregs].offset = i * 2;
7880 regpos[nregs].reg = reg;
7887 regpos[nregs].offset = i * 2 + 1;
7888 regpos[nregs].reg = reg;
7893 printf (_("pop frame {"));
7895 for (i = i * 2; i > 0; i--)
7897 if (regpos[reg].offset == i - 1)
7899 name = tic6x_unwind_regnames[regpos[reg].reg];
7906 fputs (name, stdout);
7913 else if (op == 0xd0)
7914 printf (" MOV FP, SP");
7915 else if (op == 0xd1)
7916 printf (" __c6xabi_pop_rts");
7917 else if (op == 0xd2)
7919 unsigned char buf[9];
7920 unsigned int i, len;
7921 unsigned long offset;
7923 for (i = 0; i < sizeof (buf); i++)
7926 if ((buf[i] & 0x80) == 0)
7929 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7930 if (i == sizeof (buf))
7932 printf ("<corrupt sp adjust>\n");
7933 warn (_("Corrupt stack pointer adjustment detected\n"));
7937 offset = read_uleb128 (buf, &len, buf + i + 1);
7938 assert (len == i + 1);
7939 offset = offset * 8 + 0x408;
7940 printf (_("sp = sp + %ld"), offset);
7942 else if ((op & 0xf0) == 0xe0)
7944 if ((op & 0x0f) == 7)
7947 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7951 printf (_(" [unsupported opcode]"));
7958 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7962 offset = word & 0x7fffffff;
7963 if (offset & 0x40000000)
7964 offset |= ~ (bfd_vma) 0x7fffffff;
7966 if (elf_header.e_machine == EM_TI_C6000)
7969 return offset + where;
7973 decode_arm_unwind (struct arm_unw_aux_info * aux,
7975 unsigned int remaining,
7976 bfd_vma data_offset,
7977 Elf_Internal_Shdr * data_sec,
7978 struct arm_section * data_arm_sec)
7981 unsigned int more_words = 0;
7982 struct absaddr addr;
7983 bfd_vma sym_name = (bfd_vma) -1;
7987 /* Fetch the first word.
7988 Note - when decoding an object file the address extracted
7989 here will always be 0. So we also pass in the sym_name
7990 parameter so that we can find the symbol associated with
7991 the personality routine. */
7992 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7993 & word, & addr, & sym_name))
7999 if ((word & 0x80000000) == 0)
8001 /* Expand prel31 for personality routine. */
8003 const char *procname;
8005 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8006 printf (_(" Personality routine: "));
8008 && addr.section == SHN_UNDEF && addr.offset == 0
8009 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8011 procname = aux->strtab + sym_name;
8012 print_vma (fn, PREFIX_HEX);
8015 fputs (" <", stdout);
8016 fputs (procname, stdout);
8017 fputc ('>', stdout);
8021 procname = arm_print_vma_and_name (aux, fn, addr);
8022 fputc ('\n', stdout);
8024 /* The GCC personality routines use the standard compact
8025 encoding, starting with one byte giving the number of
8027 if (procname != NULL
8028 && (const_strneq (procname, "__gcc_personality_v0")
8029 || const_strneq (procname, "__gxx_personality_v0")
8030 || const_strneq (procname, "__gcj_personality_v0")
8031 || const_strneq (procname, "__gnu_objc_personality_v0")))
8038 printf (_(" [Truncated data]\n"));
8041 more_words = word >> 24;
8051 /* ARM EHABI Section 6.3:
8053 An exception-handling table entry for the compact model looks like:
8057 1 0 index Data for personalityRoutine[index] */
8059 if (elf_header.e_machine == EM_ARM
8060 && (word & 0x70000000))
8061 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8063 per_index = (word >> 24) & 0x7f;
8064 printf (_(" Compact model index: %d\n"), per_index);
8071 else if (per_index < 3)
8073 more_words = (word >> 16) & 0xff;
8079 switch (elf_header.e_machine)
8084 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8085 data_offset, data_sec, data_arm_sec);
8089 warn (_("Unknown ARM compact model index encountered\n"));
8090 printf (_(" [reserved]\n"));
8097 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8098 data_offset, data_sec, data_arm_sec);
8100 else if (per_index < 5)
8102 if (((word >> 17) & 0x7f) == 0x7f)
8103 printf (_(" Restore stack from frame pointer\n"));
8105 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8106 printf (_(" Registers restored: "));
8108 printf (" (compact) ");
8109 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8111 printf (_(" Return register: %s\n"),
8112 tic6x_unwind_regnames[word & 0xf]);
8115 printf (_(" [reserved (%d)]\n"), per_index);
8119 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8120 elf_header.e_machine);
8123 /* Decode the descriptors. Not implemented. */
8127 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8129 struct arm_section exidx_arm_sec, extab_arm_sec;
8130 unsigned int i, exidx_len;
8131 unsigned long j, nfuns;
8133 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8134 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8135 exidx_len = exidx_sec->sh_size / 8;
8137 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8138 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8139 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8140 aux->funtab[nfuns++] = aux->symtab[j];
8142 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8144 for (i = 0; i < exidx_len; i++)
8146 unsigned int exidx_fn, exidx_entry;
8147 struct absaddr fn_addr, entry_addr;
8150 fputc ('\n', stdout);
8152 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8153 8 * i, & exidx_fn, & fn_addr, NULL)
8154 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8155 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8158 arm_free_section (& exidx_arm_sec);
8159 arm_free_section (& extab_arm_sec);
8163 /* ARM EHABI, Section 5:
8164 An index table entry consists of 2 words.
8165 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8166 if (exidx_fn & 0x80000000)
8167 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8169 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8171 arm_print_vma_and_name (aux, fn, fn_addr);
8172 fputs (": ", stdout);
8174 if (exidx_entry == 1)
8176 print_vma (exidx_entry, PREFIX_HEX);
8177 fputs (" [cantunwind]\n", stdout);
8179 else if (exidx_entry & 0x80000000)
8181 print_vma (exidx_entry, PREFIX_HEX);
8182 fputc ('\n', stdout);
8183 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8187 bfd_vma table, table_offset = 0;
8188 Elf_Internal_Shdr *table_sec;
8190 fputs ("@", stdout);
8191 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8192 print_vma (table, PREFIX_HEX);
8195 /* Locate the matching .ARM.extab. */
8196 if (entry_addr.section != SHN_UNDEF
8197 && entry_addr.section < elf_header.e_shnum)
8199 table_sec = section_headers + entry_addr.section;
8200 table_offset = entry_addr.offset;
8204 table_sec = find_section_by_address (table);
8205 if (table_sec != NULL)
8206 table_offset = table - table_sec->sh_addr;
8208 if (table_sec == NULL)
8210 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8211 (unsigned long) table);
8214 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8222 arm_free_section (&exidx_arm_sec);
8223 arm_free_section (&extab_arm_sec);
8226 /* Used for both ARM and C6X unwinding tables. */
8229 arm_process_unwind (FILE *file)
8231 struct arm_unw_aux_info aux;
8232 Elf_Internal_Shdr *unwsec = NULL;
8233 Elf_Internal_Shdr *strsec;
8234 Elf_Internal_Shdr *sec;
8236 unsigned int sec_type;
8238 switch (elf_header.e_machine)
8241 sec_type = SHT_ARM_EXIDX;
8245 sec_type = SHT_C6000_UNWIND;
8249 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8250 elf_header.e_machine);
8254 if (string_table == NULL)
8257 memset (& aux, 0, sizeof (aux));
8260 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8262 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8264 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8266 strsec = section_headers + sec->sh_link;
8268 /* PR binutils/17531 file: 011-12666-0.004. */
8269 if (aux.strtab != NULL)
8271 error (_("Multiple string tables found in file.\n"));
8274 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8275 1, strsec->sh_size, _("string table"));
8276 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8278 else if (sec->sh_type == sec_type)
8283 printf (_("\nThere are no unwind sections in this file.\n"));
8285 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8287 if (sec->sh_type == sec_type)
8289 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8290 printable_section_name (sec),
8291 (unsigned long) sec->sh_offset,
8292 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8294 dump_arm_unwind (&aux, sec);
8301 free ((char *) aux.strtab);
8305 process_unwind (FILE * file)
8307 struct unwind_handler
8310 void (* handler)(FILE *);
8313 { EM_ARM, arm_process_unwind },
8314 { EM_IA_64, ia64_process_unwind },
8315 { EM_PARISC, hppa_process_unwind },
8316 { EM_TI_C6000, arm_process_unwind },
8324 for (i = 0; handlers[i].handler != NULL; i++)
8325 if (elf_header.e_machine == handlers[i].machtype)
8327 handlers[i].handler (file);
8331 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8332 get_machine_name (elf_header.e_machine));
8336 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8338 switch (entry->d_tag)
8341 if (entry->d_un.d_val == 0)
8345 static const char * opts[] =
8347 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8348 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8349 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8350 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8356 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8357 if (entry->d_un.d_val & (1 << cnt))
8359 printf ("%s%s", first ? "" : " ", opts[cnt]);
8365 case DT_MIPS_IVERSION:
8366 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8367 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8371 sprintf_vma (buf, entry->d_un.d_ptr);
8372 /* Note: coded this way so that there is a single string for translation. */
8373 printf (_("<corrupt: %s>"), buf);
8377 case DT_MIPS_TIME_STAMP:
8381 time_t atime = entry->d_un.d_val;
8383 tmp = gmtime (&atime);
8384 /* PR 17531: file: 6accc532. */
8386 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8388 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8389 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8390 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8391 printf (_("Time Stamp: %s"), timebuf);
8395 case DT_MIPS_RLD_VERSION:
8396 case DT_MIPS_LOCAL_GOTNO:
8397 case DT_MIPS_CONFLICTNO:
8398 case DT_MIPS_LIBLISTNO:
8399 case DT_MIPS_SYMTABNO:
8400 case DT_MIPS_UNREFEXTNO:
8401 case DT_MIPS_HIPAGENO:
8402 case DT_MIPS_DELTA_CLASS_NO:
8403 case DT_MIPS_DELTA_INSTANCE_NO:
8404 case DT_MIPS_DELTA_RELOC_NO:
8405 case DT_MIPS_DELTA_SYM_NO:
8406 case DT_MIPS_DELTA_CLASSSYM_NO:
8407 case DT_MIPS_COMPACT_SIZE:
8408 print_vma (entry->d_un.d_ptr, DEC);
8412 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8418 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8420 switch (entry->d_tag)
8422 case DT_HP_DLD_FLAGS:
8431 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8432 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8433 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8434 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8435 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8436 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8437 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8438 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8439 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8440 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8441 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8442 { DT_HP_GST, "HP_GST" },
8443 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8444 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8445 { DT_HP_NODELETE, "HP_NODELETE" },
8446 { DT_HP_GROUP, "HP_GROUP" },
8447 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8451 bfd_vma val = entry->d_un.d_val;
8453 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8454 if (val & flags[cnt].bit)
8458 fputs (flags[cnt].str, stdout);
8460 val ^= flags[cnt].bit;
8463 if (val != 0 || first)
8467 print_vma (val, HEX);
8473 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8481 /* VMS vs Unix time offset and factor. */
8483 #define VMS_EPOCH_OFFSET 35067168000000000LL
8484 #define VMS_GRANULARITY_FACTOR 10000000
8486 /* Display a VMS time in a human readable format. */
8489 print_vms_time (bfd_int64_t vmstime)
8494 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8495 tm = gmtime (&unxtime);
8496 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8497 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8498 tm->tm_hour, tm->tm_min, tm->tm_sec);
8503 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8505 switch (entry->d_tag)
8507 case DT_IA_64_PLT_RESERVE:
8508 /* First 3 slots reserved. */
8509 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8511 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8514 case DT_IA_64_VMS_LINKTIME:
8516 print_vms_time (entry->d_un.d_val);
8520 case DT_IA_64_VMS_LNKFLAGS:
8521 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8522 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8523 printf (" CALL_DEBUG");
8524 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8525 printf (" NOP0BUFS");
8526 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8527 printf (" P0IMAGE");
8528 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8529 printf (" MKTHREADS");
8530 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8531 printf (" UPCALLS");
8532 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8534 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8535 printf (" INITIALIZE");
8536 if (entry->d_un.d_val & VMS_LF_MAIN)
8538 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8539 printf (" EXE_INIT");
8540 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8541 printf (" TBK_IN_IMG");
8542 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8543 printf (" DBG_IN_IMG");
8544 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8545 printf (" TBK_IN_DSF");
8546 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8547 printf (" DBG_IN_DSF");
8548 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8549 printf (" SIGNATURES");
8550 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8551 printf (" REL_SEG_OFF");
8555 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8562 get_32bit_dynamic_section (FILE * file)
8564 Elf32_External_Dyn * edyn;
8565 Elf32_External_Dyn * ext;
8566 Elf_Internal_Dyn * entry;
8568 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8569 dynamic_size, _("dynamic section"));
8573 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8574 might not have the luxury of section headers. Look for the DT_NULL
8575 terminator to determine the number of entries. */
8576 for (ext = edyn, dynamic_nent = 0;
8577 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8581 if (BYTE_GET (ext->d_tag) == DT_NULL)
8585 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8587 if (dynamic_section == NULL)
8589 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8590 (unsigned long) dynamic_nent);
8595 for (ext = edyn, entry = dynamic_section;
8596 entry < dynamic_section + dynamic_nent;
8599 entry->d_tag = BYTE_GET (ext->d_tag);
8600 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8609 get_64bit_dynamic_section (FILE * file)
8611 Elf64_External_Dyn * edyn;
8612 Elf64_External_Dyn * ext;
8613 Elf_Internal_Dyn * entry;
8615 /* Read in the data. */
8616 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8617 dynamic_size, _("dynamic section"));
8621 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8622 might not have the luxury of section headers. Look for the DT_NULL
8623 terminator to determine the number of entries. */
8624 for (ext = edyn, dynamic_nent = 0;
8625 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8626 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8630 if (BYTE_GET (ext->d_tag) == DT_NULL)
8634 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8636 if (dynamic_section == NULL)
8638 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8639 (unsigned long) dynamic_nent);
8644 /* Convert from external to internal formats. */
8645 for (ext = edyn, entry = dynamic_section;
8646 entry < dynamic_section + dynamic_nent;
8649 entry->d_tag = BYTE_GET (ext->d_tag);
8650 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8659 print_dynamic_flags (bfd_vma flags)
8667 flag = flags & - flags;
8677 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8678 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8679 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8680 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8681 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8682 default: fputs (_("unknown"), stdout); break;
8688 /* Parse and display the contents of the dynamic section. */
8691 process_dynamic_section (FILE * file)
8693 Elf_Internal_Dyn * entry;
8695 if (dynamic_size == 0)
8698 printf (_("\nThere is no dynamic section in this file.\n"));
8705 if (! get_32bit_dynamic_section (file))
8708 else if (! get_64bit_dynamic_section (file))
8711 /* Find the appropriate symbol table. */
8712 if (dynamic_symbols == NULL)
8714 for (entry = dynamic_section;
8715 entry < dynamic_section + dynamic_nent;
8718 Elf_Internal_Shdr section;
8720 if (entry->d_tag != DT_SYMTAB)
8723 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8725 /* Since we do not know how big the symbol table is,
8726 we default to reading in the entire file (!) and
8727 processing that. This is overkill, I know, but it
8729 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8731 if (archive_file_offset != 0)
8732 section.sh_size = archive_file_size - section.sh_offset;
8735 if (fseek (file, 0, SEEK_END))
8736 error (_("Unable to seek to end of file!\n"));
8738 section.sh_size = ftell (file) - section.sh_offset;
8742 section.sh_entsize = sizeof (Elf32_External_Sym);
8744 section.sh_entsize = sizeof (Elf64_External_Sym);
8745 section.sh_name = string_table_length;
8747 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8748 if (num_dynamic_syms < 1)
8750 error (_("Unable to determine the number of symbols to load\n"));
8756 /* Similarly find a string table. */
8757 if (dynamic_strings == NULL)
8759 for (entry = dynamic_section;
8760 entry < dynamic_section + dynamic_nent;
8763 unsigned long offset;
8766 if (entry->d_tag != DT_STRTAB)
8769 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8771 /* Since we do not know how big the string table is,
8772 we default to reading in the entire file (!) and
8773 processing that. This is overkill, I know, but it
8776 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8778 if (archive_file_offset != 0)
8779 str_tab_len = archive_file_size - offset;
8782 if (fseek (file, 0, SEEK_END))
8783 error (_("Unable to seek to end of file\n"));
8784 str_tab_len = ftell (file) - offset;
8787 if (str_tab_len < 1)
8790 (_("Unable to determine the length of the dynamic string table\n"));
8794 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8796 _("dynamic string table"));
8797 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8802 /* And find the syminfo section if available. */
8803 if (dynamic_syminfo == NULL)
8805 unsigned long syminsz = 0;
8807 for (entry = dynamic_section;
8808 entry < dynamic_section + dynamic_nent;
8811 if (entry->d_tag == DT_SYMINENT)
8813 /* Note: these braces are necessary to avoid a syntax
8814 error from the SunOS4 C compiler. */
8815 /* PR binutils/17531: A corrupt file can trigger this test.
8816 So do not use an assert, instead generate an error message. */
8817 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8818 error (_("Bad value (%d) for SYMINENT entry\n"),
8819 (int) entry->d_un.d_val);
8821 else if (entry->d_tag == DT_SYMINSZ)
8822 syminsz = entry->d_un.d_val;
8823 else if (entry->d_tag == DT_SYMINFO)
8824 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8828 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8830 Elf_External_Syminfo * extsyminfo;
8831 Elf_External_Syminfo * extsym;
8832 Elf_Internal_Syminfo * syminfo;
8834 /* There is a syminfo section. Read the data. */
8835 extsyminfo = (Elf_External_Syminfo *)
8836 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8837 _("symbol information"));
8841 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8842 if (dynamic_syminfo == NULL)
8844 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8845 (unsigned long) syminsz);
8849 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8850 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8851 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8852 ++syminfo, ++extsym)
8854 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8855 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8862 if (do_dynamic && dynamic_addr)
8863 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8864 dynamic_addr, (unsigned long) dynamic_nent);
8866 printf (_(" Tag Type Name/Value\n"));
8868 for (entry = dynamic_section;
8869 entry < dynamic_section + dynamic_nent;
8877 print_vma (entry->d_tag, FULL_HEX);
8878 dtype = get_dynamic_type (entry->d_tag);
8879 printf (" (%s)%*s", dtype,
8880 ((is_32bit_elf ? 27 : 19)
8881 - (int) strlen (dtype)),
8885 switch (entry->d_tag)
8889 print_dynamic_flags (entry->d_un.d_val);
8899 switch (entry->d_tag)
8902 printf (_("Auxiliary library"));
8906 printf (_("Filter library"));
8910 printf (_("Configuration file"));
8914 printf (_("Dependency audit library"));
8918 printf (_("Audit library"));
8922 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8923 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8927 print_vma (entry->d_un.d_val, PREFIX_HEX);
8936 printf (_("Flags:"));
8938 if (entry->d_un.d_val == 0)
8939 printf (_(" None\n"));
8942 unsigned long int val = entry->d_un.d_val;
8944 if (val & DTF_1_PARINIT)
8946 printf (" PARINIT");
8947 val ^= DTF_1_PARINIT;
8949 if (val & DTF_1_CONFEXP)
8951 printf (" CONFEXP");
8952 val ^= DTF_1_CONFEXP;
8955 printf (" %lx", val);
8964 printf (_("Flags:"));
8966 if (entry->d_un.d_val == 0)
8967 printf (_(" None\n"));
8970 unsigned long int val = entry->d_un.d_val;
8972 if (val & DF_P1_LAZYLOAD)
8974 printf (" LAZYLOAD");
8975 val ^= DF_P1_LAZYLOAD;
8977 if (val & DF_P1_GROUPPERM)
8979 printf (" GROUPPERM");
8980 val ^= DF_P1_GROUPPERM;
8983 printf (" %lx", val);
8992 printf (_("Flags:"));
8993 if (entry->d_un.d_val == 0)
8994 printf (_(" None\n"));
8997 unsigned long int val = entry->d_un.d_val;
9004 if (val & DF_1_GLOBAL)
9009 if (val & DF_1_GROUP)
9014 if (val & DF_1_NODELETE)
9016 printf (" NODELETE");
9017 val ^= DF_1_NODELETE;
9019 if (val & DF_1_LOADFLTR)
9021 printf (" LOADFLTR");
9022 val ^= DF_1_LOADFLTR;
9024 if (val & DF_1_INITFIRST)
9026 printf (" INITFIRST");
9027 val ^= DF_1_INITFIRST;
9029 if (val & DF_1_NOOPEN)
9034 if (val & DF_1_ORIGIN)
9039 if (val & DF_1_DIRECT)
9044 if (val & DF_1_TRANS)
9049 if (val & DF_1_INTERPOSE)
9051 printf (" INTERPOSE");
9052 val ^= DF_1_INTERPOSE;
9054 if (val & DF_1_NODEFLIB)
9056 printf (" NODEFLIB");
9057 val ^= DF_1_NODEFLIB;
9059 if (val & DF_1_NODUMP)
9064 if (val & DF_1_CONFALT)
9066 printf (" CONFALT");
9067 val ^= DF_1_CONFALT;
9069 if (val & DF_1_ENDFILTEE)
9071 printf (" ENDFILTEE");
9072 val ^= DF_1_ENDFILTEE;
9074 if (val & DF_1_DISPRELDNE)
9076 printf (" DISPRELDNE");
9077 val ^= DF_1_DISPRELDNE;
9079 if (val & DF_1_DISPRELPND)
9081 printf (" DISPRELPND");
9082 val ^= DF_1_DISPRELPND;
9084 if (val & DF_1_NODIRECT)
9086 printf (" NODIRECT");
9087 val ^= DF_1_NODIRECT;
9089 if (val & DF_1_IGNMULDEF)
9091 printf (" IGNMULDEF");
9092 val ^= DF_1_IGNMULDEF;
9094 if (val & DF_1_NOKSYMS)
9096 printf (" NOKSYMS");
9097 val ^= DF_1_NOKSYMS;
9099 if (val & DF_1_NOHDR)
9104 if (val & DF_1_EDITED)
9109 if (val & DF_1_NORELOC)
9111 printf (" NORELOC");
9112 val ^= DF_1_NORELOC;
9114 if (val & DF_1_SYMINTPOSE)
9116 printf (" SYMINTPOSE");
9117 val ^= DF_1_SYMINTPOSE;
9119 if (val & DF_1_GLOBAUDIT)
9121 printf (" GLOBAUDIT");
9122 val ^= DF_1_GLOBAUDIT;
9124 if (val & DF_1_SINGLETON)
9126 printf (" SINGLETON");
9127 val ^= DF_1_SINGLETON;
9130 printf (" %lx", val);
9137 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9139 puts (get_dynamic_type (entry->d_un.d_val));
9159 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9165 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9166 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9172 switch (entry->d_tag)
9175 printf (_("Shared library: [%s]"), name);
9177 if (streq (name, program_interpreter))
9178 printf (_(" program interpreter"));
9182 printf (_("Library soname: [%s]"), name);
9186 printf (_("Library rpath: [%s]"), name);
9190 printf (_("Library runpath: [%s]"), name);
9194 print_vma (entry->d_un.d_val, PREFIX_HEX);
9199 print_vma (entry->d_un.d_val, PREFIX_HEX);
9212 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9216 case DT_INIT_ARRAYSZ:
9217 case DT_FINI_ARRAYSZ:
9218 case DT_GNU_CONFLICTSZ:
9219 case DT_GNU_LIBLISTSZ:
9222 print_vma (entry->d_un.d_val, UNSIGNED);
9223 printf (_(" (bytes)\n"));
9233 print_vma (entry->d_un.d_val, UNSIGNED);
9246 if (entry->d_tag == DT_USED
9247 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9249 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9253 printf (_("Not needed object: [%s]\n"), name);
9258 print_vma (entry->d_un.d_val, PREFIX_HEX);
9264 /* The value of this entry is ignored. */
9269 case DT_GNU_PRELINKED:
9273 time_t atime = entry->d_un.d_val;
9275 tmp = gmtime (&atime);
9276 /* PR 17533 file: 041-1244816-0.004. */
9278 printf (_("<corrupt time val: %lx"),
9279 (unsigned long) atime);
9281 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9282 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9283 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9289 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9292 print_vma (entry->d_un.d_val, PREFIX_HEX);
9298 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9299 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9304 switch (elf_header.e_machine)
9307 case EM_MIPS_RS3_LE:
9308 dynamic_section_mips_val (entry);
9311 dynamic_section_parisc_val (entry);
9314 dynamic_section_ia64_val (entry);
9317 print_vma (entry->d_un.d_val, PREFIX_HEX);
9329 get_ver_flags (unsigned int flags)
9331 static char buff[32];
9338 if (flags & VER_FLG_BASE)
9339 strcat (buff, "BASE ");
9341 if (flags & VER_FLG_WEAK)
9343 if (flags & VER_FLG_BASE)
9344 strcat (buff, "| ");
9346 strcat (buff, "WEAK ");
9349 if (flags & VER_FLG_INFO)
9351 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9352 strcat (buff, "| ");
9354 strcat (buff, "INFO ");
9357 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9358 strcat (buff, _("| <unknown>"));
9363 /* Display the contents of the version sections. */
9366 process_version_sections (FILE * file)
9368 Elf_Internal_Shdr * section;
9375 for (i = 0, section = section_headers;
9376 i < elf_header.e_shnum;
9379 switch (section->sh_type)
9381 case SHT_GNU_verdef:
9383 Elf_External_Verdef * edefs;
9390 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9391 printable_section_name (section),
9394 printf (_(" Addr: 0x"));
9395 printf_vma (section->sh_addr);
9396 printf (_(" Offset: %#08lx Link: %u (%s)"),
9397 (unsigned long) section->sh_offset, section->sh_link,
9398 printable_section_name_from_index (section->sh_link));
9400 edefs = (Elf_External_Verdef *)
9401 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9402 _("version definition section"));
9405 endbuf = (char *) edefs + section->sh_size;
9407 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9410 Elf_External_Verdef * edef;
9411 Elf_Internal_Verdef ent;
9412 Elf_External_Verdaux * eaux;
9413 Elf_Internal_Verdaux aux;
9417 /* Check for very large indicies. */
9418 if (idx > (size_t) (endbuf - (char *) edefs))
9421 vstart = ((char *) edefs) + idx;
9422 if (vstart + sizeof (*edef) > endbuf)
9425 edef = (Elf_External_Verdef *) vstart;
9427 ent.vd_version = BYTE_GET (edef->vd_version);
9428 ent.vd_flags = BYTE_GET (edef->vd_flags);
9429 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9430 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9431 ent.vd_hash = BYTE_GET (edef->vd_hash);
9432 ent.vd_aux = BYTE_GET (edef->vd_aux);
9433 ent.vd_next = BYTE_GET (edef->vd_next);
9435 printf (_(" %#06x: Rev: %d Flags: %s"),
9436 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9438 printf (_(" Index: %d Cnt: %d "),
9439 ent.vd_ndx, ent.vd_cnt);
9441 /* Check for overflow. */
9442 if (ent.vd_aux > (size_t) (endbuf - vstart))
9445 vstart += ent.vd_aux;
9447 eaux = (Elf_External_Verdaux *) vstart;
9449 aux.vda_name = BYTE_GET (eaux->vda_name);
9450 aux.vda_next = BYTE_GET (eaux->vda_next);
9452 if (VALID_DYNAMIC_NAME (aux.vda_name))
9453 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9455 printf (_("Name index: %ld\n"), aux.vda_name);
9457 isum = idx + ent.vd_aux;
9459 for (j = 1; j < ent.vd_cnt; j++)
9461 /* Check for overflow. */
9462 if (aux.vda_next > (size_t) (endbuf - vstart))
9465 isum += aux.vda_next;
9466 vstart += aux.vda_next;
9468 eaux = (Elf_External_Verdaux *) vstart;
9469 if (vstart + sizeof (*eaux) > endbuf)
9472 aux.vda_name = BYTE_GET (eaux->vda_name);
9473 aux.vda_next = BYTE_GET (eaux->vda_next);
9475 if (VALID_DYNAMIC_NAME (aux.vda_name))
9476 printf (_(" %#06x: Parent %d: %s\n"),
9477 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9479 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9480 isum, j, aux.vda_name);
9484 printf (_(" Version def aux past end of section\n"));
9486 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9487 if (idx + ent.vd_next <= idx)
9493 if (cnt < section->sh_info)
9494 printf (_(" Version definition past end of section\n"));
9500 case SHT_GNU_verneed:
9502 Elf_External_Verneed * eneed;
9509 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9510 printable_section_name (section), section->sh_info);
9512 printf (_(" Addr: 0x"));
9513 printf_vma (section->sh_addr);
9514 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9515 (unsigned long) section->sh_offset, section->sh_link,
9516 printable_section_name_from_index (section->sh_link));
9518 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9519 section->sh_offset, 1,
9521 _("Version Needs section"));
9524 endbuf = (char *) eneed + section->sh_size;
9526 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9528 Elf_External_Verneed * entry;
9529 Elf_Internal_Verneed ent;
9534 if (idx > (size_t) (endbuf - (char *) eneed))
9537 vstart = ((char *) eneed) + idx;
9538 if (vstart + sizeof (*entry) > endbuf)
9541 entry = (Elf_External_Verneed *) vstart;
9543 ent.vn_version = BYTE_GET (entry->vn_version);
9544 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9545 ent.vn_file = BYTE_GET (entry->vn_file);
9546 ent.vn_aux = BYTE_GET (entry->vn_aux);
9547 ent.vn_next = BYTE_GET (entry->vn_next);
9549 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9551 if (VALID_DYNAMIC_NAME (ent.vn_file))
9552 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9554 printf (_(" File: %lx"), ent.vn_file);
9556 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9558 /* Check for overflow. */
9559 if (ent.vn_aux > (size_t) (endbuf - vstart))
9561 vstart += ent.vn_aux;
9563 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9565 Elf_External_Vernaux * eaux;
9566 Elf_Internal_Vernaux aux;
9568 if (vstart + sizeof (*eaux) > endbuf)
9570 eaux = (Elf_External_Vernaux *) vstart;
9572 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9573 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9574 aux.vna_other = BYTE_GET (eaux->vna_other);
9575 aux.vna_name = BYTE_GET (eaux->vna_name);
9576 aux.vna_next = BYTE_GET (eaux->vna_next);
9578 if (VALID_DYNAMIC_NAME (aux.vna_name))
9579 printf (_(" %#06x: Name: %s"),
9580 isum, GET_DYNAMIC_NAME (aux.vna_name));
9582 printf (_(" %#06x: Name index: %lx"),
9583 isum, aux.vna_name);
9585 printf (_(" Flags: %s Version: %d\n"),
9586 get_ver_flags (aux.vna_flags), aux.vna_other);
9588 /* Check for overflow. */
9589 if (aux.vna_next > (size_t) (endbuf - vstart)
9590 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9592 warn (_("Invalid vna_next field of %lx\n"),
9597 isum += aux.vna_next;
9598 vstart += aux.vna_next;
9602 warn (_("Missing Version Needs auxillary information\n"));
9604 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9606 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9607 cnt = section->sh_info;
9613 if (cnt < section->sh_info)
9614 warn (_("Missing Version Needs information\n"));
9620 case SHT_GNU_versym:
9622 Elf_Internal_Shdr * link_section;
9625 unsigned char * edata;
9626 unsigned short * data;
9628 Elf_Internal_Sym * symbols;
9629 Elf_Internal_Shdr * string_sec;
9630 unsigned long num_syms;
9633 if (section->sh_link >= elf_header.e_shnum)
9636 link_section = section_headers + section->sh_link;
9637 total = section->sh_size / sizeof (Elf_External_Versym);
9639 if (link_section->sh_link >= elf_header.e_shnum)
9644 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9645 if (symbols == NULL)
9648 string_sec = section_headers + link_section->sh_link;
9650 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9651 string_sec->sh_size,
9652 _("version string table"));
9659 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9660 printable_section_name (section), (unsigned long) total);
9662 printf (_(" Addr: "));
9663 printf_vma (section->sh_addr);
9664 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9665 (unsigned long) section->sh_offset, section->sh_link,
9666 printable_section_name (link_section));
9668 off = offset_from_vma (file,
9669 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9670 total * sizeof (short));
9671 edata = (unsigned char *) get_data (NULL, file, off, total,
9673 _("version symbol data"));
9681 data = (short unsigned int *) cmalloc (total, sizeof (short));
9683 for (cnt = total; cnt --;)
9684 data[cnt] = byte_get (edata + cnt * sizeof (short),
9689 for (cnt = 0; cnt < total; cnt += 4)
9692 int check_def, check_need;
9695 printf (" %03x:", cnt);
9697 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9698 switch (data[cnt + j])
9701 fputs (_(" 0 (*local*) "), stdout);
9705 fputs (_(" 1 (*global*) "), stdout);
9709 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9710 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9712 /* If this index value is greater than the size of the symbols
9713 array, break to avoid an out-of-bounds read. */
9714 if ((unsigned long)(cnt + j) >= num_syms)
9716 warn (_("invalid index into symbol array\n"));
9722 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9723 || section_headers[symbols[cnt + j].st_shndx].sh_type
9726 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9733 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9735 Elf_Internal_Verneed ivn;
9736 unsigned long offset;
9738 offset = offset_from_vma
9739 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9740 sizeof (Elf_External_Verneed));
9744 Elf_Internal_Vernaux ivna;
9745 Elf_External_Verneed evn;
9746 Elf_External_Vernaux evna;
9747 unsigned long a_off;
9749 if (get_data (&evn, file, offset, sizeof (evn), 1,
9750 _("version need")) == NULL)
9753 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9754 ivn.vn_next = BYTE_GET (evn.vn_next);
9756 a_off = offset + ivn.vn_aux;
9760 if (get_data (&evna, file, a_off, sizeof (evna),
9761 1, _("version need aux (2)")) == NULL)
9768 ivna.vna_next = BYTE_GET (evna.vna_next);
9769 ivna.vna_other = BYTE_GET (evna.vna_other);
9772 a_off += ivna.vna_next;
9774 while (ivna.vna_other != data[cnt + j]
9775 && ivna.vna_next != 0);
9777 if (ivna.vna_other == data[cnt + j])
9779 ivna.vna_name = BYTE_GET (evna.vna_name);
9781 if (ivna.vna_name >= string_sec->sh_size)
9782 name = _("*invalid*");
9784 name = strtab + ivna.vna_name;
9785 nn += printf ("(%s%-*s",
9787 12 - (int) strlen (name),
9793 offset += ivn.vn_next;
9795 while (ivn.vn_next);
9798 if (check_def && data[cnt + j] != 0x8001
9799 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9801 Elf_Internal_Verdef ivd;
9802 Elf_External_Verdef evd;
9803 unsigned long offset;
9805 offset = offset_from_vma
9806 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9811 if (get_data (&evd, file, offset, sizeof (evd), 1,
9812 _("version def")) == NULL)
9815 /* PR 17531: file: 046-1082287-0.004. */
9816 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9821 ivd.vd_next = BYTE_GET (evd.vd_next);
9822 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9825 offset += ivd.vd_next;
9827 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9828 && ivd.vd_next != 0);
9830 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9832 Elf_External_Verdaux evda;
9833 Elf_Internal_Verdaux ivda;
9835 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9837 if (get_data (&evda, file,
9838 offset - ivd.vd_next + ivd.vd_aux,
9840 _("version def aux")) == NULL)
9843 ivda.vda_name = BYTE_GET (evda.vda_name);
9845 if (ivda.vda_name >= string_sec->sh_size)
9846 name = _("*invalid*");
9848 name = strtab + ivda.vda_name;
9849 nn += printf ("(%s%-*s",
9851 12 - (int) strlen (name),
9857 printf ("%*c", 18 - nn, ' ');
9875 printf (_("\nNo version information found in this file.\n"));
9881 get_symbol_binding (unsigned int binding)
9883 static char buff[32];
9887 case STB_LOCAL: return "LOCAL";
9888 case STB_GLOBAL: return "GLOBAL";
9889 case STB_WEAK: return "WEAK";
9891 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9892 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9894 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9896 if (binding == STB_GNU_UNIQUE
9897 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9898 /* GNU is still using the default value 0. */
9899 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9901 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9904 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9910 get_symbol_type (unsigned int type)
9912 static char buff[32];
9916 case STT_NOTYPE: return "NOTYPE";
9917 case STT_OBJECT: return "OBJECT";
9918 case STT_FUNC: return "FUNC";
9919 case STT_SECTION: return "SECTION";
9920 case STT_FILE: return "FILE";
9921 case STT_COMMON: return "COMMON";
9922 case STT_TLS: return "TLS";
9923 case STT_RELC: return "RELC";
9924 case STT_SRELC: return "SRELC";
9926 if (type >= STT_LOPROC && type <= STT_HIPROC)
9928 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9929 return "THUMB_FUNC";
9931 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9934 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9935 return "PARISC_MILLI";
9937 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9939 else if (type >= STT_LOOS && type <= STT_HIOS)
9941 if (elf_header.e_machine == EM_PARISC)
9943 if (type == STT_HP_OPAQUE)
9945 if (type == STT_HP_STUB)
9949 if (type == STT_GNU_IFUNC
9950 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9951 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9952 /* GNU is still using the default value 0. */
9953 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9956 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9959 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9965 get_symbol_visibility (unsigned int visibility)
9969 case STV_DEFAULT: return "DEFAULT";
9970 case STV_INTERNAL: return "INTERNAL";
9971 case STV_HIDDEN: return "HIDDEN";
9972 case STV_PROTECTED: return "PROTECTED";
9974 error (_("Unrecognized visibility value: %u"), visibility);
9975 return _("<unknown>");
9980 get_mips_symbol_other (unsigned int other)
9992 case STO_MICROMIPS | STO_MIPS_PIC:
9993 return "MICROMIPS, MIPS PIC";
10001 static const char *
10002 get_ia64_symbol_other (unsigned int other)
10004 if (is_ia64_vms ())
10006 static char res[32];
10010 /* Function types is for images and .STB files only. */
10011 switch (elf_header.e_type)
10015 switch (VMS_ST_FUNC_TYPE (other))
10017 case VMS_SFT_CODE_ADDR:
10018 strcat (res, " CA");
10020 case VMS_SFT_SYMV_IDX:
10021 strcat (res, " VEC");
10024 strcat (res, " FD");
10026 case VMS_SFT_RESERVE:
10027 strcat (res, " RSV");
10030 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10031 VMS_ST_FUNC_TYPE (other));
10032 strcat (res, " <unknown>");
10039 switch (VMS_ST_LINKAGE (other))
10041 case VMS_STL_IGNORE:
10042 strcat (res, " IGN");
10044 case VMS_STL_RESERVE:
10045 strcat (res, " RSV");
10048 strcat (res, " STD");
10051 strcat (res, " LNK");
10054 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10055 VMS_ST_LINKAGE (other));
10056 strcat (res, " <unknown>");
10068 static const char *
10069 get_ppc64_symbol_other (unsigned int other)
10071 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10073 static char buf[32];
10074 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10075 PPC64_LOCAL_ENTRY_OFFSET (other));
10081 static const char *
10082 get_symbol_other (unsigned int other)
10084 const char * result = NULL;
10085 static char buff [32];
10090 switch (elf_header.e_machine)
10093 result = get_mips_symbol_other (other);
10096 result = get_ia64_symbol_other (other);
10099 result = get_ppc64_symbol_other (other);
10108 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10112 static const char *
10113 get_symbol_index_type (unsigned int type)
10115 static char buff[32];
10119 case SHN_UNDEF: return "UND";
10120 case SHN_ABS: return "ABS";
10121 case SHN_COMMON: return "COM";
10123 if (type == SHN_IA_64_ANSI_COMMON
10124 && elf_header.e_machine == EM_IA_64
10125 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10127 else if ((elf_header.e_machine == EM_X86_64
10128 || elf_header.e_machine == EM_L1OM
10129 || elf_header.e_machine == EM_K1OM)
10130 && type == SHN_X86_64_LCOMMON)
10131 return "LARGE_COM";
10132 else if ((type == SHN_MIPS_SCOMMON
10133 && elf_header.e_machine == EM_MIPS)
10134 || (type == SHN_TIC6X_SCOMMON
10135 && elf_header.e_machine == EM_TI_C6000))
10137 else if (type == SHN_MIPS_SUNDEFINED
10138 && elf_header.e_machine == EM_MIPS)
10140 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10141 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10142 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10143 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10144 else if (type >= SHN_LORESERVE)
10145 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10146 else if (type >= elf_header.e_shnum)
10147 sprintf (buff, _("bad section index[%3d]"), type);
10149 sprintf (buff, "%3d", type);
10157 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10159 unsigned char * e_data;
10162 /* If the size_t type is smaller than the bfd_size_type, eg because
10163 you are building a 32-bit tool on a 64-bit host, then make sure
10164 that when (number) is cast to (size_t) no information is lost. */
10165 if (sizeof (size_t) < sizeof (bfd_size_type)
10166 && (bfd_size_type) ((size_t) number) != number)
10168 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10169 (unsigned long long) number, ent_size);
10173 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10174 attempting to allocate memory when the read is bound to fail. */
10175 if (ent_size * number > current_file_size)
10177 error (_("Invalid number of dynamic entries: %llu\n"),
10178 (unsigned long long) number);
10182 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10183 if (e_data == NULL)
10185 error (_("Out of memory reading %llu dynamic entries\n"),
10186 (unsigned long long) number);
10190 if (fread (e_data, ent_size, (size_t) number, file) != number)
10192 error (_("Unable to read in %llu bytes of dynamic data\n"),
10193 (unsigned long long) (number * ent_size));
10198 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10199 if (i_data == NULL)
10201 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10202 (unsigned long long) number);
10208 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10216 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10218 Elf_Internal_Sym * psym;
10221 n = print_vma (si, DEC_5);
10223 fputs (&" "[n], stdout);
10224 printf (" %3lu: ", hn);
10226 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10228 printf (_("<No info available for dynamic symbol number %lu>\n"),
10229 (unsigned long) si);
10233 psym = dynamic_symbols + si;
10234 print_vma (psym->st_value, LONG_HEX);
10236 print_vma (psym->st_size, DEC_5);
10238 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10239 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10240 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10241 /* Check to see if any other bits in the st_other field are set.
10242 Note - displaying this information disrupts the layout of the
10243 table being generated, but for the moment this case is very
10245 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10246 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10247 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10248 if (VALID_DYNAMIC_NAME (psym->st_name))
10249 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10251 printf (_(" <corrupt: %14ld>"), psym->st_name);
10255 static const char *
10256 get_symbol_version_string (FILE *file, int is_dynsym,
10257 const char *strtab,
10258 unsigned long int strtab_size,
10259 unsigned int si, Elf_Internal_Sym *psym,
10260 enum versioned_symbol_info *sym_info,
10261 unsigned short *vna_other)
10263 const char *version_string = NULL;
10266 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10268 unsigned char data[2];
10269 unsigned short vers_data;
10270 unsigned long offset;
10274 offset = offset_from_vma
10275 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10276 sizeof data + si * sizeof (vers_data));
10278 if (get_data (&data, file, offset + si * sizeof (vers_data),
10279 sizeof (data), 1, _("version data")) == NULL)
10282 vers_data = byte_get (data, 2);
10284 is_nobits = (section_headers != NULL
10285 && psym->st_shndx < elf_header.e_shnum
10286 && section_headers[psym->st_shndx].sh_type
10289 check_def = (psym->st_shndx != SHN_UNDEF);
10291 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10293 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10294 && (is_nobits || ! check_def))
10296 Elf_External_Verneed evn;
10297 Elf_Internal_Verneed ivn;
10298 Elf_Internal_Vernaux ivna;
10300 /* We must test both. */
10301 offset = offset_from_vma
10302 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10307 unsigned long vna_off;
10309 if (get_data (&evn, file, offset, sizeof (evn), 1,
10310 _("version need")) == NULL)
10313 ivna.vna_other = 0;
10318 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10319 ivn.vn_next = BYTE_GET (evn.vn_next);
10321 vna_off = offset + ivn.vn_aux;
10325 Elf_External_Vernaux evna;
10327 if (get_data (&evna, file, vna_off,
10329 _("version need aux (3)")) == NULL)
10332 ivna.vna_other = 0;
10337 ivna.vna_other = BYTE_GET (evna.vna_other);
10338 ivna.vna_next = BYTE_GET (evna.vna_next);
10339 ivna.vna_name = BYTE_GET (evna.vna_name);
10342 vna_off += ivna.vna_next;
10344 while (ivna.vna_other != vers_data
10345 && ivna.vna_next != 0);
10347 if (ivna.vna_other == vers_data)
10350 offset += ivn.vn_next;
10352 while (ivn.vn_next != 0);
10354 if (ivna.vna_other == vers_data)
10356 *sym_info = symbol_undefined;
10357 *vna_other = ivna.vna_other;
10358 version_string = (ivna.vna_name < strtab_size
10359 ? strtab + ivna.vna_name
10363 else if (! is_nobits)
10364 error (_("bad dynamic symbol\n"));
10371 if (vers_data != 0x8001
10372 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10374 Elf_Internal_Verdef ivd;
10375 Elf_Internal_Verdaux ivda;
10376 Elf_External_Verdaux evda;
10379 off = offset_from_vma
10381 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10382 sizeof (Elf_External_Verdef));
10386 Elf_External_Verdef evd;
10388 if (get_data (&evd, file, off, sizeof (evd),
10389 1, _("version def")) == NULL)
10397 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10398 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10399 ivd.vd_next = BYTE_GET (evd.vd_next);
10402 off += ivd.vd_next;
10404 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10405 && ivd.vd_next != 0);
10407 off -= ivd.vd_next;
10410 if (get_data (&evda, file, off, sizeof (evda),
10411 1, _("version def aux")) == NULL)
10412 return version_string;
10414 ivda.vda_name = BYTE_GET (evda.vda_name);
10416 if (psym->st_name != ivda.vda_name)
10418 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10419 ? symbol_hidden : symbol_public);
10420 version_string = (ivda.vda_name < strtab_size
10421 ? strtab + ivda.vda_name
10428 return version_string;
10431 /* Dump the symbol table. */
10433 process_symbol_table (FILE * file)
10435 Elf_Internal_Shdr * section;
10436 bfd_size_type nbuckets = 0;
10437 bfd_size_type nchains = 0;
10438 bfd_vma * buckets = NULL;
10439 bfd_vma * chains = NULL;
10440 bfd_vma ngnubuckets = 0;
10441 bfd_vma * gnubuckets = NULL;
10442 bfd_vma * gnuchains = NULL;
10443 bfd_vma gnusymidx = 0;
10444 bfd_size_type ngnuchains = 0;
10446 if (!do_syms && !do_dyn_syms && !do_histogram)
10449 if (dynamic_info[DT_HASH]
10451 || (do_using_dynamic
10453 && dynamic_strings != NULL)))
10455 unsigned char nb[8];
10456 unsigned char nc[8];
10457 unsigned int hash_ent_size = 4;
10459 if ((elf_header.e_machine == EM_ALPHA
10460 || elf_header.e_machine == EM_S390
10461 || elf_header.e_machine == EM_S390_OLD)
10462 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10466 (archive_file_offset
10467 + offset_from_vma (file, dynamic_info[DT_HASH],
10468 sizeof nb + sizeof nc)),
10471 error (_("Unable to seek to start of dynamic information\n"));
10475 if (fread (nb, hash_ent_size, 1, file) != 1)
10477 error (_("Failed to read in number of buckets\n"));
10481 if (fread (nc, hash_ent_size, 1, file) != 1)
10483 error (_("Failed to read in number of chains\n"));
10487 nbuckets = byte_get (nb, hash_ent_size);
10488 nchains = byte_get (nc, hash_ent_size);
10490 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10491 chains = get_dynamic_data (file, nchains, hash_ent_size);
10494 if (buckets == NULL || chains == NULL)
10496 if (do_using_dynamic)
10507 if (dynamic_info_DT_GNU_HASH
10509 || (do_using_dynamic
10511 && dynamic_strings != NULL)))
10513 unsigned char nb[16];
10514 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10515 bfd_vma buckets_vma;
10518 (archive_file_offset
10519 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10523 error (_("Unable to seek to start of dynamic information\n"));
10527 if (fread (nb, 16, 1, file) != 1)
10529 error (_("Failed to read in number of buckets\n"));
10533 ngnubuckets = byte_get (nb, 4);
10534 gnusymidx = byte_get (nb + 4, 4);
10535 bitmaskwords = byte_get (nb + 8, 4);
10536 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10538 buckets_vma += bitmaskwords * 4;
10540 buckets_vma += bitmaskwords * 8;
10543 (archive_file_offset
10544 + offset_from_vma (file, buckets_vma, 4)),
10547 error (_("Unable to seek to start of dynamic information\n"));
10551 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10553 if (gnubuckets == NULL)
10556 for (i = 0; i < ngnubuckets; i++)
10557 if (gnubuckets[i] != 0)
10559 if (gnubuckets[i] < gnusymidx)
10562 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10563 maxchain = gnubuckets[i];
10566 if (maxchain == 0xffffffff)
10569 maxchain -= gnusymidx;
10572 (archive_file_offset
10573 + offset_from_vma (file, buckets_vma
10574 + 4 * (ngnubuckets + maxchain), 4)),
10577 error (_("Unable to seek to start of dynamic information\n"));
10583 if (fread (nb, 4, 1, file) != 1)
10585 error (_("Failed to determine last chain length\n"));
10589 if (maxchain + 1 == 0)
10594 while ((byte_get (nb, 4) & 1) == 0);
10597 (archive_file_offset
10598 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10601 error (_("Unable to seek to start of dynamic information\n"));
10605 gnuchains = get_dynamic_data (file, maxchain, 4);
10606 ngnuchains = maxchain;
10609 if (gnuchains == NULL)
10614 if (do_using_dynamic)
10619 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10621 && do_using_dynamic
10622 && dynamic_strings != NULL
10623 && dynamic_symbols != NULL)
10627 if (dynamic_info[DT_HASH])
10631 printf (_("\nSymbol table for image:\n"));
10633 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10635 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10637 for (hn = 0; hn < nbuckets; hn++)
10642 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10643 print_dynamic_symbol (si, hn);
10647 if (dynamic_info_DT_GNU_HASH)
10649 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10651 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10653 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10655 for (hn = 0; hn < ngnubuckets; ++hn)
10656 if (gnubuckets[hn] != 0)
10658 bfd_vma si = gnubuckets[hn];
10659 bfd_vma off = si - gnusymidx;
10663 print_dynamic_symbol (si, hn);
10666 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10670 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10671 && section_headers != NULL)
10675 for (i = 0, section = section_headers;
10676 i < elf_header.e_shnum;
10680 char * strtab = NULL;
10681 unsigned long int strtab_size = 0;
10682 Elf_Internal_Sym * symtab;
10683 Elf_Internal_Sym * psym;
10684 unsigned long num_syms;
10686 if ((section->sh_type != SHT_SYMTAB
10687 && section->sh_type != SHT_DYNSYM)
10689 && section->sh_type == SHT_SYMTAB))
10692 if (section->sh_entsize == 0)
10694 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10695 printable_section_name (section));
10699 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10700 printable_section_name (section),
10701 (unsigned long) (section->sh_size / section->sh_entsize));
10704 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10706 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10708 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10709 if (symtab == NULL)
10712 if (section->sh_link == elf_header.e_shstrndx)
10714 strtab = string_table;
10715 strtab_size = string_table_length;
10717 else if (section->sh_link < elf_header.e_shnum)
10719 Elf_Internal_Shdr * string_sec;
10721 string_sec = section_headers + section->sh_link;
10723 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10724 1, string_sec->sh_size,
10725 _("string table"));
10726 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10729 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10731 const char *version_string;
10732 enum versioned_symbol_info sym_info;
10733 unsigned short vna_other;
10735 printf ("%6d: ", si);
10736 print_vma (psym->st_value, LONG_HEX);
10738 print_vma (psym->st_size, DEC_5);
10739 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10740 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10741 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10742 /* Check to see if any other bits in the st_other field are set.
10743 Note - displaying this information disrupts the layout of the
10744 table being generated, but for the moment this case is very rare. */
10745 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10746 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10747 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10748 print_symbol (25, psym->st_name < strtab_size
10749 ? strtab + psym->st_name : _("<corrupt>"));
10752 = get_symbol_version_string (file,
10753 section->sh_type == SHT_DYNSYM,
10754 strtab, strtab_size, si,
10755 psym, &sym_info, &vna_other);
10756 if (version_string)
10758 if (sym_info == symbol_undefined)
10759 printf ("@%s (%d)", version_string, vna_other);
10761 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10769 if (strtab != string_table)
10775 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10777 if (do_histogram && buckets != NULL)
10779 unsigned long * lengths;
10780 unsigned long * counts;
10783 unsigned long maxlength = 0;
10784 unsigned long nzero_counts = 0;
10785 unsigned long nsyms = 0;
10787 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10788 (unsigned long) nbuckets);
10790 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10791 if (lengths == NULL)
10793 error (_("Out of memory allocating space for histogram buckets\n"));
10797 printf (_(" Length Number %% of total Coverage\n"));
10798 for (hn = 0; hn < nbuckets; ++hn)
10800 for (si = buckets[hn]; si > 0 && si < nchains && si < nbuckets; si = chains[si])
10803 if (maxlength < ++lengths[hn])
10806 /* PR binutils/17531: A corrupt binary could contain broken
10807 histogram data. Do not go into an infinite loop trying
10809 if (chains[si] == si)
10811 error (_("histogram chain links to itself\n"));
10817 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10818 if (counts == NULL)
10821 error (_("Out of memory allocating space for histogram counts\n"));
10825 for (hn = 0; hn < nbuckets; ++hn)
10826 ++counts[lengths[hn]];
10831 printf (" 0 %-10lu (%5.1f%%)\n",
10832 counts[0], (counts[0] * 100.0) / nbuckets);
10833 for (i = 1; i <= maxlength; ++i)
10835 nzero_counts += counts[i] * i;
10836 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10837 i, counts[i], (counts[i] * 100.0) / nbuckets,
10838 (nzero_counts * 100.0) / nsyms);
10846 if (buckets != NULL)
10852 if (do_histogram && gnubuckets != NULL)
10854 unsigned long * lengths;
10855 unsigned long * counts;
10857 unsigned long maxlength = 0;
10858 unsigned long nzero_counts = 0;
10859 unsigned long nsyms = 0;
10861 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10862 (unsigned long) ngnubuckets);
10864 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10865 if (lengths == NULL)
10867 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10871 printf (_(" Length Number %% of total Coverage\n"));
10873 for (hn = 0; hn < ngnubuckets; ++hn)
10874 if (gnubuckets[hn] != 0)
10876 bfd_vma off, length = 1;
10878 for (off = gnubuckets[hn] - gnusymidx;
10879 /* PR 17531 file: 010-77222-0.004. */
10880 off < ngnuchains && (gnuchains[off] & 1) == 0;
10883 lengths[hn] = length;
10884 if (length > maxlength)
10885 maxlength = length;
10889 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10890 if (counts == NULL)
10893 error (_("Out of memory allocating space for gnu histogram counts\n"));
10897 for (hn = 0; hn < ngnubuckets; ++hn)
10898 ++counts[lengths[hn]];
10900 if (ngnubuckets > 0)
10903 printf (" 0 %-10lu (%5.1f%%)\n",
10904 counts[0], (counts[0] * 100.0) / ngnubuckets);
10905 for (j = 1; j <= maxlength; ++j)
10907 nzero_counts += counts[j] * j;
10908 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10909 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10910 (nzero_counts * 100.0) / nsyms);
10924 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10928 if (dynamic_syminfo == NULL
10930 /* No syminfo, this is ok. */
10933 /* There better should be a dynamic symbol section. */
10934 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10938 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10939 dynamic_syminfo_offset, dynamic_syminfo_nent);
10941 printf (_(" Num: Name BoundTo Flags\n"));
10942 for (i = 0; i < dynamic_syminfo_nent; ++i)
10944 unsigned short int flags = dynamic_syminfo[i].si_flags;
10946 printf ("%4d: ", i);
10947 if (i >= num_dynamic_syms)
10948 printf (_("<corrupt index>"));
10949 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10950 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10952 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10955 switch (dynamic_syminfo[i].si_boundto)
10957 case SYMINFO_BT_SELF:
10958 fputs ("SELF ", stdout);
10960 case SYMINFO_BT_PARENT:
10961 fputs ("PARENT ", stdout);
10964 if (dynamic_syminfo[i].si_boundto > 0
10965 && dynamic_syminfo[i].si_boundto < dynamic_nent
10966 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10968 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10972 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10976 if (flags & SYMINFO_FLG_DIRECT)
10977 printf (" DIRECT");
10978 if (flags & SYMINFO_FLG_PASSTHRU)
10979 printf (" PASSTHRU");
10980 if (flags & SYMINFO_FLG_COPY)
10982 if (flags & SYMINFO_FLG_LAZYLOAD)
10983 printf (" LAZYLOAD");
10991 /* Check to see if the given reloc needs to be handled in a target specific
10992 manner. If so then process the reloc and return TRUE otherwise return
10996 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10997 unsigned char * start,
10998 Elf_Internal_Sym * symtab)
11000 unsigned int reloc_type = get_reloc_type (reloc->r_info);
11002 switch (elf_header.e_machine)
11005 case EM_MSP430_OLD:
11007 static Elf_Internal_Sym * saved_sym = NULL;
11009 switch (reloc_type)
11011 case 10: /* R_MSP430_SYM_DIFF */
11012 if (uses_msp430x_relocs ())
11014 case 21: /* R_MSP430X_SYM_DIFF */
11015 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11018 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11019 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11020 goto handle_sym_diff;
11022 case 5: /* R_MSP430_16_BYTE */
11023 case 9: /* R_MSP430_8 */
11024 if (uses_msp430x_relocs ())
11026 goto handle_sym_diff;
11028 case 2: /* R_MSP430_ABS16 */
11029 case 15: /* R_MSP430X_ABS16 */
11030 if (! uses_msp430x_relocs ())
11032 goto handle_sym_diff;
11035 if (saved_sym != NULL)
11039 value = reloc->r_addend
11040 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11041 - saved_sym->st_value);
11043 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11051 if (saved_sym != NULL)
11052 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11059 case EM_CYGNUS_MN10300:
11061 static Elf_Internal_Sym * saved_sym = NULL;
11063 switch (reloc_type)
11065 case 34: /* R_MN10300_ALIGN */
11067 case 33: /* R_MN10300_SYM_DIFF */
11068 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11070 case 1: /* R_MN10300_32 */
11071 case 2: /* R_MN10300_16 */
11072 if (saved_sym != NULL)
11076 value = reloc->r_addend
11077 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11078 - saved_sym->st_value);
11080 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11087 if (saved_sym != NULL)
11088 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11098 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11099 DWARF debug sections. This is a target specific test. Note - we do not
11100 go through the whole including-target-headers-multiple-times route, (as
11101 we have already done with <elf/h8.h>) because this would become very
11102 messy and even then this function would have to contain target specific
11103 information (the names of the relocs instead of their numeric values).
11104 FIXME: This is not the correct way to solve this problem. The proper way
11105 is to have target specific reloc sizing and typing functions created by
11106 the reloc-macros.h header, in the same way that it already creates the
11107 reloc naming functions. */
11110 is_32bit_abs_reloc (unsigned int reloc_type)
11112 switch (elf_header.e_machine)
11116 return reloc_type == 1; /* R_386_32. */
11118 return reloc_type == 1; /* R_68K_32. */
11120 return reloc_type == 1; /* R_860_32. */
11122 return reloc_type == 2; /* R_960_32. */
11124 return reloc_type == 258; /* R_AARCH64_ABS32 */
11126 return reloc_type == 1; /* R_ALPHA_REFLONG. */
11128 return reloc_type == 1; /* R_ARC_32. */
11130 return reloc_type == 2; /* R_ARM_ABS32 */
11133 return reloc_type == 1;
11134 case EM_ADAPTEVA_EPIPHANY:
11135 return reloc_type == 3;
11137 return reloc_type == 0x12; /* R_byte4_data. */
11139 return reloc_type == 3; /* R_CRIS_32. */
11141 return reloc_type == 3; /* R_CR16_NUM32. */
11143 return reloc_type == 15; /* R_CRX_NUM32. */
11144 case EM_CYGNUS_FRV:
11145 return reloc_type == 1;
11146 case EM_CYGNUS_D10V:
11148 return reloc_type == 6; /* R_D10V_32. */
11149 case EM_CYGNUS_D30V:
11151 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11153 return reloc_type == 3; /* R_DLX_RELOC_32. */
11154 case EM_CYGNUS_FR30:
11156 return reloc_type == 3; /* R_FR30_32. */
11158 return reloc_type == 1; /* R_FT32_32. */
11162 return reloc_type == 1; /* R_H8_DIR32. */
11164 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
11167 return reloc_type == 2; /* R_IP2K_32. */
11169 return reloc_type == 2; /* R_IQ2000_32. */
11170 case EM_LATTICEMICO32:
11171 return reloc_type == 3; /* R_LM32_32. */
11174 return reloc_type == 3; /* R_M32C_32. */
11176 return reloc_type == 34; /* R_M32R_32_RELA. */
11178 return reloc_type == 1; /* R_MCORE_ADDR32. */
11179 case EM_CYGNUS_MEP:
11180 return reloc_type == 4; /* R_MEP_32. */
11182 return reloc_type == 2; /* R_METAG_ADDR32. */
11183 case EM_MICROBLAZE:
11184 return reloc_type == 1; /* R_MICROBLAZE_32. */
11186 return reloc_type == 2; /* R_MIPS_32. */
11188 return reloc_type == 4; /* R_MMIX_32. */
11189 case EM_CYGNUS_MN10200:
11191 return reloc_type == 1; /* R_MN10200_32. */
11192 case EM_CYGNUS_MN10300:
11194 return reloc_type == 1; /* R_MN10300_32. */
11196 return reloc_type == 1; /* R_MOXIE_32. */
11197 case EM_MSP430_OLD:
11199 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11201 return reloc_type == 2; /* R_MT_32. */
11203 return reloc_type == 20; /* R_NDS32_RELA. */
11204 case EM_ALTERA_NIOS2:
11205 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
11207 return reloc_type == 1; /* R_NIOS_32. */
11209 return reloc_type == 1; /* R_OR1K_32. */
11211 return (reloc_type == 1 /* R_PARISC_DIR32. */
11212 || reloc_type == 41); /* R_PARISC_SECREL32. */
11215 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11217 return reloc_type == 1; /* R_PPC64_ADDR32. */
11219 return reloc_type == 1; /* R_PPC_ADDR32. */
11221 return reloc_type == 1; /* R_RL78_DIR32. */
11223 return reloc_type == 1; /* R_RX_DIR32. */
11225 return reloc_type == 1; /* R_I370_ADDR31. */
11228 return reloc_type == 4; /* R_S390_32. */
11230 return reloc_type == 8; /* R_SCORE_ABS32. */
11232 return reloc_type == 1; /* R_SH_DIR32. */
11233 case EM_SPARC32PLUS:
11236 return reloc_type == 3 /* R_SPARC_32. */
11237 || reloc_type == 23; /* R_SPARC_UA32. */
11239 return reloc_type == 6; /* R_SPU_ADDR32 */
11241 return reloc_type == 1; /* R_C6000_ABS32. */
11243 return reloc_type == 2; /* R_TILEGX_32. */
11245 return reloc_type == 1; /* R_TILEPRO_32. */
11246 case EM_CYGNUS_V850:
11248 return reloc_type == 6; /* R_V850_ABS32. */
11250 return reloc_type == 0x33; /* R_V810_WORD. */
11252 return reloc_type == 1; /* R_VAX_32. */
11254 return reloc_type == 3; /* R_VISIUM_32. */
11258 return reloc_type == 10; /* R_X86_64_32. */
11261 return reloc_type == 3; /* R_XC16C_ABS_32. */
11263 return reloc_type == 4; /* R_XGATE_32. */
11265 return reloc_type == 1; /* R_XSTROMY16_32. */
11266 case EM_XTENSA_OLD:
11268 return reloc_type == 1; /* R_XTENSA_32. */
11271 static unsigned int prev_warn = 0;
11273 /* Avoid repeating the same warning multiple times. */
11274 if (prev_warn != elf_header.e_machine)
11275 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11276 elf_header.e_machine);
11277 prev_warn = elf_header.e_machine;
11283 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11284 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11287 is_32bit_pcrel_reloc (unsigned int reloc_type)
11289 switch (elf_header.e_machine)
11293 return reloc_type == 2; /* R_386_PC32. */
11295 return reloc_type == 4; /* R_68K_PC32. */
11297 return reloc_type == 261; /* R_AARCH64_PREL32 */
11298 case EM_ADAPTEVA_EPIPHANY:
11299 return reloc_type == 6;
11301 return reloc_type == 10; /* R_ALPHA_SREL32. */
11303 return reloc_type == 3; /* R_ARM_REL32 */
11304 case EM_MICROBLAZE:
11305 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11307 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11309 return reloc_type == 9; /* R_PARISC_PCREL32. */
11311 return reloc_type == 26; /* R_PPC_REL32. */
11313 return reloc_type == 26; /* R_PPC64_REL32. */
11316 return reloc_type == 5; /* R_390_PC32. */
11318 return reloc_type == 2; /* R_SH_REL32. */
11319 case EM_SPARC32PLUS:
11322 return reloc_type == 6; /* R_SPARC_DISP32. */
11324 return reloc_type == 13; /* R_SPU_REL32. */
11326 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11328 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11330 return reloc_type == 6; /* R_VISIUM_32_PCREL */
11334 return reloc_type == 2; /* R_X86_64_PC32. */
11335 case EM_XTENSA_OLD:
11337 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11339 /* Do not abort or issue an error message here. Not all targets use
11340 pc-relative 32-bit relocs in their DWARF debug information and we
11341 have already tested for target coverage in is_32bit_abs_reloc. A
11342 more helpful warning message will be generated by apply_relocations
11343 anyway, so just return. */
11348 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11349 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11352 is_64bit_abs_reloc (unsigned int reloc_type)
11354 switch (elf_header.e_machine)
11357 return reloc_type == 257; /* R_AARCH64_ABS64. */
11359 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11361 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11363 return reloc_type == 80; /* R_PARISC_DIR64. */
11365 return reloc_type == 38; /* R_PPC64_ADDR64. */
11366 case EM_SPARC32PLUS:
11369 return reloc_type == 54; /* R_SPARC_UA64. */
11373 return reloc_type == 1; /* R_X86_64_64. */
11376 return reloc_type == 22; /* R_S390_64. */
11378 return reloc_type == 1; /* R_TILEGX_64. */
11380 return reloc_type == 18; /* R_MIPS_64. */
11386 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11387 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11390 is_64bit_pcrel_reloc (unsigned int reloc_type)
11392 switch (elf_header.e_machine)
11395 return reloc_type == 260; /* R_AARCH64_PREL64. */
11397 return reloc_type == 11; /* R_ALPHA_SREL64. */
11399 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11401 return reloc_type == 72; /* R_PARISC_PCREL64. */
11403 return reloc_type == 44; /* R_PPC64_REL64. */
11404 case EM_SPARC32PLUS:
11407 return reloc_type == 46; /* R_SPARC_DISP64. */
11411 return reloc_type == 24; /* R_X86_64_PC64. */
11414 return reloc_type == 23; /* R_S390_PC64. */
11416 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11422 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11423 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11426 is_24bit_abs_reloc (unsigned int reloc_type)
11428 switch (elf_header.e_machine)
11430 case EM_CYGNUS_MN10200:
11432 return reloc_type == 4; /* R_MN10200_24. */
11438 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11439 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11442 is_16bit_abs_reloc (unsigned int reloc_type)
11444 switch (elf_header.e_machine)
11448 return reloc_type == 4; /* R_AVR_16. */
11449 case EM_ADAPTEVA_EPIPHANY:
11450 return reloc_type == 5;
11451 case EM_CYGNUS_D10V:
11453 return reloc_type == 3; /* R_D10V_16. */
11457 return reloc_type == R_H8_DIR16;
11460 return reloc_type == 1; /* R_IP2K_16. */
11463 return reloc_type == 1; /* R_M32C_16 */
11465 if (uses_msp430x_relocs ())
11466 return reloc_type == 2; /* R_MSP430_ABS16. */
11467 case EM_MSP430_OLD:
11468 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11470 return reloc_type == 19; /* R_NDS32_RELA. */
11471 case EM_ALTERA_NIOS2:
11472 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11474 return reloc_type == 9; /* R_NIOS_16. */
11476 return reloc_type == 2; /* R_OR1K_16. */
11478 return reloc_type == 2; /* R_C6000_ABS16. */
11481 return reloc_type == 2; /* R_XC16C_ABS_16. */
11482 case EM_CYGNUS_MN10200:
11484 return reloc_type == 2; /* R_MN10200_16. */
11485 case EM_CYGNUS_MN10300:
11487 return reloc_type == 2; /* R_MN10300_16. */
11489 return reloc_type == 2; /* R_VISIUM_16. */
11491 return reloc_type == 3; /* R_XGATE_16. */
11497 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11498 relocation entries (possibly formerly used for SHT_GROUP sections). */
11501 is_none_reloc (unsigned int reloc_type)
11503 switch (elf_header.e_machine)
11505 case EM_68K: /* R_68K_NONE. */
11506 case EM_386: /* R_386_NONE. */
11507 case EM_SPARC32PLUS:
11509 case EM_SPARC: /* R_SPARC_NONE. */
11510 case EM_MIPS: /* R_MIPS_NONE. */
11511 case EM_PARISC: /* R_PARISC_NONE. */
11512 case EM_ALPHA: /* R_ALPHA_NONE. */
11513 case EM_ADAPTEVA_EPIPHANY:
11514 case EM_PPC: /* R_PPC_NONE. */
11515 case EM_PPC64: /* R_PPC64_NONE. */
11516 case EM_ARM: /* R_ARM_NONE. */
11517 case EM_IA_64: /* R_IA64_NONE. */
11518 case EM_SH: /* R_SH_NONE. */
11520 case EM_S390: /* R_390_NONE. */
11521 case EM_CRIS: /* R_CRIS_NONE. */
11522 case EM_X86_64: /* R_X86_64_NONE. */
11523 case EM_L1OM: /* R_X86_64_NONE. */
11524 case EM_K1OM: /* R_X86_64_NONE. */
11525 case EM_MN10300: /* R_MN10300_NONE. */
11526 case EM_FT32: /* R_FT32_NONE. */
11527 case EM_MOXIE: /* R_MOXIE_NONE. */
11528 case EM_M32R: /* R_M32R_NONE. */
11529 case EM_TI_C6000:/* R_C6000_NONE. */
11530 case EM_TILEGX: /* R_TILEGX_NONE. */
11531 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11533 case EM_C166: /* R_XC16X_NONE. */
11534 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11535 case EM_NIOS32: /* R_NIOS_NONE. */
11536 case EM_OR1K: /* R_OR1K_NONE. */
11537 return reloc_type == 0;
11539 return reloc_type == 0 || reloc_type == 256;
11541 return (reloc_type == 0 /* R_XTENSA_NONE. */
11542 || reloc_type == 204 /* R_NDS32_DIFF8. */
11543 || reloc_type == 205 /* R_NDS32_DIFF16. */
11544 || reloc_type == 206 /* R_NDS32_DIFF32. */
11545 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11546 case EM_XTENSA_OLD:
11548 return (reloc_type == 0 /* R_XTENSA_NONE. */
11549 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11550 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11551 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11553 return reloc_type == 3; /* R_METAG_NONE. */
11558 /* Apply relocations to a section.
11559 Note: So far support has been added only for those relocations
11560 which can be found in debug sections.
11561 FIXME: Add support for more relocations ? */
11564 apply_relocations (void * file,
11565 Elf_Internal_Shdr * section,
11566 unsigned char * start)
11568 Elf_Internal_Shdr * relsec;
11569 unsigned char * end = start + section->sh_size;
11571 if (elf_header.e_type != ET_REL)
11574 /* Find the reloc section associated with the section. */
11575 for (relsec = section_headers;
11576 relsec < section_headers + elf_header.e_shnum;
11579 bfd_boolean is_rela;
11580 unsigned long num_relocs;
11581 Elf_Internal_Rela * relocs;
11582 Elf_Internal_Rela * rp;
11583 Elf_Internal_Shdr * symsec;
11584 Elf_Internal_Sym * symtab;
11585 unsigned long num_syms;
11586 Elf_Internal_Sym * sym;
11588 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11589 || relsec->sh_info >= elf_header.e_shnum
11590 || section_headers + relsec->sh_info != section
11591 || relsec->sh_size == 0
11592 || relsec->sh_link >= elf_header.e_shnum)
11595 is_rela = relsec->sh_type == SHT_RELA;
11599 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11600 relsec->sh_size, & relocs, & num_relocs))
11605 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11606 relsec->sh_size, & relocs, & num_relocs))
11610 /* SH uses RELA but uses in place value instead of the addend field. */
11611 if (elf_header.e_machine == EM_SH)
11614 symsec = section_headers + relsec->sh_link;
11615 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11617 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11620 unsigned int reloc_type;
11621 unsigned int reloc_size;
11622 unsigned char * rloc;
11623 unsigned long sym_index;
11625 reloc_type = get_reloc_type (rp->r_info);
11627 if (target_specific_reloc_handling (rp, start, symtab))
11629 else if (is_none_reloc (reloc_type))
11631 else if (is_32bit_abs_reloc (reloc_type)
11632 || is_32bit_pcrel_reloc (reloc_type))
11634 else if (is_64bit_abs_reloc (reloc_type)
11635 || is_64bit_pcrel_reloc (reloc_type))
11637 else if (is_24bit_abs_reloc (reloc_type))
11639 else if (is_16bit_abs_reloc (reloc_type))
11643 static unsigned int prev_reloc = 0;
11644 if (reloc_type != prev_reloc)
11645 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11646 reloc_type, printable_section_name (section));
11647 prev_reloc = reloc_type;
11651 rloc = start + rp->r_offset;
11652 if ((rloc + reloc_size) > end || (rloc < start))
11654 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11655 (unsigned long) rp->r_offset,
11656 printable_section_name (section));
11660 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11661 if (sym_index >= num_syms)
11663 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11664 sym_index, printable_section_name (section));
11667 sym = symtab + sym_index;
11669 /* If the reloc has a symbol associated with it,
11670 make sure that it is of an appropriate type.
11672 Relocations against symbols without type can happen.
11673 Gcc -feliminate-dwarf2-dups may generate symbols
11674 without type for debug info.
11676 Icc generates relocations against function symbols
11677 instead of local labels.
11679 Relocations against object symbols can happen, eg when
11680 referencing a global array. For an example of this see
11681 the _clz.o binary in libgcc.a. */
11683 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11685 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11686 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11687 (long int)(rp - relocs),
11688 printable_section_name (relsec));
11694 addend += rp->r_addend;
11695 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11696 partial_inplace. */
11698 || (elf_header.e_machine == EM_XTENSA
11699 && reloc_type == 1)
11700 || ((elf_header.e_machine == EM_PJ
11701 || elf_header.e_machine == EM_PJ_OLD)
11702 && reloc_type == 1)
11703 || ((elf_header.e_machine == EM_D30V
11704 || elf_header.e_machine == EM_CYGNUS_D30V)
11705 && reloc_type == 12))
11706 addend += byte_get (rloc, reloc_size);
11708 if (is_32bit_pcrel_reloc (reloc_type)
11709 || is_64bit_pcrel_reloc (reloc_type))
11711 /* On HPPA, all pc-relative relocations are biased by 8. */
11712 if (elf_header.e_machine == EM_PARISC)
11714 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11718 byte_put (rloc, addend + sym->st_value, reloc_size);
11727 #ifdef SUPPORT_DISASSEMBLY
11729 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11731 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11733 /* FIXME: XXX -- to be done --- XXX */
11739 /* Reads in the contents of SECTION from FILE, returning a pointer
11740 to a malloc'ed buffer or NULL if something went wrong. */
11743 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11745 bfd_size_type num_bytes;
11747 num_bytes = section->sh_size;
11749 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11751 printf (_("\nSection '%s' has no data to dump.\n"),
11752 printable_section_name (section));
11756 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11757 _("section contents"));
11762 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11764 Elf_Internal_Shdr * relsec;
11765 bfd_size_type num_bytes;
11769 bfd_boolean some_strings_shown;
11771 start = get_section_contents (section, file);
11775 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11777 /* If the section being dumped has relocations against it the user might
11778 be expecting these relocations to have been applied. Check for this
11779 case and issue a warning message in order to avoid confusion.
11780 FIXME: Maybe we ought to have an option that dumps a section with
11781 relocs applied ? */
11782 for (relsec = section_headers;
11783 relsec < section_headers + elf_header.e_shnum;
11786 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11787 || relsec->sh_info >= elf_header.e_shnum
11788 || section_headers + relsec->sh_info != section
11789 || relsec->sh_size == 0
11790 || relsec->sh_link >= elf_header.e_shnum)
11793 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11797 num_bytes = section->sh_size;
11799 end = start + num_bytes;
11800 some_strings_shown = FALSE;
11804 while (!ISPRINT (* data))
11805 if (++ data >= end)
11810 size_t maxlen = end - data;
11813 /* PR 11128: Use two separate invocations in order to work
11814 around bugs in the Solaris 8 implementation of printf. */
11815 printf (" [%6tx] ", data - start);
11817 printf (" [%6Ix] ", (size_t) (data - start));
11821 print_symbol ((int) maxlen, data);
11823 data += strnlen (data, maxlen);
11827 printf (_("<corrupt>\n"));
11830 some_strings_shown = TRUE;
11834 if (! some_strings_shown)
11835 printf (_(" No strings found in this section."));
11843 dump_section_as_bytes (Elf_Internal_Shdr * section,
11845 bfd_boolean relocate)
11847 Elf_Internal_Shdr * relsec;
11848 bfd_size_type bytes;
11850 unsigned char * data;
11851 unsigned char * start;
11853 start = (unsigned char *) get_section_contents (section, file);
11857 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11861 apply_relocations (file, section, start);
11865 /* If the section being dumped has relocations against it the user might
11866 be expecting these relocations to have been applied. Check for this
11867 case and issue a warning message in order to avoid confusion.
11868 FIXME: Maybe we ought to have an option that dumps a section with
11869 relocs applied ? */
11870 for (relsec = section_headers;
11871 relsec < section_headers + elf_header.e_shnum;
11874 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11875 || relsec->sh_info >= elf_header.e_shnum
11876 || section_headers + relsec->sh_info != section
11877 || relsec->sh_size == 0
11878 || relsec->sh_link >= elf_header.e_shnum)
11881 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11886 addr = section->sh_addr;
11887 bytes = section->sh_size;
11896 lbytes = (bytes > 16 ? 16 : bytes);
11898 printf (" 0x%8.8lx ", (unsigned long) addr);
11900 for (j = 0; j < 16; j++)
11903 printf ("%2.2x", data[j]);
11911 for (j = 0; j < lbytes; j++)
11914 if (k >= ' ' && k < 0x7f)
11932 /* Uncompresses a section that was compressed using zlib, in place. */
11935 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11936 dwarf_size_type *size ATTRIBUTE_UNUSED)
11938 #ifndef HAVE_ZLIB_H
11941 dwarf_size_type compressed_size = *size;
11942 unsigned char * compressed_buffer = *buffer;
11943 dwarf_size_type uncompressed_size;
11944 unsigned char * uncompressed_buffer;
11947 dwarf_size_type header_size = 12;
11949 /* Read the zlib header. In this case, it should be "ZLIB" followed
11950 by the uncompressed section size, 8 bytes in big-endian order. */
11951 if (compressed_size < header_size
11952 || ! streq ((char *) compressed_buffer, "ZLIB"))
11955 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11956 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11957 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11958 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11959 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11960 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11961 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11962 uncompressed_size += compressed_buffer[11];
11964 /* It is possible the section consists of several compressed
11965 buffers concatenated together, so we uncompress in a loop. */
11966 strm.zalloc = NULL;
11968 strm.opaque = NULL;
11969 strm.avail_in = compressed_size - header_size;
11970 strm.next_in = (Bytef *) compressed_buffer + header_size;
11971 strm.avail_out = uncompressed_size;
11972 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11974 rc = inflateInit (& strm);
11975 while (strm.avail_in > 0)
11979 strm.next_out = ((Bytef *) uncompressed_buffer
11980 + (uncompressed_size - strm.avail_out));
11981 rc = inflate (&strm, Z_FINISH);
11982 if (rc != Z_STREAM_END)
11984 rc = inflateReset (& strm);
11986 rc = inflateEnd (& strm);
11988 || strm.avail_out != 0)
11991 free (compressed_buffer);
11992 *buffer = uncompressed_buffer;
11993 *size = uncompressed_size;
11997 free (uncompressed_buffer);
11998 /* Indicate decompression failure. */
12001 #endif /* HAVE_ZLIB_H */
12005 load_specific_debug_section (enum dwarf_section_display_enum debug,
12006 Elf_Internal_Shdr * sec, void * file)
12008 struct dwarf_section * section = &debug_displays [debug].section;
12011 /* If it is already loaded, do nothing. */
12012 if (section->start != NULL)
12015 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
12016 section->address = sec->sh_addr;
12017 section->user_data = NULL;
12018 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
12020 sec->sh_size, buf);
12021 if (section->start == NULL)
12025 section->size = sec->sh_size;
12026 if (uncompress_section_contents (§ion->start, §ion->size))
12027 sec->sh_size = section->size;
12030 if (section->start == NULL)
12033 if (debug_displays [debug].relocate)
12034 apply_relocations ((FILE *) file, sec, section->start);
12039 /* If this is not NULL, load_debug_section will only look for sections
12040 within the list of sections given here. */
12041 unsigned int *section_subset = NULL;
12044 load_debug_section (enum dwarf_section_display_enum debug, void * file)
12046 struct dwarf_section * section = &debug_displays [debug].section;
12047 Elf_Internal_Shdr * sec;
12049 /* Locate the debug section. */
12050 sec = find_section_in_set (section->uncompressed_name, section_subset);
12052 section->name = section->uncompressed_name;
12055 sec = find_section_in_set (section->compressed_name, section_subset);
12057 section->name = section->compressed_name;
12062 /* If we're loading from a subset of sections, and we've loaded
12063 a section matching this name before, it's likely that it's a
12065 if (section_subset != NULL)
12066 free_debug_section (debug);
12068 return load_specific_debug_section (debug, sec, (FILE *) file);
12072 free_debug_section (enum dwarf_section_display_enum debug)
12074 struct dwarf_section * section = &debug_displays [debug].section;
12076 if (section->start == NULL)
12079 free ((char *) section->start);
12080 section->start = NULL;
12081 section->address = 0;
12086 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12088 char * name = SECTION_NAME (section);
12089 const char * print_name = printable_section_name (section);
12090 bfd_size_type length;
12094 length = section->sh_size;
12097 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12100 if (section->sh_type == SHT_NOBITS)
12102 /* There is no point in dumping the contents of a debugging section
12103 which has the NOBITS type - the bits in the file will be random.
12104 This can happen when a file containing a .eh_frame section is
12105 stripped with the --only-keep-debug command line option. */
12106 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12111 if (const_strneq (name, ".gnu.linkonce.wi."))
12112 name = ".debug_info";
12114 /* See if we know how to display the contents of this section. */
12115 for (i = 0; i < max; i++)
12116 if (streq (debug_displays[i].section.uncompressed_name, name)
12117 || (i == line && const_strneq (name, ".debug_line."))
12118 || streq (debug_displays[i].section.compressed_name, name))
12120 struct dwarf_section * sec = &debug_displays [i].section;
12121 int secondary = (section != find_section (name));
12124 free_debug_section ((enum dwarf_section_display_enum) i);
12126 if (i == line && const_strneq (name, ".debug_line."))
12128 else if (streq (sec->uncompressed_name, name))
12129 sec->name = sec->uncompressed_name;
12131 sec->name = sec->compressed_name;
12132 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12135 /* If this debug section is part of a CU/TU set in a .dwp file,
12136 restrict load_debug_section to the sections in that set. */
12137 section_subset = find_cu_tu_set (file, shndx);
12139 result &= debug_displays[i].display (sec, file);
12141 section_subset = NULL;
12143 if (secondary || (i != info && i != abbrev))
12144 free_debug_section ((enum dwarf_section_display_enum) i);
12152 printf (_("Unrecognized debug section: %s\n"), print_name);
12159 /* Set DUMP_SECTS for all sections where dumps were requested
12160 based on section name. */
12163 initialise_dumps_byname (void)
12165 struct dump_list_entry * cur;
12167 for (cur = dump_sects_byname; cur; cur = cur->next)
12172 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12173 if (streq (SECTION_NAME (section_headers + i), cur->name))
12175 request_dump_bynumber (i, cur->type);
12180 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12186 process_section_contents (FILE * file)
12188 Elf_Internal_Shdr * section;
12194 initialise_dumps_byname ();
12196 for (i = 0, section = section_headers;
12197 i < elf_header.e_shnum && i < num_dump_sects;
12200 #ifdef SUPPORT_DISASSEMBLY
12201 if (dump_sects[i] & DISASS_DUMP)
12202 disassemble_section (section, file);
12204 if (dump_sects[i] & HEX_DUMP)
12205 dump_section_as_bytes (section, file, FALSE);
12207 if (dump_sects[i] & RELOC_DUMP)
12208 dump_section_as_bytes (section, file, TRUE);
12210 if (dump_sects[i] & STRING_DUMP)
12211 dump_section_as_strings (section, file);
12213 if (dump_sects[i] & DEBUG_DUMP)
12214 display_debug_section (i, section, file);
12217 /* Check to see if the user requested a
12218 dump of a section that does not exist. */
12219 while (i++ < num_dump_sects)
12221 warn (_("Section %d was not dumped because it does not exist!\n"), i);
12225 process_mips_fpe_exception (int mask)
12230 if (mask & OEX_FPU_INEX)
12231 fputs ("INEX", stdout), first = 0;
12232 if (mask & OEX_FPU_UFLO)
12233 printf ("%sUFLO", first ? "" : "|"), first = 0;
12234 if (mask & OEX_FPU_OFLO)
12235 printf ("%sOFLO", first ? "" : "|"), first = 0;
12236 if (mask & OEX_FPU_DIV0)
12237 printf ("%sDIV0", first ? "" : "|"), first = 0;
12238 if (mask & OEX_FPU_INVAL)
12239 printf ("%sINVAL", first ? "" : "|");
12242 fputs ("0", stdout);
12245 /* Display's the value of TAG at location P. If TAG is
12246 greater than 0 it is assumed to be an unknown tag, and
12247 a message is printed to this effect. Otherwise it is
12248 assumed that a message has already been printed.
12250 If the bottom bit of TAG is set it assumed to have a
12251 string value, otherwise it is assumed to have an integer
12254 Returns an updated P pointing to the first unread byte
12255 beyond the end of TAG's value.
12257 Reads at or beyond END will not be made. */
12259 static unsigned char *
12260 display_tag_value (int tag,
12262 const unsigned char * const end)
12267 printf (" Tag_unknown_%d: ", tag);
12271 warn (_("<corrupt tag>\n"));
12275 /* PR 17531 file: 027-19978-0.004. */
12276 size_t maxlen = (end - p) - 1;
12281 print_symbol ((int) maxlen, (const char *) p);
12282 p += strnlen ((char *) p, maxlen) + 1;
12286 printf (_("<corrupt string tag>"));
12287 p = (unsigned char *) end;
12295 val = read_uleb128 (p, &len, end);
12297 printf ("%ld (0x%lx)\n", val, val);
12304 /* ARM EABI attributes section. */
12309 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12311 const char ** table;
12312 } arm_attr_public_tag;
12314 static const char * arm_attr_tag_CPU_arch[] =
12315 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12316 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12317 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12318 static const char * arm_attr_tag_THUMB_ISA_use[] =
12319 {"No", "Thumb-1", "Thumb-2"};
12320 static const char * arm_attr_tag_FP_arch[] =
12321 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12322 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12323 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12324 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12325 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12326 static const char * arm_attr_tag_PCS_config[] =
12327 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12328 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12329 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12330 {"V6", "SB", "TLS", "Unused"};
12331 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12332 {"Absolute", "PC-relative", "SB-relative", "None"};
12333 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12334 {"Absolute", "PC-relative", "None"};
12335 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12336 {"None", "direct", "GOT-indirect"};
12337 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12338 {"None", "??? 1", "2", "??? 3", "4"};
12339 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12340 static const char * arm_attr_tag_ABI_FP_denormal[] =
12341 {"Unused", "Needed", "Sign only"};
12342 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12343 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12344 static const char * arm_attr_tag_ABI_FP_number_model[] =
12345 {"Unused", "Finite", "RTABI", "IEEE 754"};
12346 static const char * arm_attr_tag_ABI_enum_size[] =
12347 {"Unused", "small", "int", "forced to int"};
12348 static const char * arm_attr_tag_ABI_HardFP_use[] =
12349 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12350 static const char * arm_attr_tag_ABI_VFP_args[] =
12351 {"AAPCS", "VFP registers", "custom", "compatible"};
12352 static const char * arm_attr_tag_ABI_WMMX_args[] =
12353 {"AAPCS", "WMMX registers", "custom"};
12354 static const char * arm_attr_tag_ABI_optimization_goals[] =
12355 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12356 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12357 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12358 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12359 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12360 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12361 static const char * arm_attr_tag_FP_HP_extension[] =
12362 {"Not Allowed", "Allowed"};
12363 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12364 {"None", "IEEE 754", "Alternative Format"};
12365 static const char * arm_attr_tag_MPextension_use[] =
12366 {"Not Allowed", "Allowed"};
12367 static const char * arm_attr_tag_DIV_use[] =
12368 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12369 "Allowed in v7-A with integer division extension"};
12370 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12371 static const char * arm_attr_tag_Virtualization_use[] =
12372 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12373 "TrustZone and Virtualization Extensions"};
12374 static const char * arm_attr_tag_MPextension_use_legacy[] =
12375 {"Not Allowed", "Allowed"};
12377 #define LOOKUP(id, name) \
12378 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12379 static arm_attr_public_tag arm_attr_public_tags[] =
12381 {4, "CPU_raw_name", 1, NULL},
12382 {5, "CPU_name", 1, NULL},
12383 LOOKUP(6, CPU_arch),
12384 {7, "CPU_arch_profile", 0, NULL},
12385 LOOKUP(8, ARM_ISA_use),
12386 LOOKUP(9, THUMB_ISA_use),
12387 LOOKUP(10, FP_arch),
12388 LOOKUP(11, WMMX_arch),
12389 LOOKUP(12, Advanced_SIMD_arch),
12390 LOOKUP(13, PCS_config),
12391 LOOKUP(14, ABI_PCS_R9_use),
12392 LOOKUP(15, ABI_PCS_RW_data),
12393 LOOKUP(16, ABI_PCS_RO_data),
12394 LOOKUP(17, ABI_PCS_GOT_use),
12395 LOOKUP(18, ABI_PCS_wchar_t),
12396 LOOKUP(19, ABI_FP_rounding),
12397 LOOKUP(20, ABI_FP_denormal),
12398 LOOKUP(21, ABI_FP_exceptions),
12399 LOOKUP(22, ABI_FP_user_exceptions),
12400 LOOKUP(23, ABI_FP_number_model),
12401 {24, "ABI_align_needed", 0, NULL},
12402 {25, "ABI_align_preserved", 0, NULL},
12403 LOOKUP(26, ABI_enum_size),
12404 LOOKUP(27, ABI_HardFP_use),
12405 LOOKUP(28, ABI_VFP_args),
12406 LOOKUP(29, ABI_WMMX_args),
12407 LOOKUP(30, ABI_optimization_goals),
12408 LOOKUP(31, ABI_FP_optimization_goals),
12409 {32, "compatibility", 0, NULL},
12410 LOOKUP(34, CPU_unaligned_access),
12411 LOOKUP(36, FP_HP_extension),
12412 LOOKUP(38, ABI_FP_16bit_format),
12413 LOOKUP(42, MPextension_use),
12414 LOOKUP(44, DIV_use),
12415 {64, "nodefaults", 0, NULL},
12416 {65, "also_compatible_with", 0, NULL},
12417 LOOKUP(66, T2EE_use),
12418 {67, "conformance", 1, NULL},
12419 LOOKUP(68, Virtualization_use),
12420 LOOKUP(70, MPextension_use_legacy)
12424 static unsigned char *
12425 display_arm_attribute (unsigned char * p,
12426 const unsigned char * const end)
12431 arm_attr_public_tag * attr;
12435 tag = read_uleb128 (p, &len, end);
12438 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12440 if (arm_attr_public_tags[i].tag == tag)
12442 attr = &arm_attr_public_tags[i];
12449 printf (" Tag_%s: ", attr->name);
12450 switch (attr->type)
12455 case 7: /* Tag_CPU_arch_profile. */
12456 val = read_uleb128 (p, &len, end);
12460 case 0: printf (_("None\n")); break;
12461 case 'A': printf (_("Application\n")); break;
12462 case 'R': printf (_("Realtime\n")); break;
12463 case 'M': printf (_("Microcontroller\n")); break;
12464 case 'S': printf (_("Application or Realtime\n")); break;
12465 default: printf ("??? (%d)\n", val); break;
12469 case 24: /* Tag_align_needed. */
12470 val = read_uleb128 (p, &len, end);
12474 case 0: printf (_("None\n")); break;
12475 case 1: printf (_("8-byte\n")); break;
12476 case 2: printf (_("4-byte\n")); break;
12477 case 3: printf ("??? 3\n"); break;
12480 printf (_("8-byte and up to %d-byte extended\n"),
12483 printf ("??? (%d)\n", val);
12488 case 25: /* Tag_align_preserved. */
12489 val = read_uleb128 (p, &len, end);
12493 case 0: printf (_("None\n")); break;
12494 case 1: printf (_("8-byte, except leaf SP\n")); break;
12495 case 2: printf (_("8-byte\n")); break;
12496 case 3: printf ("??? 3\n"); break;
12499 printf (_("8-byte and up to %d-byte extended\n"),
12502 printf ("??? (%d)\n", val);
12507 case 32: /* Tag_compatibility. */
12509 val = read_uleb128 (p, &len, end);
12511 printf (_("flag = %d, vendor = "), val);
12514 size_t maxlen = (end - p) - 1;
12516 print_symbol ((int) maxlen, (const char *) p);
12517 p += strnlen ((char *) p, maxlen) + 1;
12521 printf (_("<corrupt>"));
12522 p = (unsigned char *) end;
12528 case 64: /* Tag_nodefaults. */
12529 /* PR 17531: file: 001-505008-0.01. */
12532 printf (_("True\n"));
12535 case 65: /* Tag_also_compatible_with. */
12536 val = read_uleb128 (p, &len, end);
12538 if (val == 6 /* Tag_CPU_arch. */)
12540 val = read_uleb128 (p, &len, end);
12542 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12543 printf ("??? (%d)\n", val);
12545 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12549 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12554 printf (_("<unknown: %d>\n"), tag);
12560 return display_tag_value (-1, p, end);
12562 return display_tag_value (0, p, end);
12565 assert (attr->type & 0x80);
12566 val = read_uleb128 (p, &len, end);
12568 type = attr->type & 0x7f;
12570 printf ("??? (%d)\n", val);
12572 printf ("%s\n", attr->table[val]);
12577 return display_tag_value (tag, p, end);
12580 static unsigned char *
12581 display_gnu_attribute (unsigned char * p,
12582 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12583 const unsigned char * const end)
12589 tag = read_uleb128 (p, &len, end);
12592 /* Tag_compatibility is the only generic GNU attribute defined at
12596 val = read_uleb128 (p, &len, end);
12599 printf (_("flag = %d, vendor = "), val);
12602 printf (_("<corrupt>\n"));
12603 warn (_("corrupt vendor attribute\n"));
12609 size_t maxlen = (end - p) - 1;
12611 print_symbol ((int) maxlen, (const char *) p);
12612 p += strnlen ((char *) p, maxlen) + 1;
12616 printf (_("<corrupt>"));
12617 p = (unsigned char *) end;
12624 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12625 return display_proc_gnu_attribute (p, tag, end);
12627 return display_tag_value (tag, p, end);
12630 static unsigned char *
12631 display_power_gnu_attribute (unsigned char * p,
12633 const unsigned char * const end)
12638 if (tag == Tag_GNU_Power_ABI_FP)
12640 val = read_uleb128 (p, &len, end);
12642 printf (" Tag_GNU_Power_ABI_FP: ");
12647 printf (_("Hard or soft float\n"));
12650 printf (_("Hard float\n"));
12653 printf (_("Soft float\n"));
12656 printf (_("Single-precision hard float\n"));
12659 printf ("??? (%d)\n", val);
12665 if (tag == Tag_GNU_Power_ABI_Vector)
12667 val = read_uleb128 (p, &len, end);
12669 printf (" Tag_GNU_Power_ABI_Vector: ");
12673 printf (_("Any\n"));
12676 printf (_("Generic\n"));
12679 printf ("AltiVec\n");
12685 printf ("??? (%d)\n", val);
12691 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12695 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12699 val = read_uleb128 (p, &len, end);
12701 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12705 printf (_("Any\n"));
12708 printf ("r3/r4\n");
12711 printf (_("Memory\n"));
12714 printf ("??? (%d)\n", val);
12720 return display_tag_value (tag & 1, p, end);
12724 display_sparc_hwcaps (int mask)
12730 if (mask & ELF_SPARC_HWCAP_MUL32)
12731 fputs ("mul32", stdout), first = 0;
12732 if (mask & ELF_SPARC_HWCAP_DIV32)
12733 printf ("%sdiv32", first ? "" : "|"), first = 0;
12734 if (mask & ELF_SPARC_HWCAP_FSMULD)
12735 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12736 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12737 printf ("%sv8plus", first ? "" : "|"), first = 0;
12738 if (mask & ELF_SPARC_HWCAP_POPC)
12739 printf ("%spopc", first ? "" : "|"), first = 0;
12740 if (mask & ELF_SPARC_HWCAP_VIS)
12741 printf ("%svis", first ? "" : "|"), first = 0;
12742 if (mask & ELF_SPARC_HWCAP_VIS2)
12743 printf ("%svis2", first ? "" : "|"), first = 0;
12744 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12745 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12746 if (mask & ELF_SPARC_HWCAP_FMAF)
12747 printf ("%sfmaf", first ? "" : "|"), first = 0;
12748 if (mask & ELF_SPARC_HWCAP_VIS3)
12749 printf ("%svis3", first ? "" : "|"), first = 0;
12750 if (mask & ELF_SPARC_HWCAP_HPC)
12751 printf ("%shpc", first ? "" : "|"), first = 0;
12752 if (mask & ELF_SPARC_HWCAP_RANDOM)
12753 printf ("%srandom", first ? "" : "|"), first = 0;
12754 if (mask & ELF_SPARC_HWCAP_TRANS)
12755 printf ("%strans", first ? "" : "|"), first = 0;
12756 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12757 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12758 if (mask & ELF_SPARC_HWCAP_IMA)
12759 printf ("%sima", first ? "" : "|"), first = 0;
12760 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12761 printf ("%scspare", first ? "" : "|"), first = 0;
12764 fputc ('0', stdout);
12765 fputc ('\n', stdout);
12769 display_sparc_hwcaps2 (int mask)
12775 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12776 fputs ("fjathplus", stdout), first = 0;
12777 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12778 printf ("%svis3b", first ? "" : "|"), first = 0;
12779 if (mask & ELF_SPARC_HWCAP2_ADP)
12780 printf ("%sadp", first ? "" : "|"), first = 0;
12781 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12782 printf ("%ssparc5", first ? "" : "|"), first = 0;
12783 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12784 printf ("%smwait", first ? "" : "|"), first = 0;
12785 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12786 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12787 if (mask & ELF_SPARC_HWCAP2_XMONT)
12788 printf ("%sxmont2", first ? "" : "|"), first = 0;
12789 if (mask & ELF_SPARC_HWCAP2_NSEC)
12790 printf ("%snsec", first ? "" : "|"), first = 0;
12791 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12792 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12793 if (mask & ELF_SPARC_HWCAP2_FJDES)
12794 printf ("%sfjdes", first ? "" : "|"), first = 0;
12795 if (mask & ELF_SPARC_HWCAP2_FJAES)
12796 printf ("%sfjaes", first ? "" : "|"), first = 0;
12799 fputc ('0', stdout);
12800 fputc ('\n', stdout);
12803 static unsigned char *
12804 display_sparc_gnu_attribute (unsigned char * p,
12806 const unsigned char * const end)
12811 if (tag == Tag_GNU_Sparc_HWCAPS)
12813 val = read_uleb128 (p, &len, end);
12815 printf (" Tag_GNU_Sparc_HWCAPS: ");
12816 display_sparc_hwcaps (val);
12819 if (tag == Tag_GNU_Sparc_HWCAPS2)
12821 val = read_uleb128 (p, &len, end);
12823 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12824 display_sparc_hwcaps2 (val);
12828 return display_tag_value (tag, p, end);
12832 print_mips_fp_abi_value (int val)
12836 case Val_GNU_MIPS_ABI_FP_ANY:
12837 printf (_("Hard or soft float\n"));
12839 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12840 printf (_("Hard float (double precision)\n"));
12842 case Val_GNU_MIPS_ABI_FP_SINGLE:
12843 printf (_("Hard float (single precision)\n"));
12845 case Val_GNU_MIPS_ABI_FP_SOFT:
12846 printf (_("Soft float\n"));
12848 case Val_GNU_MIPS_ABI_FP_OLD_64:
12849 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12851 case Val_GNU_MIPS_ABI_FP_XX:
12852 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12854 case Val_GNU_MIPS_ABI_FP_64:
12855 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12857 case Val_GNU_MIPS_ABI_FP_64A:
12858 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12861 printf ("??? (%d)\n", val);
12866 static unsigned char *
12867 display_mips_gnu_attribute (unsigned char * p,
12869 const unsigned char * const end)
12871 if (tag == Tag_GNU_MIPS_ABI_FP)
12876 val = read_uleb128 (p, &len, end);
12878 printf (" Tag_GNU_MIPS_ABI_FP: ");
12880 print_mips_fp_abi_value (val);
12885 if (tag == Tag_GNU_MIPS_ABI_MSA)
12890 val = read_uleb128 (p, &len, end);
12892 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12896 case Val_GNU_MIPS_ABI_MSA_ANY:
12897 printf (_("Any MSA or not\n"));
12899 case Val_GNU_MIPS_ABI_MSA_128:
12900 printf (_("128-bit MSA\n"));
12903 printf ("??? (%d)\n", val);
12909 return display_tag_value (tag & 1, p, end);
12912 static unsigned char *
12913 display_tic6x_attribute (unsigned char * p,
12914 const unsigned char * const end)
12920 tag = read_uleb128 (p, &len, end);
12926 val = read_uleb128 (p, &len, end);
12928 printf (" Tag_ISA: ");
12932 case C6XABI_Tag_ISA_none:
12933 printf (_("None\n"));
12935 case C6XABI_Tag_ISA_C62X:
12938 case C6XABI_Tag_ISA_C67X:
12941 case C6XABI_Tag_ISA_C67XP:
12942 printf ("C67x+\n");
12944 case C6XABI_Tag_ISA_C64X:
12947 case C6XABI_Tag_ISA_C64XP:
12948 printf ("C64x+\n");
12950 case C6XABI_Tag_ISA_C674X:
12951 printf ("C674x\n");
12954 printf ("??? (%d)\n", val);
12959 case Tag_ABI_wchar_t:
12960 val = read_uleb128 (p, &len, end);
12962 printf (" Tag_ABI_wchar_t: ");
12966 printf (_("Not used\n"));
12969 printf (_("2 bytes\n"));
12972 printf (_("4 bytes\n"));
12975 printf ("??? (%d)\n", val);
12980 case Tag_ABI_stack_align_needed:
12981 val = read_uleb128 (p, &len, end);
12983 printf (" Tag_ABI_stack_align_needed: ");
12987 printf (_("8-byte\n"));
12990 printf (_("16-byte\n"));
12993 printf ("??? (%d)\n", val);
12998 case Tag_ABI_stack_align_preserved:
12999 val = read_uleb128 (p, &len, end);
13001 printf (" Tag_ABI_stack_align_preserved: ");
13005 printf (_("8-byte\n"));
13008 printf (_("16-byte\n"));
13011 printf ("??? (%d)\n", val);
13017 val = read_uleb128 (p, &len, end);
13019 printf (" Tag_ABI_DSBT: ");
13023 printf (_("DSBT addressing not used\n"));
13026 printf (_("DSBT addressing used\n"));
13029 printf ("??? (%d)\n", val);
13035 val = read_uleb128 (p, &len, end);
13037 printf (" Tag_ABI_PID: ");
13041 printf (_("Data addressing position-dependent\n"));
13044 printf (_("Data addressing position-independent, GOT near DP\n"));
13047 printf (_("Data addressing position-independent, GOT far from DP\n"));
13050 printf ("??? (%d)\n", val);
13056 val = read_uleb128 (p, &len, end);
13058 printf (" Tag_ABI_PIC: ");
13062 printf (_("Code addressing position-dependent\n"));
13065 printf (_("Code addressing position-independent\n"));
13068 printf ("??? (%d)\n", val);
13073 case Tag_ABI_array_object_alignment:
13074 val = read_uleb128 (p, &len, end);
13076 printf (" Tag_ABI_array_object_alignment: ");
13080 printf (_("8-byte\n"));
13083 printf (_("4-byte\n"));
13086 printf (_("16-byte\n"));
13089 printf ("??? (%d)\n", val);
13094 case Tag_ABI_array_object_align_expected:
13095 val = read_uleb128 (p, &len, end);
13097 printf (" Tag_ABI_array_object_align_expected: ");
13101 printf (_("8-byte\n"));
13104 printf (_("4-byte\n"));
13107 printf (_("16-byte\n"));
13110 printf ("??? (%d)\n", val);
13115 case Tag_ABI_compatibility:
13117 val = read_uleb128 (p, &len, end);
13119 printf (" Tag_ABI_compatibility: ");
13120 printf (_("flag = %d, vendor = "), val);
13123 size_t maxlen = (end - p) - 1;
13125 print_symbol ((int) maxlen, (const char *) p);
13126 p += strnlen ((char *) p, maxlen) + 1;
13130 printf (_("<corrupt>"));
13131 p = (unsigned char *) end;
13137 case Tag_ABI_conformance:
13139 printf (" Tag_ABI_conformance: \"");
13142 size_t maxlen = (end - p) - 1;
13144 print_symbol ((int) maxlen, (const char *) p);
13145 p += strnlen ((char *) p, maxlen) + 1;
13149 printf (_("<corrupt>"));
13150 p = (unsigned char *) end;
13157 return display_tag_value (tag, p, end);
13161 display_raw_attribute (unsigned char * p, unsigned char * end)
13163 unsigned long addr = 0;
13164 size_t bytes = end - p;
13171 int lbytes = (bytes > 16 ? 16 : bytes);
13173 printf (" 0x%8.8lx ", addr);
13175 for (j = 0; j < 16; j++)
13178 printf ("%2.2x", p[j]);
13186 for (j = 0; j < lbytes; j++)
13189 if (k >= ' ' && k < 0x7f)
13205 static unsigned char *
13206 display_msp430x_attribute (unsigned char * p,
13207 const unsigned char * const end)
13213 tag = read_uleb128 (p, & len, end);
13218 case OFBA_MSPABI_Tag_ISA:
13219 val = read_uleb128 (p, &len, end);
13221 printf (" Tag_ISA: ");
13224 case 0: printf (_("None\n")); break;
13225 case 1: printf (_("MSP430\n")); break;
13226 case 2: printf (_("MSP430X\n")); break;
13227 default: printf ("??? (%d)\n", val); break;
13231 case OFBA_MSPABI_Tag_Code_Model:
13232 val = read_uleb128 (p, &len, end);
13234 printf (" Tag_Code_Model: ");
13237 case 0: printf (_("None\n")); break;
13238 case 1: printf (_("Small\n")); break;
13239 case 2: printf (_("Large\n")); break;
13240 default: printf ("??? (%d)\n", val); break;
13244 case OFBA_MSPABI_Tag_Data_Model:
13245 val = read_uleb128 (p, &len, end);
13247 printf (" Tag_Data_Model: ");
13250 case 0: printf (_("None\n")); break;
13251 case 1: printf (_("Small\n")); break;
13252 case 2: printf (_("Large\n")); break;
13253 case 3: printf (_("Restricted Large\n")); break;
13254 default: printf ("??? (%d)\n", val); break;
13259 printf (_(" <unknown tag %d>: "), tag);
13266 size_t maxlen = (end - p) - 1;
13268 print_symbol ((int) maxlen, (const char *) p);
13269 p += strnlen ((char *) p, maxlen) + 1;
13273 printf (_("<corrupt>"));
13274 p = (unsigned char *) end;
13280 val = read_uleb128 (p, &len, end);
13282 printf ("%d (0x%x)\n", val, val);
13292 process_attributes (FILE * file,
13293 const char * public_name,
13294 unsigned int proc_type,
13295 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13296 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13298 Elf_Internal_Shdr * sect;
13301 /* Find the section header so that we get the size. */
13302 for (i = 0, sect = section_headers;
13303 i < elf_header.e_shnum;
13306 unsigned char * contents;
13309 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13312 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13313 sect->sh_size, _("attributes"));
13314 if (contents == NULL)
13320 bfd_vma section_len;
13322 section_len = sect->sh_size - 1;
13325 while (section_len > 0)
13328 unsigned int namelen;
13329 bfd_boolean public_section;
13330 bfd_boolean gnu_section;
13332 if (section_len <= 4)
13334 error (_("Tag section ends prematurely\n"));
13337 attr_len = byte_get (p, 4);
13340 if (attr_len > section_len)
13342 error (_("Bad attribute length (%u > %u)\n"),
13343 (unsigned) attr_len, (unsigned) section_len);
13344 attr_len = section_len;
13346 /* PR 17531: file: 001-101425-0.004 */
13347 else if (attr_len < 5)
13349 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13353 section_len -= attr_len;
13356 namelen = strnlen ((char *) p, attr_len) + 1;
13357 if (namelen == 0 || namelen >= attr_len)
13359 error (_("Corrupt attribute section name\n"));
13363 printf (_("Attribute Section: "));
13364 print_symbol (INT_MAX, (const char *) p);
13367 if (public_name && streq ((char *) p, public_name))
13368 public_section = TRUE;
13370 public_section = FALSE;
13372 if (streq ((char *) p, "gnu"))
13373 gnu_section = TRUE;
13375 gnu_section = FALSE;
13378 attr_len -= namelen;
13380 while (attr_len > 0 && p < contents + sect->sh_size)
13385 unsigned char * end;
13387 /* PR binutils/17531: Safe handling of corrupt files. */
13390 error (_("Unused bytes at end of section\n"));
13396 size = byte_get (p, 4);
13397 if (size > attr_len)
13399 error (_("Bad subsection length (%u > %u)\n"),
13400 (unsigned) size, (unsigned) attr_len);
13403 /* PR binutils/17531: Safe handling of corrupt files. */
13406 error (_("Bad subsection length (%u < 6)\n"),
13413 end = p + size - 1;
13414 assert (end <= contents + sect->sh_size);
13420 printf (_("File Attributes\n"));
13423 printf (_("Section Attributes:"));
13426 printf (_("Symbol Attributes:"));
13432 val = read_uleb128 (p, &j, end);
13436 printf (" %d", val);
13441 printf (_("Unknown tag: %d\n"), tag);
13442 public_section = FALSE;
13446 if (public_section && display_pub_attribute != NULL)
13449 p = display_pub_attribute (p, end);
13452 else if (gnu_section && display_proc_gnu_attribute != NULL)
13455 p = display_gnu_attribute (p,
13456 display_proc_gnu_attribute,
13462 printf (_(" Unknown attribute:\n"));
13463 display_raw_attribute (p, end);
13472 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13480 process_arm_specific (FILE * file)
13482 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13483 display_arm_attribute, NULL);
13487 process_power_specific (FILE * file)
13489 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13490 display_power_gnu_attribute);
13494 process_sparc_specific (FILE * file)
13496 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13497 display_sparc_gnu_attribute);
13501 process_tic6x_specific (FILE * file)
13503 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13504 display_tic6x_attribute, NULL);
13508 process_msp430x_specific (FILE * file)
13510 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13511 display_msp430x_attribute, NULL);
13514 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13515 Print the Address, Access and Initial fields of an entry at VMA ADDR
13516 and return the VMA of the next entry, or -1 if there was a problem.
13517 Does not read from DATA_END or beyond. */
13520 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13521 unsigned char * data_end)
13524 print_vma (addr, LONG_HEX);
13526 if (addr < pltgot + 0xfff0)
13527 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13529 printf ("%10s", "");
13532 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13536 unsigned char * from = data + addr - pltgot;
13538 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13540 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13541 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13542 return (bfd_vma) -1;
13546 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13547 print_vma (entry, LONG_HEX);
13550 return addr + (is_32bit_elf ? 4 : 8);
13553 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13554 PLTGOT. Print the Address and Initial fields of an entry at VMA
13555 ADDR and return the VMA of the next entry. */
13558 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13561 print_vma (addr, LONG_HEX);
13564 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13569 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13570 print_vma (entry, LONG_HEX);
13572 return addr + (is_32bit_elf ? 4 : 8);
13576 print_mips_ases (unsigned int mask)
13578 if (mask & AFL_ASE_DSP)
13579 fputs ("\n\tDSP ASE", stdout);
13580 if (mask & AFL_ASE_DSPR2)
13581 fputs ("\n\tDSP R2 ASE", stdout);
13582 if (mask & AFL_ASE_EVA)
13583 fputs ("\n\tEnhanced VA Scheme", stdout);
13584 if (mask & AFL_ASE_MCU)
13585 fputs ("\n\tMCU (MicroController) ASE", stdout);
13586 if (mask & AFL_ASE_MDMX)
13587 fputs ("\n\tMDMX ASE", stdout);
13588 if (mask & AFL_ASE_MIPS3D)
13589 fputs ("\n\tMIPS-3D ASE", stdout);
13590 if (mask & AFL_ASE_MT)
13591 fputs ("\n\tMT ASE", stdout);
13592 if (mask & AFL_ASE_SMARTMIPS)
13593 fputs ("\n\tSmartMIPS ASE", stdout);
13594 if (mask & AFL_ASE_VIRT)
13595 fputs ("\n\tVZ ASE", stdout);
13596 if (mask & AFL_ASE_MSA)
13597 fputs ("\n\tMSA ASE", stdout);
13598 if (mask & AFL_ASE_MIPS16)
13599 fputs ("\n\tMIPS16 ASE", stdout);
13600 if (mask & AFL_ASE_MICROMIPS)
13601 fputs ("\n\tMICROMIPS ASE", stdout);
13602 if (mask & AFL_ASE_XPA)
13603 fputs ("\n\tXPA ASE", stdout);
13605 fprintf (stdout, "\n\t%s", _("None"));
13606 else if ((mask & ~AFL_ASE_MASK) != 0)
13607 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13611 print_mips_isa_ext (unsigned int isa_ext)
13616 fputs (_("None"), stdout);
13619 fputs ("RMI XLR", stdout);
13621 case AFL_EXT_OCTEON3:
13622 fputs ("Cavium Networks Octeon3", stdout);
13624 case AFL_EXT_OCTEON2:
13625 fputs ("Cavium Networks Octeon2", stdout);
13627 case AFL_EXT_OCTEONP:
13628 fputs ("Cavium Networks OcteonP", stdout);
13630 case AFL_EXT_LOONGSON_3A:
13631 fputs ("Loongson 3A", stdout);
13633 case AFL_EXT_OCTEON:
13634 fputs ("Cavium Networks Octeon", stdout);
13637 fputs ("Toshiba R5900", stdout);
13640 fputs ("MIPS R4650", stdout);
13643 fputs ("LSI R4010", stdout);
13646 fputs ("NEC VR4100", stdout);
13649 fputs ("Toshiba R3900", stdout);
13651 case AFL_EXT_10000:
13652 fputs ("MIPS R10000", stdout);
13655 fputs ("Broadcom SB-1", stdout);
13658 fputs ("NEC VR4111/VR4181", stdout);
13661 fputs ("NEC VR4120", stdout);
13664 fputs ("NEC VR5400", stdout);
13667 fputs ("NEC VR5500", stdout);
13669 case AFL_EXT_LOONGSON_2E:
13670 fputs ("ST Microelectronics Loongson 2E", stdout);
13672 case AFL_EXT_LOONGSON_2F:
13673 fputs ("ST Microelectronics Loongson 2F", stdout);
13676 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13681 get_mips_reg_size (int reg_size)
13683 return (reg_size == AFL_REG_NONE) ? 0
13684 : (reg_size == AFL_REG_32) ? 32
13685 : (reg_size == AFL_REG_64) ? 64
13686 : (reg_size == AFL_REG_128) ? 128
13691 process_mips_specific (FILE * file)
13693 Elf_Internal_Dyn * entry;
13694 Elf_Internal_Shdr *sect = NULL;
13695 size_t liblist_offset = 0;
13696 size_t liblistno = 0;
13697 size_t conflictsno = 0;
13698 size_t options_offset = 0;
13699 size_t conflicts_offset = 0;
13700 size_t pltrelsz = 0;
13702 bfd_vma pltgot = 0;
13703 bfd_vma mips_pltgot = 0;
13704 bfd_vma jmprel = 0;
13705 bfd_vma local_gotno = 0;
13706 bfd_vma gotsym = 0;
13707 bfd_vma symtabno = 0;
13709 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13710 display_mips_gnu_attribute);
13712 sect = find_section (".MIPS.abiflags");
13716 Elf_External_ABIFlags_v0 *abiflags_ext;
13717 Elf_Internal_ABIFlags_v0 abiflags_in;
13719 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13720 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13723 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13724 sect->sh_size, _("MIPS ABI Flags section"));
13727 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13728 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13729 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13730 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13731 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13732 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13733 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13734 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13735 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13736 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13737 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13739 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13740 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13741 if (abiflags_in.isa_rev > 1)
13742 printf ("r%d", abiflags_in.isa_rev);
13743 printf ("\nGPR size: %d",
13744 get_mips_reg_size (abiflags_in.gpr_size));
13745 printf ("\nCPR1 size: %d",
13746 get_mips_reg_size (abiflags_in.cpr1_size));
13747 printf ("\nCPR2 size: %d",
13748 get_mips_reg_size (abiflags_in.cpr2_size));
13749 fputs ("\nFP ABI: ", stdout);
13750 print_mips_fp_abi_value (abiflags_in.fp_abi);
13751 fputs ("ISA Extension: ", stdout);
13752 print_mips_isa_ext (abiflags_in.isa_ext);
13753 fputs ("\nASEs:", stdout);
13754 print_mips_ases (abiflags_in.ases);
13755 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13756 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13757 fputc ('\n', stdout);
13758 free (abiflags_ext);
13763 /* We have a lot of special sections. Thanks SGI! */
13764 if (dynamic_section == NULL)
13765 /* No information available. */
13768 for (entry = dynamic_section;
13769 /* PR 17531 file: 012-50589-0.004. */
13770 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13772 switch (entry->d_tag)
13774 case DT_MIPS_LIBLIST:
13776 = offset_from_vma (file, entry->d_un.d_val,
13777 liblistno * sizeof (Elf32_External_Lib));
13779 case DT_MIPS_LIBLISTNO:
13780 liblistno = entry->d_un.d_val;
13782 case DT_MIPS_OPTIONS:
13783 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13785 case DT_MIPS_CONFLICT:
13787 = offset_from_vma (file, entry->d_un.d_val,
13788 conflictsno * sizeof (Elf32_External_Conflict));
13790 case DT_MIPS_CONFLICTNO:
13791 conflictsno = entry->d_un.d_val;
13794 pltgot = entry->d_un.d_ptr;
13796 case DT_MIPS_LOCAL_GOTNO:
13797 local_gotno = entry->d_un.d_val;
13799 case DT_MIPS_GOTSYM:
13800 gotsym = entry->d_un.d_val;
13802 case DT_MIPS_SYMTABNO:
13803 symtabno = entry->d_un.d_val;
13805 case DT_MIPS_PLTGOT:
13806 mips_pltgot = entry->d_un.d_ptr;
13809 pltrel = entry->d_un.d_val;
13812 pltrelsz = entry->d_un.d_val;
13815 jmprel = entry->d_un.d_ptr;
13821 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13823 Elf32_External_Lib * elib;
13826 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13828 sizeof (Elf32_External_Lib),
13829 _("liblist section data"));
13832 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13833 (unsigned long) liblistno);
13834 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13837 for (cnt = 0; cnt < liblistno; ++cnt)
13844 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13845 atime = BYTE_GET (elib[cnt].l_time_stamp);
13846 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13847 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13848 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13850 tmp = gmtime (&atime);
13851 snprintf (timebuf, sizeof (timebuf),
13852 "%04u-%02u-%02uT%02u:%02u:%02u",
13853 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13854 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13856 printf ("%3lu: ", (unsigned long) cnt);
13857 if (VALID_DYNAMIC_NAME (liblist.l_name))
13858 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13860 printf (_("<corrupt: %9ld>"), liblist.l_name);
13861 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13862 liblist.l_version);
13864 if (liblist.l_flags == 0)
13868 static const struct
13875 { " EXACT_MATCH", LL_EXACT_MATCH },
13876 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13877 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13878 { " EXPORTS", LL_EXPORTS },
13879 { " DELAY_LOAD", LL_DELAY_LOAD },
13880 { " DELTA", LL_DELTA }
13882 int flags = liblist.l_flags;
13885 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13886 if ((flags & l_flags_vals[fcnt].bit) != 0)
13888 fputs (l_flags_vals[fcnt].name, stdout);
13889 flags ^= l_flags_vals[fcnt].bit;
13892 printf (" %#x", (unsigned int) flags);
13902 if (options_offset != 0)
13904 Elf_External_Options * eopt;
13905 Elf_Internal_Options * iopt;
13906 Elf_Internal_Options * option;
13909 sect = section_headers;
13911 /* Find the section header so that we get the size. */
13912 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13913 /* PR 17533 file: 012-277276-0.004. */
13916 error (_("No MIPS_OPTIONS header found\n"));
13920 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13921 sect->sh_size, _("options"));
13924 iopt = (Elf_Internal_Options *)
13925 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13928 error (_("Out of memory allocatinf space for MIPS options\n"));
13935 while (offset <= sect->sh_size - sizeof (* eopt))
13937 Elf_External_Options * eoption;
13939 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13941 option->kind = BYTE_GET (eoption->kind);
13942 option->size = BYTE_GET (eoption->size);
13943 option->section = BYTE_GET (eoption->section);
13944 option->info = BYTE_GET (eoption->info);
13946 /* PR 17531: file: ffa0fa3b. */
13947 if (option->size < sizeof (* eopt)
13948 || offset + option->size > sect->sh_size)
13950 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13953 offset += option->size;
13959 printf (_("\nSection '%s' contains %d entries:\n"),
13960 printable_section_name (sect), cnt);
13969 switch (option->kind)
13972 /* This shouldn't happen. */
13973 printf (" NULL %d %lx", option->section, option->info);
13976 printf (" REGINFO ");
13977 if (elf_header.e_machine == EM_MIPS)
13980 Elf32_External_RegInfo * ereg;
13981 Elf32_RegInfo reginfo;
13983 ereg = (Elf32_External_RegInfo *) (option + 1);
13984 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13985 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13986 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13987 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13988 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13989 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13991 printf ("GPR %08lx GP 0x%lx\n",
13992 reginfo.ri_gprmask,
13993 (unsigned long) reginfo.ri_gp_value);
13994 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13995 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13996 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14001 Elf64_External_RegInfo * ereg;
14002 Elf64_Internal_RegInfo reginfo;
14004 ereg = (Elf64_External_RegInfo *) (option + 1);
14005 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
14006 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
14007 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
14008 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
14009 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
14010 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
14012 printf ("GPR %08lx GP 0x",
14013 reginfo.ri_gprmask);
14014 printf_vma (reginfo.ri_gp_value);
14017 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14018 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
14019 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
14023 case ODK_EXCEPTIONS:
14024 fputs (" EXCEPTIONS fpe_min(", stdout);
14025 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
14026 fputs (") fpe_max(", stdout);
14027 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
14028 fputs (")", stdout);
14030 if (option->info & OEX_PAGE0)
14031 fputs (" PAGE0", stdout);
14032 if (option->info & OEX_SMM)
14033 fputs (" SMM", stdout);
14034 if (option->info & OEX_FPDBUG)
14035 fputs (" FPDBUG", stdout);
14036 if (option->info & OEX_DISMISS)
14037 fputs (" DISMISS", stdout);
14040 fputs (" PAD ", stdout);
14041 if (option->info & OPAD_PREFIX)
14042 fputs (" PREFIX", stdout);
14043 if (option->info & OPAD_POSTFIX)
14044 fputs (" POSTFIX", stdout);
14045 if (option->info & OPAD_SYMBOL)
14046 fputs (" SYMBOL", stdout);
14049 fputs (" HWPATCH ", stdout);
14050 if (option->info & OHW_R4KEOP)
14051 fputs (" R4KEOP", stdout);
14052 if (option->info & OHW_R8KPFETCH)
14053 fputs (" R8KPFETCH", stdout);
14054 if (option->info & OHW_R5KEOP)
14055 fputs (" R5KEOP", stdout);
14056 if (option->info & OHW_R5KCVTL)
14057 fputs (" R5KCVTL", stdout);
14060 fputs (" FILL ", stdout);
14061 /* XXX Print content of info word? */
14064 fputs (" TAGS ", stdout);
14065 /* XXX Print content of info word? */
14068 fputs (" HWAND ", stdout);
14069 if (option->info & OHWA0_R4KEOP_CHECKED)
14070 fputs (" R4KEOP_CHECKED", stdout);
14071 if (option->info & OHWA0_R4KEOP_CLEAN)
14072 fputs (" R4KEOP_CLEAN", stdout);
14075 fputs (" HWOR ", stdout);
14076 if (option->info & OHWA0_R4KEOP_CHECKED)
14077 fputs (" R4KEOP_CHECKED", stdout);
14078 if (option->info & OHWA0_R4KEOP_CLEAN)
14079 fputs (" R4KEOP_CLEAN", stdout);
14082 printf (" GP_GROUP %#06lx self-contained %#06lx",
14083 option->info & OGP_GROUP,
14084 (option->info & OGP_SELF) >> 16);
14087 printf (" IDENT %#06lx self-contained %#06lx",
14088 option->info & OGP_GROUP,
14089 (option->info & OGP_SELF) >> 16);
14092 /* This shouldn't happen. */
14093 printf (" %3d ??? %d %lx",
14094 option->kind, option->section, option->info);
14098 len = sizeof (* eopt);
14099 while (len < option->size)
14101 char datum = * ((char *) eopt + offset + len);
14103 if (ISPRINT (datum))
14104 printf ("%c", datum);
14106 printf ("\\%03o", datum);
14109 fputs ("\n", stdout);
14111 offset += option->size;
14119 if (conflicts_offset != 0 && conflictsno != 0)
14121 Elf32_Conflict * iconf;
14124 if (dynamic_symbols == NULL)
14126 error (_("conflict list found without a dynamic symbol table\n"));
14130 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14133 error (_("Out of memory allocating space for dynamic conflicts\n"));
14139 Elf32_External_Conflict * econf32;
14141 econf32 = (Elf32_External_Conflict *)
14142 get_data (NULL, file, conflicts_offset, conflictsno,
14143 sizeof (* econf32), _("conflict"));
14147 for (cnt = 0; cnt < conflictsno; ++cnt)
14148 iconf[cnt] = BYTE_GET (econf32[cnt]);
14154 Elf64_External_Conflict * econf64;
14156 econf64 = (Elf64_External_Conflict *)
14157 get_data (NULL, file, conflicts_offset, conflictsno,
14158 sizeof (* econf64), _("conflict"));
14162 for (cnt = 0; cnt < conflictsno; ++cnt)
14163 iconf[cnt] = BYTE_GET (econf64[cnt]);
14168 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14169 (unsigned long) conflictsno);
14170 puts (_(" Num: Index Value Name"));
14172 for (cnt = 0; cnt < conflictsno; ++cnt)
14174 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
14176 if (iconf[cnt] >= num_dynamic_syms)
14177 printf (_("<corrupt symbol index>"));
14180 Elf_Internal_Sym * psym;
14182 psym = & dynamic_symbols[iconf[cnt]];
14183 print_vma (psym->st_value, FULL_HEX);
14185 if (VALID_DYNAMIC_NAME (psym->st_name))
14186 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14188 printf (_("<corrupt: %14ld>"), psym->st_name);
14196 if (pltgot != 0 && local_gotno != 0)
14198 bfd_vma ent, local_end, global_end;
14200 unsigned char * data;
14201 unsigned char * data_end;
14205 addr_size = (is_32bit_elf ? 4 : 8);
14206 local_end = pltgot + local_gotno * addr_size;
14208 /* PR binutils/17533 file: 012-111227-0.004 */
14209 if (symtabno < gotsym)
14211 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14212 (unsigned long) gotsym, (unsigned long) symtabno);
14216 global_end = local_end + (symtabno - gotsym) * addr_size;
14217 /* PR 17531: file: 54c91a34. */
14218 if (global_end < local_end)
14220 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14224 offset = offset_from_vma (file, pltgot, global_end - pltgot);
14225 data = (unsigned char *) get_data (NULL, file, offset,
14226 global_end - pltgot, 1,
14227 _("Global Offset Table data"));
14230 data_end = data + (global_end - pltgot);
14232 printf (_("\nPrimary GOT:\n"));
14233 printf (_(" Canonical gp value: "));
14234 print_vma (pltgot + 0x7ff0, LONG_HEX);
14237 printf (_(" Reserved entries:\n"));
14238 printf (_(" %*s %10s %*s Purpose\n"),
14239 addr_size * 2, _("Address"), _("Access"),
14240 addr_size * 2, _("Initial"));
14241 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14242 printf (_(" Lazy resolver\n"));
14243 if (ent == (bfd_vma) -1)
14244 goto got_print_fail;
14246 && (byte_get (data + ent - pltgot, addr_size)
14247 >> (addr_size * 8 - 1)) != 0)
14249 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14250 printf (_(" Module pointer (GNU extension)\n"));
14251 if (ent == (bfd_vma) -1)
14252 goto got_print_fail;
14256 if (ent < local_end)
14258 printf (_(" Local entries:\n"));
14259 printf (" %*s %10s %*s\n",
14260 addr_size * 2, _("Address"), _("Access"),
14261 addr_size * 2, _("Initial"));
14262 while (ent < local_end)
14264 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14266 if (ent == (bfd_vma) -1)
14267 goto got_print_fail;
14272 if (gotsym < symtabno)
14276 printf (_(" Global entries:\n"));
14277 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14278 addr_size * 2, _("Address"),
14280 addr_size * 2, _("Initial"),
14281 addr_size * 2, _("Sym.Val."),
14283 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14284 _("Ndx"), _("Name"));
14286 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14288 for (i = gotsym; i < symtabno; i++)
14290 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14293 if (dynamic_symbols == NULL)
14294 printf (_("<no dynamic symbols>"));
14295 else if (i < num_dynamic_syms)
14297 Elf_Internal_Sym * psym = dynamic_symbols + i;
14299 print_vma (psym->st_value, LONG_HEX);
14300 printf (" %-7s %3s ",
14301 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14302 get_symbol_index_type (psym->st_shndx));
14304 if (VALID_DYNAMIC_NAME (psym->st_name))
14305 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14307 printf (_("<corrupt: %14ld>"), psym->st_name);
14310 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14311 (unsigned long) i);
14314 if (ent == (bfd_vma) -1)
14325 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14328 size_t offset, rel_offset;
14329 unsigned long count, i;
14330 unsigned char * data;
14331 int addr_size, sym_width;
14332 Elf_Internal_Rela * rels;
14334 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14335 if (pltrel == DT_RELA)
14337 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14342 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14347 addr_size = (is_32bit_elf ? 4 : 8);
14348 end = mips_pltgot + (2 + count) * addr_size;
14350 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14351 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14352 1, _("Procedure Linkage Table data"));
14356 printf ("\nPLT GOT:\n\n");
14357 printf (_(" Reserved entries:\n"));
14358 printf (_(" %*s %*s Purpose\n"),
14359 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14360 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14361 printf (_(" PLT lazy resolver\n"));
14362 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14363 printf (_(" Module pointer\n"));
14366 printf (_(" Entries:\n"));
14367 printf (" %*s %*s %*s %-7s %3s %s\n",
14368 addr_size * 2, _("Address"),
14369 addr_size * 2, _("Initial"),
14370 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14371 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14372 for (i = 0; i < count; i++)
14374 unsigned long idx = get_reloc_symindex (rels[i].r_info);
14376 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14379 if (idx >= num_dynamic_syms)
14380 printf (_("<corrupt symbol index: %lu>"), idx);
14383 Elf_Internal_Sym * psym = dynamic_symbols + idx;
14385 print_vma (psym->st_value, LONG_HEX);
14386 printf (" %-7s %3s ",
14387 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14388 get_symbol_index_type (psym->st_shndx));
14389 if (VALID_DYNAMIC_NAME (psym->st_name))
14390 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14392 printf (_("<corrupt: %14ld>"), psym->st_name);
14407 process_nds32_specific (FILE * file)
14409 Elf_Internal_Shdr *sect = NULL;
14411 sect = find_section (".nds32_e_flags");
14414 unsigned int *flag;
14416 printf ("\nNDS32 elf flags section:\n");
14417 flag = get_data (NULL, file, sect->sh_offset, 1,
14418 sect->sh_size, _("NDS32 elf flags section"));
14420 switch ((*flag) & 0x3)
14423 printf ("(VEC_SIZE):\tNo entry.\n");
14426 printf ("(VEC_SIZE):\t4 bytes\n");
14429 printf ("(VEC_SIZE):\t16 bytes\n");
14432 printf ("(VEC_SIZE):\treserved\n");
14441 process_gnu_liblist (FILE * file)
14443 Elf_Internal_Shdr * section;
14444 Elf_Internal_Shdr * string_sec;
14445 Elf32_External_Lib * elib;
14447 size_t strtab_size;
14454 for (i = 0, section = section_headers;
14455 i < elf_header.e_shnum;
14458 switch (section->sh_type)
14460 case SHT_GNU_LIBLIST:
14461 if (section->sh_link >= elf_header.e_shnum)
14464 elib = (Elf32_External_Lib *)
14465 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14466 _("liblist section data"));
14470 string_sec = section_headers + section->sh_link;
14472 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14473 string_sec->sh_size,
14474 _("liblist string table"));
14476 || section->sh_entsize != sizeof (Elf32_External_Lib))
14482 strtab_size = string_sec->sh_size;
14484 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14485 printable_section_name (section),
14486 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14488 puts (_(" Library Time Stamp Checksum Version Flags"));
14490 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14498 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14499 atime = BYTE_GET (elib[cnt].l_time_stamp);
14500 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14501 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14502 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14504 tmp = gmtime (&atime);
14505 snprintf (timebuf, sizeof (timebuf),
14506 "%04u-%02u-%02uT%02u:%02u:%02u",
14507 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14508 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14510 printf ("%3lu: ", (unsigned long) cnt);
14512 printf ("%-20s", liblist.l_name < strtab_size
14513 ? strtab + liblist.l_name : _("<corrupt>"));
14515 printf ("%-20.20s", liblist.l_name < strtab_size
14516 ? strtab + liblist.l_name : _("<corrupt>"));
14517 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14518 liblist.l_version, liblist.l_flags);
14529 static const char *
14530 get_note_type (unsigned e_type)
14532 static char buff[64];
14534 if (elf_header.e_type == ET_CORE)
14538 return _("NT_AUXV (auxiliary vector)");
14540 return _("NT_PRSTATUS (prstatus structure)");
14542 return _("NT_FPREGSET (floating point registers)");
14544 return _("NT_PRPSINFO (prpsinfo structure)");
14545 case NT_TASKSTRUCT:
14546 return _("NT_TASKSTRUCT (task structure)");
14548 return _("NT_PRXFPREG (user_xfpregs structure)");
14550 return _("NT_PPC_VMX (ppc Altivec registers)");
14552 return _("NT_PPC_VSX (ppc VSX registers)");
14554 return _("NT_386_TLS (x86 TLS information)");
14555 case NT_386_IOPERM:
14556 return _("NT_386_IOPERM (x86 I/O permissions)");
14557 case NT_X86_XSTATE:
14558 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14559 case NT_S390_HIGH_GPRS:
14560 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14561 case NT_S390_TIMER:
14562 return _("NT_S390_TIMER (s390 timer register)");
14563 case NT_S390_TODCMP:
14564 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14565 case NT_S390_TODPREG:
14566 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14568 return _("NT_S390_CTRS (s390 control registers)");
14569 case NT_S390_PREFIX:
14570 return _("NT_S390_PREFIX (s390 prefix register)");
14571 case NT_S390_LAST_BREAK:
14572 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14573 case NT_S390_SYSTEM_CALL:
14574 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14576 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14577 case NT_S390_VXRS_LOW:
14578 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14579 case NT_S390_VXRS_HIGH:
14580 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14582 return _("NT_ARM_VFP (arm VFP registers)");
14584 return _("NT_ARM_TLS (AArch TLS registers)");
14585 case NT_ARM_HW_BREAK:
14586 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14587 case NT_ARM_HW_WATCH:
14588 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14590 return _("NT_PSTATUS (pstatus structure)");
14592 return _("NT_FPREGS (floating point registers)");
14594 return _("NT_PSINFO (psinfo structure)");
14596 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14598 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14599 case NT_WIN32PSTATUS:
14600 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14602 return _("NT_SIGINFO (siginfo_t data)");
14604 return _("NT_FILE (mapped files)");
14612 return _("NT_VERSION (version)");
14614 return _("NT_ARCH (architecture)");
14619 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14624 print_core_note (Elf_Internal_Note *pnote)
14626 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14627 bfd_vma count, page_size;
14628 unsigned char *descdata, *filenames, *descend;
14630 if (pnote->type != NT_FILE)
14636 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14637 /* Still "successful". */
14642 if (pnote->descsz < 2 * addr_size)
14644 printf (_(" Malformed note - too short for header\n"));
14648 descdata = (unsigned char *) pnote->descdata;
14649 descend = descdata + pnote->descsz;
14651 if (descdata[pnote->descsz - 1] != '\0')
14653 printf (_(" Malformed note - does not end with \\0\n"));
14657 count = byte_get (descdata, addr_size);
14658 descdata += addr_size;
14660 page_size = byte_get (descdata, addr_size);
14661 descdata += addr_size;
14663 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14665 printf (_(" Malformed note - too short for supplied file count\n"));
14669 printf (_(" Page size: "));
14670 print_vma (page_size, DEC);
14673 printf (_(" %*s%*s%*s\n"),
14674 (int) (2 + 2 * addr_size), _("Start"),
14675 (int) (4 + 2 * addr_size), _("End"),
14676 (int) (4 + 2 * addr_size), _("Page Offset"));
14677 filenames = descdata + count * 3 * addr_size;
14678 while (--count > 0)
14680 bfd_vma start, end, file_ofs;
14682 if (filenames == descend)
14684 printf (_(" Malformed note - filenames end too early\n"));
14688 start = byte_get (descdata, addr_size);
14689 descdata += addr_size;
14690 end = byte_get (descdata, addr_size);
14691 descdata += addr_size;
14692 file_ofs = byte_get (descdata, addr_size);
14693 descdata += addr_size;
14696 print_vma (start, FULL_HEX);
14698 print_vma (end, FULL_HEX);
14700 print_vma (file_ofs, FULL_HEX);
14701 printf ("\n %s\n", filenames);
14703 filenames += 1 + strlen ((char *) filenames);
14709 static const char *
14710 get_gnu_elf_note_type (unsigned e_type)
14712 static char buff[64];
14716 case NT_GNU_ABI_TAG:
14717 return _("NT_GNU_ABI_TAG (ABI version tag)");
14719 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14720 case NT_GNU_BUILD_ID:
14721 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14722 case NT_GNU_GOLD_VERSION:
14723 return _("NT_GNU_GOLD_VERSION (gold version)");
14728 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14733 print_gnu_note (Elf_Internal_Note *pnote)
14735 switch (pnote->type)
14737 case NT_GNU_BUILD_ID:
14741 printf (_(" Build ID: "));
14742 for (i = 0; i < pnote->descsz; ++i)
14743 printf ("%02x", pnote->descdata[i] & 0xff);
14748 case NT_GNU_ABI_TAG:
14750 unsigned long os, major, minor, subminor;
14751 const char *osname;
14753 /* PR 17531: file: 030-599401-0.004. */
14754 if (pnote->descsz < 16)
14756 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14760 os = byte_get ((unsigned char *) pnote->descdata, 4);
14761 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14762 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14763 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14767 case GNU_ABI_TAG_LINUX:
14770 case GNU_ABI_TAG_HURD:
14773 case GNU_ABI_TAG_SOLARIS:
14774 osname = "Solaris";
14776 case GNU_ABI_TAG_FREEBSD:
14777 osname = "FreeBSD";
14779 case GNU_ABI_TAG_NETBSD:
14783 osname = "Unknown";
14787 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14788 major, minor, subminor);
14792 case NT_GNU_GOLD_VERSION:
14796 printf (_(" Version: "));
14797 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14798 printf ("%c", pnote->descdata[i]);
14807 static const char *
14808 get_netbsd_elfcore_note_type (unsigned e_type)
14810 static char buff[64];
14812 if (e_type == NT_NETBSDCORE_PROCINFO)
14814 /* NetBSD core "procinfo" structure. */
14815 return _("NetBSD procinfo structure");
14818 /* As of Jan 2002 there are no other machine-independent notes
14819 defined for NetBSD core files. If the note type is less
14820 than the start of the machine-dependent note types, we don't
14823 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14825 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14829 switch (elf_header.e_machine)
14831 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14832 and PT_GETFPREGS == mach+2. */
14837 case EM_SPARC32PLUS:
14841 case NT_NETBSDCORE_FIRSTMACH + 0:
14842 return _("PT_GETREGS (reg structure)");
14843 case NT_NETBSDCORE_FIRSTMACH + 2:
14844 return _("PT_GETFPREGS (fpreg structure)");
14850 /* On all other arch's, PT_GETREGS == mach+1 and
14851 PT_GETFPREGS == mach+3. */
14855 case NT_NETBSDCORE_FIRSTMACH + 1:
14856 return _("PT_GETREGS (reg structure)");
14857 case NT_NETBSDCORE_FIRSTMACH + 3:
14858 return _("PT_GETFPREGS (fpreg structure)");
14864 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14865 e_type - NT_NETBSDCORE_FIRSTMACH);
14869 static const char *
14870 get_stapsdt_note_type (unsigned e_type)
14872 static char buff[64];
14877 return _("NT_STAPSDT (SystemTap probe descriptors)");
14883 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14888 print_stapsdt_note (Elf_Internal_Note *pnote)
14890 int addr_size = is_32bit_elf ? 4 : 8;
14891 char *data = pnote->descdata;
14892 char *data_end = pnote->descdata + pnote->descsz;
14893 bfd_vma pc, base_addr, semaphore;
14894 char *provider, *probe, *arg_fmt;
14896 pc = byte_get ((unsigned char *) data, addr_size);
14898 base_addr = byte_get ((unsigned char *) data, addr_size);
14900 semaphore = byte_get ((unsigned char *) data, addr_size);
14904 data += strlen (data) + 1;
14906 data += strlen (data) + 1;
14908 data += strlen (data) + 1;
14910 printf (_(" Provider: %s\n"), provider);
14911 printf (_(" Name: %s\n"), probe);
14912 printf (_(" Location: "));
14913 print_vma (pc, FULL_HEX);
14914 printf (_(", Base: "));
14915 print_vma (base_addr, FULL_HEX);
14916 printf (_(", Semaphore: "));
14917 print_vma (semaphore, FULL_HEX);
14919 printf (_(" Arguments: %s\n"), arg_fmt);
14921 return data == data_end;
14924 static const char *
14925 get_ia64_vms_note_type (unsigned e_type)
14927 static char buff[64];
14932 return _("NT_VMS_MHD (module header)");
14934 return _("NT_VMS_LNM (language name)");
14936 return _("NT_VMS_SRC (source files)");
14938 return "NT_VMS_TITLE";
14940 return _("NT_VMS_EIDC (consistency check)");
14941 case NT_VMS_FPMODE:
14942 return _("NT_VMS_FPMODE (FP mode)");
14943 case NT_VMS_LINKTIME:
14944 return "NT_VMS_LINKTIME";
14945 case NT_VMS_IMGNAM:
14946 return _("NT_VMS_IMGNAM (image name)");
14948 return _("NT_VMS_IMGID (image id)");
14949 case NT_VMS_LINKID:
14950 return _("NT_VMS_LINKID (link id)");
14951 case NT_VMS_IMGBID:
14952 return _("NT_VMS_IMGBID (build id)");
14953 case NT_VMS_GSTNAM:
14954 return _("NT_VMS_GSTNAM (sym table name)");
14955 case NT_VMS_ORIG_DYN:
14956 return "NT_VMS_ORIG_DYN";
14957 case NT_VMS_PATCHTIME:
14958 return "NT_VMS_PATCHTIME";
14960 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14966 print_ia64_vms_note (Elf_Internal_Note * pnote)
14968 switch (pnote->type)
14971 if (pnote->descsz > 36)
14973 size_t l = strlen (pnote->descdata + 34);
14974 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14975 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14976 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14977 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14980 printf (_(" Invalid size\n"));
14983 printf (_(" Language: %s\n"), pnote->descdata);
14986 case NT_VMS_FPMODE:
14987 printf (_(" Floating Point mode: "));
14988 printf ("0x%016" BFD_VMA_FMT "x\n",
14989 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
14991 case NT_VMS_LINKTIME:
14992 printf (_(" Link time: "));
14994 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14997 case NT_VMS_PATCHTIME:
14998 printf (_(" Patch time: "));
15000 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
15003 case NT_VMS_ORIG_DYN:
15004 printf (_(" Major id: %u, minor id: %u\n"),
15005 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
15006 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
15007 printf (_(" Last modified : "));
15009 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
15010 printf (_("\n Link flags : "));
15011 printf ("0x%016" BFD_VMA_FMT "x\n",
15012 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
15013 printf (_(" Header flags: 0x%08x\n"),
15014 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
15015 printf (_(" Image id : %s\n"), pnote->descdata + 32);
15018 case NT_VMS_IMGNAM:
15019 printf (_(" Image name: %s\n"), pnote->descdata);
15021 case NT_VMS_GSTNAM:
15022 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
15025 printf (_(" Image id: %s\n"), pnote->descdata);
15027 case NT_VMS_LINKID:
15028 printf (_(" Linker id: %s\n"), pnote->descdata);
15036 /* Note that by the ELF standard, the name field is already null byte
15037 terminated, and namesz includes the terminating null byte.
15038 I.E. the value of namesz for the name "FSF" is 4.
15040 If the value of namesz is zero, there is no name present. */
15042 process_note (Elf_Internal_Note * pnote)
15044 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
15047 if (pnote->namesz == 0)
15048 /* If there is no note name, then use the default set of
15049 note type strings. */
15050 nt = get_note_type (pnote->type);
15052 else if (const_strneq (pnote->namedata, "GNU"))
15053 /* GNU-specific object file notes. */
15054 nt = get_gnu_elf_note_type (pnote->type);
15056 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
15057 /* NetBSD-specific core file notes. */
15058 nt = get_netbsd_elfcore_note_type (pnote->type);
15060 else if (strneq (pnote->namedata, "SPU/", 4))
15062 /* SPU-specific core file notes. */
15063 nt = pnote->namedata + 4;
15067 else if (const_strneq (pnote->namedata, "IPF/VMS"))
15068 /* VMS/ia64-specific file notes. */
15069 nt = get_ia64_vms_note_type (pnote->type);
15071 else if (const_strneq (pnote->namedata, "stapsdt"))
15072 nt = get_stapsdt_note_type (pnote->type);
15075 /* Don't recognize this note name; just use the default set of
15076 note type strings. */
15077 nt = get_note_type (pnote->type);
15079 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15081 if (const_strneq (pnote->namedata, "IPF/VMS"))
15082 return print_ia64_vms_note (pnote);
15083 else if (const_strneq (pnote->namedata, "GNU"))
15084 return print_gnu_note (pnote);
15085 else if (const_strneq (pnote->namedata, "stapsdt"))
15086 return print_stapsdt_note (pnote);
15087 else if (const_strneq (pnote->namedata, "CORE"))
15088 return print_core_note (pnote);
15095 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15097 Elf_External_Note * pnotes;
15098 Elf_External_Note * external;
15104 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15106 if (pnotes == NULL)
15111 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15112 (unsigned long) offset, (unsigned long) length);
15113 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15115 while ((char *) external < (char *) pnotes + length)
15117 Elf_Internal_Note inote;
15120 char * temp = NULL;
15121 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
15123 if (!is_ia64_vms ())
15125 /* PR binutils/15191
15126 Make sure that there is enough data to read. */
15127 min_notesz = offsetof (Elf_External_Note, name);
15128 if (data_remaining < min_notesz)
15130 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15131 (int) data_remaining);
15134 inote.type = BYTE_GET (external->type);
15135 inote.namesz = BYTE_GET (external->namesz);
15136 inote.namedata = external->name;
15137 inote.descsz = BYTE_GET (external->descsz);
15138 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15139 /* PR 17531: file: 3443835e. */
15140 if (inote.descdata < (char *) pnotes)
15142 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
15143 inote.descdata = inote.namedata;
15146 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15147 next = inote.descdata + align_power (inote.descsz, 2);
15151 Elf64_External_VMS_Note *vms_external;
15153 /* PR binutils/15191
15154 Make sure that there is enough data to read. */
15155 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15156 if (data_remaining < min_notesz)
15158 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15159 (int) data_remaining);
15163 vms_external = (Elf64_External_VMS_Note *) external;
15164 inote.type = BYTE_GET (vms_external->type);
15165 inote.namesz = BYTE_GET (vms_external->namesz);
15166 inote.namedata = vms_external->name;
15167 inote.descsz = BYTE_GET (vms_external->descsz);
15168 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15169 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15170 next = inote.descdata + align_power (inote.descsz, 3);
15173 if (inote.descdata < (char *) external + min_notesz
15174 || next < (char *) external + min_notesz
15175 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15176 || inote.namedata + inote.namesz < inote.namedata
15177 || inote.descdata + inote.descsz < inote.descdata
15178 || data_remaining < (size_t)(next - (char *) external))
15180 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15181 (unsigned long) ((char *) external - (char *) pnotes));
15182 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15183 inote.type, inote.namesz, inote.descsz);
15187 external = (Elf_External_Note *) next;
15189 /* Verify that name is null terminated. It appears that at least
15190 one version of Linux (RedHat 6.0) generates corefiles that don't
15191 comply with the ELF spec by failing to include the null byte in
15193 if (inote.namedata[inote.namesz - 1] != '\0')
15195 temp = (char *) malloc (inote.namesz + 1);
15198 error (_("Out of memory allocating space for inote name\n"));
15203 strncpy (temp, inote.namedata, inote.namesz);
15204 temp[inote.namesz] = 0;
15206 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15207 inote.namedata = temp;
15210 res &= process_note (& inote);
15225 process_corefile_note_segments (FILE * file)
15227 Elf_Internal_Phdr * segment;
15231 if (! get_program_headers (file))
15234 for (i = 0, segment = program_headers;
15235 i < elf_header.e_phnum;
15238 if (segment->p_type == PT_NOTE)
15239 res &= process_corefile_note_segment (file,
15240 (bfd_vma) segment->p_offset,
15241 (bfd_vma) segment->p_filesz);
15248 process_note_sections (FILE * file)
15250 Elf_Internal_Shdr * section;
15255 for (i = 0, section = section_headers;
15256 i < elf_header.e_shnum && section != NULL;
15258 if (section->sh_type == SHT_NOTE)
15260 res &= process_corefile_note_segment (file,
15261 (bfd_vma) section->sh_offset,
15262 (bfd_vma) section->sh_size);
15267 /* Try processing NOTE segments instead. */
15268 return process_corefile_note_segments (file);
15274 process_notes (FILE * file)
15276 /* If we have not been asked to display the notes then do nothing. */
15280 if (elf_header.e_type != ET_CORE)
15281 return process_note_sections (file);
15283 /* No program headers means no NOTE segment. */
15284 if (elf_header.e_phnum > 0)
15285 return process_corefile_note_segments (file);
15287 printf (_("No note segments present in the core file.\n"));
15292 process_arch_specific (FILE * file)
15297 switch (elf_header.e_machine)
15300 return process_arm_specific (file);
15302 case EM_MIPS_RS3_LE:
15303 return process_mips_specific (file);
15306 return process_nds32_specific (file);
15309 return process_power_specific (file);
15312 case EM_SPARC32PLUS:
15314 return process_sparc_specific (file);
15317 return process_tic6x_specific (file);
15320 return process_msp430x_specific (file);
15328 get_file_header (FILE * file)
15330 /* Read in the identity array. */
15331 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15334 /* Determine how to read the rest of the header. */
15335 switch (elf_header.e_ident[EI_DATA])
15337 default: /* fall through */
15338 case ELFDATANONE: /* fall through */
15340 byte_get = byte_get_little_endian;
15341 byte_put = byte_put_little_endian;
15344 byte_get = byte_get_big_endian;
15345 byte_put = byte_put_big_endian;
15349 /* For now we only support 32 bit and 64 bit ELF files. */
15350 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15352 /* Read in the rest of the header. */
15355 Elf32_External_Ehdr ehdr32;
15357 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15360 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15361 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15362 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15363 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15364 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15365 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15366 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15367 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15368 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15369 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15370 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15371 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15372 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15376 Elf64_External_Ehdr ehdr64;
15378 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15379 we will not be able to cope with the 64bit data found in
15380 64 ELF files. Detect this now and abort before we start
15381 overwriting things. */
15382 if (sizeof (bfd_vma) < 8)
15384 error (_("This instance of readelf has been built without support for a\n\
15385 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15389 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15392 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15393 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15394 elf_header.e_version = BYTE_GET (ehdr64.e_version);
15395 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15396 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15397 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
15398 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15399 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15400 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15401 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15402 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15403 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15404 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15407 if (elf_header.e_shoff)
15409 /* There may be some extensions in the first section header. Don't
15410 bomb if we can't read it. */
15412 get_32bit_section_headers (file, TRUE);
15414 get_64bit_section_headers (file, TRUE);
15420 /* Process one ELF object file according to the command line options.
15421 This file may actually be stored in an archive. The file is
15422 positioned at the start of the ELF object. */
15425 process_object (char * file_name, FILE * file)
15429 if (! get_file_header (file))
15431 error (_("%s: Failed to read file header\n"), file_name);
15435 /* Initialise per file variables. */
15436 for (i = ARRAY_SIZE (version_info); i--;)
15437 version_info[i] = 0;
15439 for (i = ARRAY_SIZE (dynamic_info); i--;)
15440 dynamic_info[i] = 0;
15441 dynamic_info_DT_GNU_HASH = 0;
15443 /* Process the file. */
15445 printf (_("\nFile: %s\n"), file_name);
15447 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15448 Note we do this even if cmdline_dump_sects is empty because we
15449 must make sure that the dump_sets array is zeroed out before each
15450 object file is processed. */
15451 if (num_dump_sects > num_cmdline_dump_sects)
15452 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15454 if (num_cmdline_dump_sects > 0)
15456 if (num_dump_sects == 0)
15457 /* A sneaky way of allocating the dump_sects array. */
15458 request_dump_bynumber (num_cmdline_dump_sects, 0);
15460 assert (num_dump_sects >= num_cmdline_dump_sects);
15461 memcpy (dump_sects, cmdline_dump_sects,
15462 num_cmdline_dump_sects * sizeof (* dump_sects));
15465 if (! process_file_header ())
15468 if (! process_section_headers (file))
15470 /* Without loaded section headers we cannot process lots of
15472 do_unwind = do_version = do_dump = do_arch = 0;
15474 if (! do_using_dynamic)
15475 do_syms = do_dyn_syms = do_reloc = 0;
15478 if (! process_section_groups (file))
15480 /* Without loaded section groups we cannot process unwind. */
15484 if (process_program_headers (file))
15485 process_dynamic_section (file);
15487 process_relocs (file);
15489 process_unwind (file);
15491 process_symbol_table (file);
15493 process_syminfo (file);
15495 process_version_sections (file);
15497 process_section_contents (file);
15499 process_notes (file);
15501 process_gnu_liblist (file);
15503 process_arch_specific (file);
15505 if (program_headers)
15507 free (program_headers);
15508 program_headers = NULL;
15511 if (section_headers)
15513 free (section_headers);
15514 section_headers = NULL;
15519 free (string_table);
15520 string_table = NULL;
15521 string_table_length = 0;
15524 if (dynamic_strings)
15526 free (dynamic_strings);
15527 dynamic_strings = NULL;
15528 dynamic_strings_length = 0;
15531 if (dynamic_symbols)
15533 free (dynamic_symbols);
15534 dynamic_symbols = NULL;
15535 num_dynamic_syms = 0;
15538 if (dynamic_syminfo)
15540 free (dynamic_syminfo);
15541 dynamic_syminfo = NULL;
15544 if (dynamic_section)
15546 free (dynamic_section);
15547 dynamic_section = NULL;
15550 if (section_headers_groups)
15552 free (section_headers_groups);
15553 section_headers_groups = NULL;
15556 if (section_groups)
15558 struct group_list * g;
15559 struct group_list * next;
15561 for (i = 0; i < group_count; i++)
15563 for (g = section_groups [i].root; g != NULL; g = next)
15570 free (section_groups);
15571 section_groups = NULL;
15574 free_debug_memory ();
15579 /* Process an ELF archive.
15580 On entry the file is positioned just after the ARMAG string. */
15583 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15585 struct archive_info arch;
15586 struct archive_info nested_arch;
15592 /* The ARCH structure is used to hold information about this archive. */
15593 arch.file_name = NULL;
15595 arch.index_array = NULL;
15596 arch.sym_table = NULL;
15597 arch.longnames = NULL;
15599 /* The NESTED_ARCH structure is used as a single-item cache of information
15600 about a nested archive (when members of a thin archive reside within
15601 another regular archive file). */
15602 nested_arch.file_name = NULL;
15603 nested_arch.file = NULL;
15604 nested_arch.index_array = NULL;
15605 nested_arch.sym_table = NULL;
15606 nested_arch.longnames = NULL;
15608 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15614 if (do_archive_index)
15616 if (arch.sym_table == NULL)
15617 error (_("%s: unable to dump the index as none was found\n"), file_name);
15620 unsigned long i, l;
15621 unsigned long current_pos;
15623 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15624 file_name, (unsigned long) arch.index_num, arch.sym_size);
15625 current_pos = ftell (file);
15627 for (i = l = 0; i < arch.index_num; i++)
15629 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15631 char * member_name;
15633 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15635 if (member_name != NULL)
15637 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15639 if (qualified_name != NULL)
15641 printf (_("Contents of binary %s at offset "), qualified_name);
15642 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15644 free (qualified_name);
15649 if (l >= arch.sym_size)
15651 error (_("%s: end of the symbol table reached before the end of the index\n"),
15655 /* PR 17531: file: 0b6630b2. */
15656 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15657 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15660 if (arch.uses_64bit_indicies)
15665 if (l < arch.sym_size)
15666 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15667 file_name, arch.sym_size - l);
15669 if (fseek (file, current_pos, SEEK_SET) != 0)
15671 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15677 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15678 && !do_segments && !do_header && !do_dump && !do_version
15679 && !do_histogram && !do_debugging && !do_arch && !do_notes
15680 && !do_section_groups && !do_dyn_syms)
15682 ret = 0; /* Archive index only. */
15693 char * qualified_name;
15695 /* Read the next archive header. */
15696 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15698 error (_("%s: failed to seek to next archive header\n"), file_name);
15701 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15702 if (got != sizeof arch.arhdr)
15706 error (_("%s: failed to read archive header\n"), file_name);
15710 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15712 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15717 arch.next_arhdr_offset += sizeof arch.arhdr;
15719 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15720 if (archive_file_size & 01)
15721 ++archive_file_size;
15723 name = get_archive_member_name (&arch, &nested_arch);
15726 error (_("%s: bad archive file name\n"), file_name);
15730 namelen = strlen (name);
15732 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15733 if (qualified_name == NULL)
15735 error (_("%s: bad archive file name\n"), file_name);
15740 if (is_thin_archive && arch.nested_member_origin == 0)
15742 /* This is a proxy for an external member of a thin archive. */
15743 FILE * member_file;
15744 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15745 if (member_file_name == NULL)
15751 member_file = fopen (member_file_name, "rb");
15752 if (member_file == NULL)
15754 error (_("Input file '%s' is not readable.\n"), member_file_name);
15755 free (member_file_name);
15760 archive_file_offset = arch.nested_member_origin;
15762 ret |= process_object (qualified_name, member_file);
15764 fclose (member_file);
15765 free (member_file_name);
15767 else if (is_thin_archive)
15769 /* PR 15140: Allow for corrupt thin archives. */
15770 if (nested_arch.file == NULL)
15772 error (_("%s: contains corrupt thin archive: %s\n"),
15778 /* This is a proxy for a member of a nested archive. */
15779 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15781 /* The nested archive file will have been opened and setup by
15782 get_archive_member_name. */
15783 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15785 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15790 ret |= process_object (qualified_name, nested_arch.file);
15794 archive_file_offset = arch.next_arhdr_offset;
15795 arch.next_arhdr_offset += archive_file_size;
15797 ret |= process_object (qualified_name, file);
15800 if (dump_sects != NULL)
15804 num_dump_sects = 0;
15807 free (qualified_name);
15811 if (nested_arch.file != NULL)
15812 fclose (nested_arch.file);
15813 release_archive (&nested_arch);
15814 release_archive (&arch);
15820 process_file (char * file_name)
15823 struct stat statbuf;
15824 char armag[SARMAG];
15827 if (stat (file_name, &statbuf) < 0)
15829 if (errno == ENOENT)
15830 error (_("'%s': No such file\n"), file_name);
15832 error (_("Could not locate '%s'. System error message: %s\n"),
15833 file_name, strerror (errno));
15837 if (! S_ISREG (statbuf.st_mode))
15839 error (_("'%s' is not an ordinary file\n"), file_name);
15843 file = fopen (file_name, "rb");
15846 error (_("Input file '%s' is not readable.\n"), file_name);
15850 if (fread (armag, SARMAG, 1, file) != 1)
15852 error (_("%s: Failed to read file's magic number\n"), file_name);
15857 current_file_size = (bfd_size_type) statbuf.st_size;
15859 if (memcmp (armag, ARMAG, SARMAG) == 0)
15860 ret = process_archive (file_name, file, FALSE);
15861 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15862 ret = process_archive (file_name, file, TRUE);
15865 if (do_archive_index)
15866 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15870 archive_file_size = archive_file_offset = 0;
15871 ret = process_object (file_name, file);
15876 current_file_size = 0;
15880 #ifdef SUPPORT_DISASSEMBLY
15881 /* Needed by the i386 disassembler. For extra credit, someone could
15882 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15886 print_address (unsigned int addr, FILE * outfile)
15888 fprintf (outfile,"0x%8.8x", addr);
15891 /* Needed by the i386 disassembler. */
15893 db_task_printsym (unsigned int addr)
15895 print_address (addr, stderr);
15900 main (int argc, char ** argv)
15904 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15905 setlocale (LC_MESSAGES, "");
15907 #if defined (HAVE_SETLOCALE)
15908 setlocale (LC_CTYPE, "");
15910 bindtextdomain (PACKAGE, LOCALEDIR);
15911 textdomain (PACKAGE);
15913 expandargv (&argc, &argv);
15915 parse_args (argc, argv);
15917 if (num_dump_sects > 0)
15919 /* Make a copy of the dump_sects array. */
15920 cmdline_dump_sects = (dump_type *)
15921 malloc (num_dump_sects * sizeof (* dump_sects));
15922 if (cmdline_dump_sects == NULL)
15923 error (_("Out of memory allocating dump request table.\n"));
15926 memcpy (cmdline_dump_sects, dump_sects,
15927 num_dump_sects * sizeof (* dump_sects));
15928 num_cmdline_dump_sects = num_dump_sects;
15932 if (optind < (argc - 1))
15936 while (optind < argc)
15937 err |= process_file (argv[optind++]);
15939 if (dump_sects != NULL)
15941 if (cmdline_dump_sects != NULL)
15942 free (cmdline_dump_sects);