1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
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/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr * hdr;
173 struct elf_section_list * next;
176 char * program_name = "readelf";
177 static unsigned long archive_file_offset;
178 static unsigned long archive_file_size;
179 static bfd_size_type current_file_size;
180 static unsigned long dynamic_addr;
181 static bfd_size_type dynamic_size;
182 static size_t dynamic_nent;
183 static char * dynamic_strings;
184 static unsigned long dynamic_strings_length;
185 static char * string_table;
186 static unsigned long string_table_length;
187 static unsigned long num_dynamic_syms;
188 static Elf_Internal_Sym * dynamic_symbols;
189 static Elf_Internal_Syminfo * dynamic_syminfo;
190 static unsigned long dynamic_syminfo_offset;
191 static unsigned int dynamic_syminfo_nent;
192 static char program_interpreter[PATH_MAX];
193 static bfd_vma dynamic_info[DT_ENCODING];
194 static bfd_vma dynamic_info_DT_GNU_HASH;
195 static bfd_vma version_info[16];
196 static Elf_Internal_Ehdr elf_header;
197 static Elf_Internal_Shdr * section_headers;
198 static Elf_Internal_Phdr * program_headers;
199 static Elf_Internal_Dyn * dynamic_section;
200 static elf_section_list * symtab_shndx_list;
201 static bfd_boolean show_name = FALSE;
202 static bfd_boolean do_dynamic = FALSE;
203 static bfd_boolean do_syms = FALSE;
204 static bfd_boolean do_dyn_syms = FALSE;
205 static bfd_boolean do_reloc = FALSE;
206 static bfd_boolean do_sections = FALSE;
207 static bfd_boolean do_section_groups = FALSE;
208 static bfd_boolean do_section_details = FALSE;
209 static bfd_boolean do_segments = FALSE;
210 static bfd_boolean do_unwind = FALSE;
211 static bfd_boolean do_using_dynamic = FALSE;
212 static bfd_boolean do_header = FALSE;
213 static bfd_boolean do_dump = FALSE;
214 static bfd_boolean do_version = FALSE;
215 static bfd_boolean do_histogram = FALSE;
216 static bfd_boolean do_debugging = FALSE;
217 static bfd_boolean do_arch = FALSE;
218 static bfd_boolean do_notes = FALSE;
219 static bfd_boolean do_archive_index = FALSE;
220 static bfd_boolean is_32bit_elf = FALSE;
221 static bfd_boolean decompress_dumps = FALSE;
225 struct group_list * next;
226 unsigned int section_index;
231 struct group_list * root;
232 unsigned int group_index;
235 static size_t group_count;
236 static struct group * section_groups;
237 static struct group ** section_headers_groups;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry * next;
256 static struct dump_list_entry * dump_sects_byname;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type * cmdline_dump_sects = NULL;
261 static unsigned int num_cmdline_dump_sects = 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type * dump_sects = NULL;
269 static unsigned int num_dump_sects = 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Print a BFD_VMA to an internal buffer, for use in error messages.
325 BFD_FMA_FMT can't be used in translated strings. */
328 bfd_vmatoa (char *fmtch, bfd_vma value)
330 /* bfd_vmatoa is used more then once in a printf call for output.
331 Cycle through an array of buffers. */
332 static int buf_pos = 0;
333 static struct bfd_vmatoa_buf
340 ret = buf[buf_pos++].place;
341 buf_pos %= ARRAY_SIZE (buf);
343 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
344 snprintf (ret, sizeof (buf[0].place), fmt, value);
348 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
349 the offset of the current archive member, if we are examining an archive.
350 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
351 using malloc and fill that. In either case return the pointer to the start of
352 the retrieved data or NULL if something went wrong. If something does go wrong
353 and REASON is not NULL then emit an error message using REASON as part of the
357 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
358 bfd_size_type nmemb, const char * reason)
361 bfd_size_type amt = size * nmemb;
363 if (size == 0 || nmemb == 0)
366 /* If the size_t type is smaller than the bfd_size_type, eg because
367 you are building a 32-bit tool on a 64-bit host, then make sure
368 that when the sizes are cast to (size_t) no information is lost. */
369 if (sizeof (size_t) < sizeof (bfd_size_type)
370 && ( (bfd_size_type) ((size_t) size) != size
371 || (bfd_size_type) ((size_t) nmemb) != nmemb))
374 error (_("Size truncation prevents reading %s"
375 " elements of size %s for %s\n"),
376 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
380 /* Check for size overflow. */
384 error (_("Size overflow prevents reading %s"
385 " elements of size %s for %s\n"),
386 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
390 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
391 attempting to allocate memory when the read is bound to fail. */
392 if (amt > current_file_size
393 || offset + archive_file_offset + amt > current_file_size)
396 error (_("Reading %s bytes extends past end of file for %s\n"),
397 bfd_vmatoa ("u", amt), reason);
401 if (fseek (file, archive_file_offset + offset, SEEK_SET))
404 error (_("Unable to seek to 0x%lx for %s\n"),
405 archive_file_offset + offset, reason);
412 /* Check for overflow. */
413 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
414 /* + 1 so that we can '\0' terminate invalid string table sections. */
415 mvar = malloc ((size_t) amt + 1);
420 error (_("Out of memory allocating %s bytes for %s\n"),
421 bfd_vmatoa ("u", amt), reason);
425 ((char *) mvar)[amt] = '\0';
428 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
431 error (_("Unable to read in %s bytes of %s\n"),
432 bfd_vmatoa ("u", amt), reason);
441 /* Print a VMA value in the MODE specified.
442 Returns the number of characters displayed. */
445 print_vma (bfd_vma vma, print_mode mode)
457 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
464 return printf ("%5" BFD_VMA_FMT "d", vma);
470 return nc + printf ("%" BFD_VMA_FMT "x", vma);
473 return printf ("%" BFD_VMA_FMT "d", vma);
476 return printf ("%" BFD_VMA_FMT "u", vma);
479 /* FIXME: Report unrecognised mode ? */
484 /* Display a symbol on stdout. Handles the display of control characters and
485 multibye characters (assuming the host environment supports them).
487 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
489 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
490 padding as necessary.
492 Returns the number of emitted characters. */
495 print_symbol (signed int width, const char *symbol)
497 bfd_boolean extra_padding = FALSE;
498 signed int num_printed = 0;
499 #ifdef HAVE_MBSTATE_T
502 unsigned int width_remaining;
506 /* Keep the width positive. This helps the code below. */
508 extra_padding = TRUE;
513 /* Set the remaining width to a very large value.
514 This simplifies the code below. */
515 width_remaining = INT_MAX;
517 width_remaining = width;
519 #ifdef HAVE_MBSTATE_T
520 /* Initialise the multibyte conversion state. */
521 memset (& state, 0, sizeof (state));
524 while (width_remaining)
527 const char c = *symbol++;
532 /* Do not print control characters directly as they can affect terminal
533 settings. Such characters usually appear in the names generated
534 by the assembler for local labels. */
537 if (width_remaining < 2)
540 printf ("^%c", c + 0x40);
541 width_remaining -= 2;
544 else if (ISPRINT (c))
552 #ifdef HAVE_MBSTATE_T
555 /* Let printf do the hard work of displaying multibyte characters. */
556 printf ("%.1s", symbol - 1);
560 #ifdef HAVE_MBSTATE_T
561 /* Try to find out how many bytes made up the character that was
562 just printed. Advance the symbol pointer past the bytes that
564 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
568 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
573 if (extra_padding && num_printed < width)
575 /* Fill in the remaining spaces. */
576 printf ("%-*s", width - num_printed, " ");
583 /* Returns a pointer to a static buffer containing a printable version of
584 the given section's name. Like print_symbol, except that it does not try
585 to print multibyte characters, it just interprets them as hex values. */
588 printable_section_name (const Elf_Internal_Shdr * sec)
590 #define MAX_PRINT_SEC_NAME_LEN 128
591 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
592 const char * name = SECTION_NAME (sec);
593 char * buf = sec_name_buf;
595 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
597 while ((c = * name ++) != 0)
608 else if (ISPRINT (c))
615 static char hex[17] = "0123456789ABCDEF";
620 * buf ++ = hex[(c & 0xf0) >> 4];
621 * buf ++ = hex[c & 0x0f];
635 printable_section_name_from_index (unsigned long ndx)
637 if (ndx >= elf_header.e_shnum)
638 return _("<corrupt>");
640 return printable_section_name (section_headers + ndx);
643 /* Return a pointer to section NAME, or NULL if no such section exists. */
645 static Elf_Internal_Shdr *
646 find_section (const char * name)
650 for (i = 0; i < elf_header.e_shnum; i++)
651 if (streq (SECTION_NAME (section_headers + i), name))
652 return section_headers + i;
657 /* Return a pointer to a section containing ADDR, or NULL if no such
660 static Elf_Internal_Shdr *
661 find_section_by_address (bfd_vma addr)
665 for (i = 0; i < elf_header.e_shnum; i++)
667 Elf_Internal_Shdr *sec = section_headers + i;
668 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
675 static Elf_Internal_Shdr *
676 find_section_by_type (unsigned int type)
680 for (i = 0; i < elf_header.e_shnum; i++)
682 Elf_Internal_Shdr *sec = section_headers + i;
683 if (sec->sh_type == type)
690 /* Return a pointer to section NAME, or NULL if no such section exists,
691 restricted to the list of sections given in SET. */
693 static Elf_Internal_Shdr *
694 find_section_in_set (const char * name, unsigned int * set)
700 while ((i = *set++) > 0)
702 /* See PR 21156 for a reproducer. */
703 if (i >= elf_header.e_shnum)
704 continue; /* FIXME: Should we issue an error message ? */
706 if (streq (SECTION_NAME (section_headers + i), name))
707 return section_headers + i;
711 return find_section (name);
714 /* Read an unsigned LEB128 encoded value from DATA.
715 Set *LENGTH_RETURN to the number of bytes read. */
717 static inline unsigned long
718 read_uleb128 (unsigned char * data,
719 unsigned int * length_return,
720 const unsigned char * const end)
722 return read_leb128 (data, length_return, FALSE, end);
725 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
726 This OS has so many departures from the ELF standard that we test it at
729 static inline bfd_boolean
732 return elf_header.e_machine == EM_IA_64
733 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
736 /* Guess the relocation size commonly used by the specific machines. */
739 guess_is_rela (unsigned int e_machine)
743 /* Targets that use REL relocations. */
758 /* Targets that use RELA relocations. */
762 case EM_ADAPTEVA_EPIPHANY:
764 case EM_ALTERA_NIOS2:
767 case EM_ARC_COMPACT2:
787 case EM_LATTICEMICO32:
796 case EM_CYGNUS_MN10200:
798 case EM_CYGNUS_MN10300:
834 case EM_MICROBLAZE_OLD:
856 warn (_("Don't know about relocations on this machine architecture\n"));
861 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
862 Returns TRUE upon success, FALSE otherwise. If successful then a
863 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
864 and the number of relocs loaded is placed in *NRELASP. It is the caller's
865 responsibility to free the allocated buffer. */
868 slurp_rela_relocs (FILE * file,
869 unsigned long rel_offset,
870 unsigned long rel_size,
871 Elf_Internal_Rela ** relasp,
872 unsigned long * nrelasp)
874 Elf_Internal_Rela * relas;
880 Elf32_External_Rela * erelas;
882 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
883 rel_size, _("32-bit relocation data"));
887 nrelas = rel_size / sizeof (Elf32_External_Rela);
889 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
890 sizeof (Elf_Internal_Rela));
895 error (_("out of memory parsing relocs\n"));
899 for (i = 0; i < nrelas; i++)
901 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
902 relas[i].r_info = BYTE_GET (erelas[i].r_info);
903 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
910 Elf64_External_Rela * erelas;
912 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
913 rel_size, _("64-bit relocation data"));
917 nrelas = rel_size / sizeof (Elf64_External_Rela);
919 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
920 sizeof (Elf_Internal_Rela));
925 error (_("out of memory parsing relocs\n"));
929 for (i = 0; i < nrelas; i++)
931 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
932 relas[i].r_info = BYTE_GET (erelas[i].r_info);
933 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
935 /* The #ifdef BFD64 below is to prevent a compile time
936 warning. We know that if we do not have a 64 bit data
937 type that we will never execute this code anyway. */
939 if (elf_header.e_machine == EM_MIPS
940 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
942 /* In little-endian objects, r_info isn't really a
943 64-bit little-endian value: it has a 32-bit
944 little-endian symbol index followed by four
945 individual byte fields. Reorder INFO
947 bfd_vma inf = relas[i].r_info;
948 inf = (((inf & 0xffffffff) << 32)
949 | ((inf >> 56) & 0xff)
950 | ((inf >> 40) & 0xff00)
951 | ((inf >> 24) & 0xff0000)
952 | ((inf >> 8) & 0xff000000));
953 relas[i].r_info = inf;
966 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
967 Returns TRUE upon success, FALSE otherwise. If successful then a
968 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
969 and the number of relocs loaded is placed in *NRELSP. It is the caller's
970 responsibility to free the allocated buffer. */
973 slurp_rel_relocs (FILE * file,
974 unsigned long rel_offset,
975 unsigned long rel_size,
976 Elf_Internal_Rela ** relsp,
977 unsigned long * nrelsp)
979 Elf_Internal_Rela * rels;
985 Elf32_External_Rel * erels;
987 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
988 rel_size, _("32-bit relocation data"));
992 nrels = rel_size / sizeof (Elf32_External_Rel);
994 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
999 error (_("out of memory parsing relocs\n"));
1003 for (i = 0; i < nrels; i++)
1005 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1006 rels[i].r_info = BYTE_GET (erels[i].r_info);
1007 rels[i].r_addend = 0;
1014 Elf64_External_Rel * erels;
1016 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
1017 rel_size, _("64-bit relocation data"));
1021 nrels = rel_size / sizeof (Elf64_External_Rel);
1023 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1028 error (_("out of memory parsing relocs\n"));
1032 for (i = 0; i < nrels; i++)
1034 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1035 rels[i].r_info = BYTE_GET (erels[i].r_info);
1036 rels[i].r_addend = 0;
1038 /* The #ifdef BFD64 below is to prevent a compile time
1039 warning. We know that if we do not have a 64 bit data
1040 type that we will never execute this code anyway. */
1042 if (elf_header.e_machine == EM_MIPS
1043 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1045 /* In little-endian objects, r_info isn't really a
1046 64-bit little-endian value: it has a 32-bit
1047 little-endian symbol index followed by four
1048 individual byte fields. Reorder INFO
1050 bfd_vma inf = rels[i].r_info;
1051 inf = (((inf & 0xffffffff) << 32)
1052 | ((inf >> 56) & 0xff)
1053 | ((inf >> 40) & 0xff00)
1054 | ((inf >> 24) & 0xff0000)
1055 | ((inf >> 8) & 0xff000000));
1056 rels[i].r_info = inf;
1069 /* Returns the reloc type extracted from the reloc info field. */
1072 get_reloc_type (bfd_vma reloc_info)
1075 return ELF32_R_TYPE (reloc_info);
1077 switch (elf_header.e_machine)
1080 /* Note: We assume that reloc_info has already been adjusted for us. */
1081 return ELF64_MIPS_R_TYPE (reloc_info);
1084 return ELF64_R_TYPE_ID (reloc_info);
1087 return ELF64_R_TYPE (reloc_info);
1091 /* Return the symbol index extracted from the reloc info field. */
1094 get_reloc_symindex (bfd_vma reloc_info)
1096 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1099 static inline bfd_boolean
1100 uses_msp430x_relocs (void)
1103 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1104 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1105 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1106 /* TI compiler uses ELFOSABI_NONE. */
1107 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1110 /* Display the contents of the relocation data found at the specified
1114 dump_relocations (FILE * file,
1115 unsigned long rel_offset,
1116 unsigned long rel_size,
1117 Elf_Internal_Sym * symtab,
1118 unsigned long nsyms,
1120 unsigned long strtablen,
1122 bfd_boolean is_dynsym)
1125 Elf_Internal_Rela * rels;
1126 bfd_boolean res = TRUE;
1128 if (is_rela == UNKNOWN)
1129 is_rela = guess_is_rela (elf_header.e_machine);
1133 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1138 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1147 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1149 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1154 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1156 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1164 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1166 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1171 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1173 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1177 for (i = 0; i < rel_size; i++)
1182 bfd_vma symtab_index;
1185 offset = rels[i].r_offset;
1186 inf = rels[i].r_info;
1188 type = get_reloc_type (inf);
1189 symtab_index = get_reloc_symindex (inf);
1193 printf ("%8.8lx %8.8lx ",
1194 (unsigned long) offset & 0xffffffff,
1195 (unsigned long) inf & 0xffffffff);
1199 #if BFD_HOST_64BIT_LONG
1201 ? "%16.16lx %16.16lx "
1202 : "%12.12lx %12.12lx ",
1204 #elif BFD_HOST_64BIT_LONG_LONG
1207 ? "%16.16llx %16.16llx "
1208 : "%12.12llx %12.12llx ",
1212 ? "%16.16I64x %16.16I64x "
1213 : "%12.12I64x %12.12I64x ",
1218 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1219 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1220 _bfd_int64_high (offset),
1221 _bfd_int64_low (offset),
1222 _bfd_int64_high (inf),
1223 _bfd_int64_low (inf));
1227 switch (elf_header.e_machine)
1234 rtype = elf_aarch64_reloc_type (type);
1238 case EM_CYGNUS_M32R:
1239 rtype = elf_m32r_reloc_type (type);
1244 rtype = elf_i386_reloc_type (type);
1249 rtype = elf_m68hc11_reloc_type (type);
1253 rtype = elf_m68k_reloc_type (type);
1257 rtype = elf_i960_reloc_type (type);
1262 rtype = elf_avr_reloc_type (type);
1265 case EM_OLD_SPARCV9:
1266 case EM_SPARC32PLUS:
1269 rtype = elf_sparc_reloc_type (type);
1273 rtype = elf_spu_reloc_type (type);
1277 rtype = v800_reloc_type (type);
1280 case EM_CYGNUS_V850:
1281 rtype = v850_reloc_type (type);
1285 case EM_CYGNUS_D10V:
1286 rtype = elf_d10v_reloc_type (type);
1290 case EM_CYGNUS_D30V:
1291 rtype = elf_d30v_reloc_type (type);
1295 rtype = elf_dlx_reloc_type (type);
1299 rtype = elf_sh_reloc_type (type);
1303 case EM_CYGNUS_MN10300:
1304 rtype = elf_mn10300_reloc_type (type);
1308 case EM_CYGNUS_MN10200:
1309 rtype = elf_mn10200_reloc_type (type);
1313 case EM_CYGNUS_FR30:
1314 rtype = elf_fr30_reloc_type (type);
1318 rtype = elf_frv_reloc_type (type);
1322 rtype = elf_ft32_reloc_type (type);
1326 rtype = elf_mcore_reloc_type (type);
1330 rtype = elf_mmix_reloc_type (type);
1334 rtype = elf_moxie_reloc_type (type);
1338 if (uses_msp430x_relocs ())
1340 rtype = elf_msp430x_reloc_type (type);
1345 rtype = elf_msp430_reloc_type (type);
1349 rtype = elf_nds32_reloc_type (type);
1353 rtype = elf_ppc_reloc_type (type);
1357 rtype = elf_ppc64_reloc_type (type);
1361 case EM_MIPS_RS3_LE:
1362 rtype = elf_mips_reloc_type (type);
1366 rtype = elf_riscv_reloc_type (type);
1370 rtype = elf_alpha_reloc_type (type);
1374 rtype = elf_arm_reloc_type (type);
1378 case EM_ARC_COMPACT:
1379 case EM_ARC_COMPACT2:
1380 rtype = elf_arc_reloc_type (type);
1384 rtype = elf_hppa_reloc_type (type);
1390 rtype = elf_h8_reloc_type (type);
1394 rtype = elf_or1k_reloc_type (type);
1399 rtype = elf_pj_reloc_type (type);
1402 rtype = elf_ia64_reloc_type (type);
1406 rtype = elf_cris_reloc_type (type);
1410 rtype = elf_i860_reloc_type (type);
1416 rtype = elf_x86_64_reloc_type (type);
1420 rtype = i370_reloc_type (type);
1425 rtype = elf_s390_reloc_type (type);
1429 rtype = elf_score_reloc_type (type);
1433 rtype = elf_xstormy16_reloc_type (type);
1437 rtype = elf_crx_reloc_type (type);
1441 rtype = elf_vax_reloc_type (type);
1445 rtype = elf_visium_reloc_type (type);
1448 case EM_ADAPTEVA_EPIPHANY:
1449 rtype = elf_epiphany_reloc_type (type);
1454 rtype = elf_ip2k_reloc_type (type);
1458 rtype = elf_iq2000_reloc_type (type);
1463 rtype = elf_xtensa_reloc_type (type);
1466 case EM_LATTICEMICO32:
1467 rtype = elf_lm32_reloc_type (type);
1472 rtype = elf_m32c_reloc_type (type);
1476 rtype = elf_mt_reloc_type (type);
1480 rtype = elf_bfin_reloc_type (type);
1484 rtype = elf_mep_reloc_type (type);
1488 rtype = elf_cr16_reloc_type (type);
1492 case EM_MICROBLAZE_OLD:
1493 rtype = elf_microblaze_reloc_type (type);
1497 rtype = elf_rl78_reloc_type (type);
1501 rtype = elf_rx_reloc_type (type);
1505 rtype = elf_metag_reloc_type (type);
1510 rtype = elf_xc16x_reloc_type (type);
1514 rtype = elf_tic6x_reloc_type (type);
1518 rtype = elf_tilegx_reloc_type (type);
1522 rtype = elf_tilepro_reloc_type (type);
1525 case EM_WEBASSEMBLY:
1526 rtype = elf_wasm32_reloc_type (type);
1530 rtype = elf_xgate_reloc_type (type);
1533 case EM_ALTERA_NIOS2:
1534 rtype = elf_nios2_reloc_type (type);
1538 rtype = elf_pru_reloc_type (type);
1543 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1545 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1547 if (elf_header.e_machine == EM_ALPHA
1549 && streq (rtype, "R_ALPHA_LITUSE")
1552 switch (rels[i].r_addend)
1554 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1555 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1556 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1557 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1558 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1559 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1560 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1561 default: rtype = NULL;
1565 printf (" (%s)", rtype);
1569 printf (_("<unknown addend: %lx>"),
1570 (unsigned long) rels[i].r_addend);
1574 else if (symtab_index)
1576 if (symtab == NULL || symtab_index >= nsyms)
1578 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1583 Elf_Internal_Sym * psym;
1584 const char * version_string;
1585 enum versioned_symbol_info sym_info;
1586 unsigned short vna_other;
1588 psym = symtab + symtab_index;
1591 = get_symbol_version_string (file, is_dynsym,
1600 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1604 unsigned int width = is_32bit_elf ? 8 : 14;
1606 /* Relocations against GNU_IFUNC symbols do not use the value
1607 of the symbol as the address to relocate against. Instead
1608 they invoke the function named by the symbol and use its
1609 result as the address for relocation.
1611 To indicate this to the user, do not display the value of
1612 the symbol in the "Symbols's Value" field. Instead show
1613 its name followed by () as a hint that the symbol is
1617 || psym->st_name == 0
1618 || psym->st_name >= strtablen)
1621 name = strtab + psym->st_name;
1623 len = print_symbol (width, name);
1625 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1627 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1631 print_vma (psym->st_value, LONG_HEX);
1633 printf (is_32bit_elf ? " " : " ");
1636 if (psym->st_name == 0)
1638 const char * sec_name = "<null>";
1641 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1643 if (psym->st_shndx < elf_header.e_shnum)
1644 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1645 else if (psym->st_shndx == SHN_ABS)
1647 else if (psym->st_shndx == SHN_COMMON)
1648 sec_name = "COMMON";
1649 else if ((elf_header.e_machine == EM_MIPS
1650 && psym->st_shndx == SHN_MIPS_SCOMMON)
1651 || (elf_header.e_machine == EM_TI_C6000
1652 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1653 sec_name = "SCOMMON";
1654 else if (elf_header.e_machine == EM_MIPS
1655 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1656 sec_name = "SUNDEF";
1657 else if ((elf_header.e_machine == EM_X86_64
1658 || elf_header.e_machine == EM_L1OM
1659 || elf_header.e_machine == EM_K1OM)
1660 && psym->st_shndx == SHN_X86_64_LCOMMON)
1661 sec_name = "LARGE_COMMON";
1662 else if (elf_header.e_machine == EM_IA_64
1663 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1664 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1665 sec_name = "ANSI_COM";
1666 else if (is_ia64_vms ()
1667 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1668 sec_name = "VMS_SYMVEC";
1671 sprintf (name_buf, "<section 0x%x>",
1672 (unsigned int) psym->st_shndx);
1673 sec_name = name_buf;
1676 print_symbol (22, sec_name);
1678 else if (strtab == NULL)
1679 printf (_("<string table index: %3ld>"), psym->st_name);
1680 else if (psym->st_name >= strtablen)
1682 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1687 print_symbol (22, strtab + psym->st_name);
1689 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1695 bfd_vma off = rels[i].r_addend;
1697 if ((bfd_signed_vma) off < 0)
1698 printf (" - %" BFD_VMA_FMT "x", - off);
1700 printf (" + %" BFD_VMA_FMT "x", off);
1706 bfd_vma off = rels[i].r_addend;
1708 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1709 if ((bfd_signed_vma) off < 0)
1710 printf ("-%" BFD_VMA_FMT "x", - off);
1712 printf ("%" BFD_VMA_FMT "x", off);
1715 if (elf_header.e_machine == EM_SPARCV9
1717 && streq (rtype, "R_SPARC_OLO10"))
1718 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1723 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1725 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1726 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1727 const char * rtype2 = elf_mips_reloc_type (type2);
1728 const char * rtype3 = elf_mips_reloc_type (type3);
1730 printf (" Type2: ");
1733 printf (_("unrecognized: %-7lx"),
1734 (unsigned long) type2 & 0xffffffff);
1736 printf ("%-17.17s", rtype2);
1738 printf ("\n Type3: ");
1741 printf (_("unrecognized: %-7lx"),
1742 (unsigned long) type3 & 0xffffffff);
1744 printf ("%-17.17s", rtype3);
1757 get_mips_dynamic_type (unsigned long type)
1761 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1762 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1763 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1764 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1765 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1766 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1767 case DT_MIPS_MSYM: return "MIPS_MSYM";
1768 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1769 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1770 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1771 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1772 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1773 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1774 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1775 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1776 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1777 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1778 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1779 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1780 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1781 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1782 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1783 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1784 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1785 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1786 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1787 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1788 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1789 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1790 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1791 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1792 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1793 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1794 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1795 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1796 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1797 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1798 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1799 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1800 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1801 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1802 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1803 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1804 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1805 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1806 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1813 get_sparc64_dynamic_type (unsigned long type)
1817 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1824 get_ppc_dynamic_type (unsigned long type)
1828 case DT_PPC_GOT: return "PPC_GOT";
1829 case DT_PPC_OPT: return "PPC_OPT";
1836 get_ppc64_dynamic_type (unsigned long type)
1840 case DT_PPC64_GLINK: return "PPC64_GLINK";
1841 case DT_PPC64_OPD: return "PPC64_OPD";
1842 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1843 case DT_PPC64_OPT: return "PPC64_OPT";
1850 get_parisc_dynamic_type (unsigned long type)
1854 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1855 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1856 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1857 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1858 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1859 case DT_HP_PREINIT: return "HP_PREINIT";
1860 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1861 case DT_HP_NEEDED: return "HP_NEEDED";
1862 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1863 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1864 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1865 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1866 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1867 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1868 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1869 case DT_HP_FILTERED: return "HP_FILTERED";
1870 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1871 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1872 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1873 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1874 case DT_PLT: return "PLT";
1875 case DT_PLT_SIZE: return "PLT_SIZE";
1876 case DT_DLT: return "DLT";
1877 case DT_DLT_SIZE: return "DLT_SIZE";
1884 get_ia64_dynamic_type (unsigned long type)
1888 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1889 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1890 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1891 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1892 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1893 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1894 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1895 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1896 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1897 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1898 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1899 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1900 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1901 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1902 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1903 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1904 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1905 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1906 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1907 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1908 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1909 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1910 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1911 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1912 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1913 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1914 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1915 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1916 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1917 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1918 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1925 get_solaris_section_type (unsigned long type)
1929 case 0x6fffffee: return "SUNW_ancillary";
1930 case 0x6fffffef: return "SUNW_capchain";
1931 case 0x6ffffff0: return "SUNW_capinfo";
1932 case 0x6ffffff1: return "SUNW_symsort";
1933 case 0x6ffffff2: return "SUNW_tlssort";
1934 case 0x6ffffff3: return "SUNW_LDYNSYM";
1935 case 0x6ffffff4: return "SUNW_dof";
1936 case 0x6ffffff5: return "SUNW_cap";
1937 case 0x6ffffff6: return "SUNW_SIGNATURE";
1938 case 0x6ffffff7: return "SUNW_ANNOTATE";
1939 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1940 case 0x6ffffff9: return "SUNW_DEBUG";
1941 case 0x6ffffffa: return "SUNW_move";
1942 case 0x6ffffffb: return "SUNW_COMDAT";
1943 case 0x6ffffffc: return "SUNW_syminfo";
1944 case 0x6ffffffd: return "SUNW_verdef";
1945 case 0x6ffffffe: return "SUNW_verneed";
1946 case 0x6fffffff: return "SUNW_versym";
1947 case 0x70000000: return "SPARC_GOTDATA";
1948 default: return NULL;
1953 get_alpha_dynamic_type (unsigned long type)
1957 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1958 default: return NULL;
1963 get_score_dynamic_type (unsigned long type)
1967 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1968 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1969 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1970 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1971 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1972 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1973 default: return NULL;
1978 get_tic6x_dynamic_type (unsigned long type)
1982 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1983 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1984 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1985 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1986 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1987 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1988 default: return NULL;
1993 get_nios2_dynamic_type (unsigned long type)
1997 case DT_NIOS2_GP: return "NIOS2_GP";
1998 default: return NULL;
2003 get_solaris_dynamic_type (unsigned long type)
2007 case 0x6000000d: return "SUNW_AUXILIARY";
2008 case 0x6000000e: return "SUNW_RTLDINF";
2009 case 0x6000000f: return "SUNW_FILTER";
2010 case 0x60000010: return "SUNW_CAP";
2011 case 0x60000011: return "SUNW_SYMTAB";
2012 case 0x60000012: return "SUNW_SYMSZ";
2013 case 0x60000013: return "SUNW_SORTENT";
2014 case 0x60000014: return "SUNW_SYMSORT";
2015 case 0x60000015: return "SUNW_SYMSORTSZ";
2016 case 0x60000016: return "SUNW_TLSSORT";
2017 case 0x60000017: return "SUNW_TLSSORTSZ";
2018 case 0x60000018: return "SUNW_CAPINFO";
2019 case 0x60000019: return "SUNW_STRPAD";
2020 case 0x6000001a: return "SUNW_CAPCHAIN";
2021 case 0x6000001b: return "SUNW_LDMACH";
2022 case 0x6000001d: return "SUNW_CAPCHAINENT";
2023 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2024 case 0x60000021: return "SUNW_PARENT";
2025 case 0x60000023: return "SUNW_ASLR";
2026 case 0x60000025: return "SUNW_RELAX";
2027 case 0x60000029: return "SUNW_NXHEAP";
2028 case 0x6000002b: return "SUNW_NXSTACK";
2030 case 0x70000001: return "SPARC_REGISTER";
2031 case 0x7ffffffd: return "AUXILIARY";
2032 case 0x7ffffffe: return "USED";
2033 case 0x7fffffff: return "FILTER";
2035 default: return NULL;
2040 get_dynamic_type (unsigned long type)
2042 static char buff[64];
2046 case DT_NULL: return "NULL";
2047 case DT_NEEDED: return "NEEDED";
2048 case DT_PLTRELSZ: return "PLTRELSZ";
2049 case DT_PLTGOT: return "PLTGOT";
2050 case DT_HASH: return "HASH";
2051 case DT_STRTAB: return "STRTAB";
2052 case DT_SYMTAB: return "SYMTAB";
2053 case DT_RELA: return "RELA";
2054 case DT_RELASZ: return "RELASZ";
2055 case DT_RELAENT: return "RELAENT";
2056 case DT_STRSZ: return "STRSZ";
2057 case DT_SYMENT: return "SYMENT";
2058 case DT_INIT: return "INIT";
2059 case DT_FINI: return "FINI";
2060 case DT_SONAME: return "SONAME";
2061 case DT_RPATH: return "RPATH";
2062 case DT_SYMBOLIC: return "SYMBOLIC";
2063 case DT_REL: return "REL";
2064 case DT_RELSZ: return "RELSZ";
2065 case DT_RELENT: return "RELENT";
2066 case DT_PLTREL: return "PLTREL";
2067 case DT_DEBUG: return "DEBUG";
2068 case DT_TEXTREL: return "TEXTREL";
2069 case DT_JMPREL: return "JMPREL";
2070 case DT_BIND_NOW: return "BIND_NOW";
2071 case DT_INIT_ARRAY: return "INIT_ARRAY";
2072 case DT_FINI_ARRAY: return "FINI_ARRAY";
2073 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2074 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2075 case DT_RUNPATH: return "RUNPATH";
2076 case DT_FLAGS: return "FLAGS";
2078 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2079 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2080 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2082 case DT_CHECKSUM: return "CHECKSUM";
2083 case DT_PLTPADSZ: return "PLTPADSZ";
2084 case DT_MOVEENT: return "MOVEENT";
2085 case DT_MOVESZ: return "MOVESZ";
2086 case DT_FEATURE: return "FEATURE";
2087 case DT_POSFLAG_1: return "POSFLAG_1";
2088 case DT_SYMINSZ: return "SYMINSZ";
2089 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2091 case DT_ADDRRNGLO: return "ADDRRNGLO";
2092 case DT_CONFIG: return "CONFIG";
2093 case DT_DEPAUDIT: return "DEPAUDIT";
2094 case DT_AUDIT: return "AUDIT";
2095 case DT_PLTPAD: return "PLTPAD";
2096 case DT_MOVETAB: return "MOVETAB";
2097 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2099 case DT_VERSYM: return "VERSYM";
2101 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2102 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2103 case DT_RELACOUNT: return "RELACOUNT";
2104 case DT_RELCOUNT: return "RELCOUNT";
2105 case DT_FLAGS_1: return "FLAGS_1";
2106 case DT_VERDEF: return "VERDEF";
2107 case DT_VERDEFNUM: return "VERDEFNUM";
2108 case DT_VERNEED: return "VERNEED";
2109 case DT_VERNEEDNUM: return "VERNEEDNUM";
2111 case DT_AUXILIARY: return "AUXILIARY";
2112 case DT_USED: return "USED";
2113 case DT_FILTER: return "FILTER";
2115 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2116 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2117 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2118 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2119 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2120 case DT_GNU_HASH: return "GNU_HASH";
2123 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2125 const char * result;
2127 switch (elf_header.e_machine)
2130 case EM_MIPS_RS3_LE:
2131 result = get_mips_dynamic_type (type);
2134 result = get_sparc64_dynamic_type (type);
2137 result = get_ppc_dynamic_type (type);
2140 result = get_ppc64_dynamic_type (type);
2143 result = get_ia64_dynamic_type (type);
2146 result = get_alpha_dynamic_type (type);
2149 result = get_score_dynamic_type (type);
2152 result = get_tic6x_dynamic_type (type);
2154 case EM_ALTERA_NIOS2:
2155 result = get_nios2_dynamic_type (type);
2158 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2159 result = get_solaris_dynamic_type (type);
2168 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2170 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2171 || (elf_header.e_machine == EM_PARISC
2172 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2174 const char * result;
2176 switch (elf_header.e_machine)
2179 result = get_parisc_dynamic_type (type);
2182 result = get_ia64_dynamic_type (type);
2185 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2186 result = get_solaris_dynamic_type (type);
2195 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2199 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2206 get_file_type (unsigned e_type)
2208 static char buff[32];
2212 case ET_NONE: return _("NONE (None)");
2213 case ET_REL: return _("REL (Relocatable file)");
2214 case ET_EXEC: return _("EXEC (Executable file)");
2215 case ET_DYN: return _("DYN (Shared object file)");
2216 case ET_CORE: return _("CORE (Core file)");
2219 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2220 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2221 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2222 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2224 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2230 get_machine_name (unsigned e_machine)
2232 static char buff[64]; /* XXX */
2236 /* Please keep this switch table sorted by increasing EM_ value. */
2238 case EM_NONE: return _("None");
2239 case EM_M32: return "WE32100";
2240 case EM_SPARC: return "Sparc";
2241 case EM_386: return "Intel 80386";
2242 case EM_68K: return "MC68000";
2243 case EM_88K: return "MC88000";
2244 case EM_IAMCU: return "Intel MCU";
2245 case EM_860: return "Intel 80860";
2246 case EM_MIPS: return "MIPS R3000";
2247 case EM_S370: return "IBM System/370";
2249 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2250 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2251 case EM_PARISC: return "HPPA";
2252 case EM_VPP550: return "Fujitsu VPP500";
2253 case EM_SPARC32PLUS: return "Sparc v8+" ;
2254 case EM_960: return "Intel 90860";
2255 case EM_PPC: return "PowerPC";
2257 case EM_PPC64: return "PowerPC64";
2259 case EM_S390: return "IBM S/390";
2260 case EM_SPU: return "SPU";
2262 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2263 case EM_FR20: return "Fujitsu FR20";
2264 case EM_RH32: return "TRW RH32";
2265 case EM_MCORE: return "MCORE";
2267 case EM_ARM: return "ARM";
2268 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2269 case EM_SH: return "Renesas / SuperH SH";
2270 case EM_SPARCV9: return "Sparc v9";
2271 case EM_TRICORE: return "Siemens Tricore";
2272 case EM_ARC: return "ARC";
2273 case EM_H8_300: return "Renesas H8/300";
2274 case EM_H8_300H: return "Renesas H8/300H";
2275 case EM_H8S: return "Renesas H8S";
2276 case EM_H8_500: return "Renesas H8/500";
2278 case EM_IA_64: return "Intel IA-64";
2279 case EM_MIPS_X: return "Stanford MIPS-X";
2280 case EM_COLDFIRE: return "Motorola Coldfire";
2281 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2282 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2283 case EM_PCP: return "Siemens PCP";
2284 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2285 case EM_NDR1: return "Denso NDR1 microprocesspr";
2286 case EM_STARCORE: return "Motorola Star*Core processor";
2287 case EM_ME16: return "Toyota ME16 processor";
2289 case EM_ST100: return "STMicroelectronics ST100 processor";
2290 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2291 case EM_X86_64: return "Advanced Micro Devices X86-64";
2292 case EM_PDSP: return "Sony DSP processor";
2293 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2294 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2295 case EM_FX66: return "Siemens FX66 microcontroller";
2296 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2297 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2298 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2300 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2301 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2302 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2303 case EM_SVX: return "Silicon Graphics SVx";
2304 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2305 case EM_VAX: return "Digital VAX";
2306 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2307 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2308 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2309 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2311 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2312 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2313 case EM_PRISM: return "Vitesse Prism";
2315 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2316 case EM_CYGNUS_FR30:
2317 case EM_FR30: return "Fujitsu FR30";
2318 case EM_CYGNUS_D10V:
2319 case EM_D10V: return "d10v";
2320 case EM_CYGNUS_D30V:
2321 case EM_D30V: return "d30v";
2322 case EM_CYGNUS_V850:
2323 case EM_V850: return "Renesas V850";
2324 case EM_CYGNUS_M32R:
2325 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2326 case EM_CYGNUS_MN10300:
2327 case EM_MN10300: return "mn10300";
2329 case EM_CYGNUS_MN10200:
2330 case EM_MN10200: return "mn10200";
2331 case EM_PJ: return "picoJava";
2332 case EM_OR1K: return "OpenRISC 1000";
2333 case EM_ARC_COMPACT: return "ARCompact";
2335 case EM_XTENSA: return "Tensilica Xtensa Processor";
2336 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2337 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2338 case EM_NS32K: return "National Semiconductor 32000 series";
2339 case EM_TPC: return "Tenor Network TPC processor";
2340 case EM_SNP1K: return "Trebia SNP 1000 processor";
2342 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2344 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2345 case EM_MAX: return "MAX Processor";
2346 case EM_CR: return "National Semiconductor CompactRISC";
2347 case EM_F2MC16: return "Fujitsu F2MC16";
2348 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2349 case EM_BLACKFIN: return "Analog Devices Blackfin";
2350 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2351 case EM_SEP: return "Sharp embedded microprocessor";
2352 case EM_ARCA: return "Arca RISC microprocessor";
2354 case EM_UNICORE: return "Unicore";
2355 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2356 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2357 case EM_ALTERA_NIOS2: return "Altera Nios II";
2358 case EM_CRX: return "National Semiconductor CRX microprocessor";
2359 case EM_XGATE: return "Motorola XGATE embedded processor";
2361 case EM_XC16X: return "Infineon Technologies xc16x";
2362 case EM_M16C: return "Renesas M16C series microprocessors";
2363 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2364 case EM_CE: return "Freescale Communication Engine RISC core";
2366 case EM_M32C: return "Renesas M32c";
2368 case EM_TSK3000: return "Altium TSK3000 core";
2369 case EM_RS08: return "Freescale RS08 embedded processor";
2370 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2371 case EM_SCORE: return "SUNPLUS S+Core";
2372 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2373 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2374 case EM_LATTICEMICO32: return "Lattice Mico32";
2375 case EM_SE_C17: return "Seiko Epson C17 family";
2377 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2378 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2379 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2380 case EM_TI_PRU: return "TI PRU I/O processor";
2382 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2383 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2384 case EM_R32C: return "Renesas R32C series microprocessors";
2385 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2386 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2387 case EM_8051: return "Intel 8051 and variants";
2388 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2389 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2390 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2391 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2393 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2394 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2395 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2396 case EM_RX: return "Renesas RX";
2397 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2398 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2399 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2402 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2403 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2404 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2406 case EM_L1OM: return "Intel L1OM";
2407 case EM_K1OM: return "Intel K1OM";
2408 case EM_INTEL182: return "Intel (reserved)";
2409 case EM_AARCH64: return "AArch64";
2410 case EM_ARM184: return "ARM (reserved)";
2411 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2412 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2413 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2414 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2416 case EM_CUDA: return "NVIDIA CUDA architecture";
2417 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2418 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2419 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2420 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2421 case EM_ARC_COMPACT2: return "ARCv2";
2422 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2423 case EM_RL78: return "Renesas RL78";
2424 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2425 case EM_78K0R: return "Renesas 78K0R";
2427 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2428 case EM_BA1: return "Beyond BA1 CPU architecture";
2429 case EM_BA2: return "Beyond BA2 CPU architecture";
2430 case EM_XCORE: return "XMOS xCORE processor family";
2431 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2433 case EM_KM32: return "KM211 KM32 32-bit processor";
2434 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2435 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2436 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2437 case EM_KVARC: return "KM211 KVARC processor";
2438 case EM_CDP: return "Paneve CDP architecture family";
2439 case EM_COGE: return "Cognitive Smart Memory Processor";
2440 case EM_COOL: return "Bluechip Systems CoolEngine";
2441 case EM_NORC: return "Nanoradio Optimized RISC";
2442 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2444 case EM_Z80: return "Zilog Z80";
2445 case EM_VISIUM: return "CDS VISIUMcore processor";
2446 case EM_FT32: return "FTDI Chip FT32";
2447 case EM_MOXIE: return "Moxie";
2448 case EM_AMDGPU: return "AMD GPU";
2449 case EM_RISCV: return "RISC-V";
2450 case EM_LANAI: return "Lanai 32-bit processor";
2451 case EM_BPF: return "Linux BPF";
2453 /* Large numbers... */
2454 case EM_MT: return "Morpho Techologies MT processor";
2455 case EM_ALPHA: return "Alpha";
2456 case EM_WEBASSEMBLY: return "Web Assembly";
2457 case EM_DLX: return "OpenDLX";
2458 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2459 case EM_IQ2000: return "Vitesse IQ2000";
2461 case EM_NIOS32: return "Altera Nios";
2462 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2463 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2464 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2467 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2473 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2475 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2476 other compilers don't a specific architecture type in the e_flags, and
2477 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2478 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2481 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2482 but also sets a specific architecture type in the e_flags field.
2484 However, when decoding the flags we don't worry if we see an
2485 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2486 ARCEM architecture type. */
2488 switch (e_flags & EF_ARC_MACH_MSK)
2490 /* We only expect these to occur for EM_ARC_COMPACT2. */
2491 case EF_ARC_CPU_ARCV2EM:
2492 strcat (buf, ", ARC EM");
2494 case EF_ARC_CPU_ARCV2HS:
2495 strcat (buf, ", ARC HS");
2498 /* We only expect these to occur for EM_ARC_COMPACT. */
2499 case E_ARC_MACH_ARC600:
2500 strcat (buf, ", ARC600");
2502 case E_ARC_MACH_ARC601:
2503 strcat (buf, ", ARC601");
2505 case E_ARC_MACH_ARC700:
2506 strcat (buf, ", ARC700");
2509 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2510 new ELF with new architecture being read by an old version of
2511 readelf, or (c) An ELF built with non-GNU compiler that does not
2512 set the architecture in the e_flags. */
2514 if (e_machine == EM_ARC_COMPACT)
2515 strcat (buf, ", Unknown ARCompact");
2517 strcat (buf, ", Unknown ARC");
2521 switch (e_flags & EF_ARC_OSABI_MSK)
2523 case E_ARC_OSABI_ORIG:
2524 strcat (buf, ", (ABI:legacy)");
2526 case E_ARC_OSABI_V2:
2527 strcat (buf, ", (ABI:v2)");
2529 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2530 case E_ARC_OSABI_V3:
2531 strcat (buf, ", v3 no-legacy-syscalls ABI");
2533 case E_ARC_OSABI_V4:
2534 strcat (buf, ", v4 ABI");
2537 strcat (buf, ", unrecognised ARC OSABI flag");
2543 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2546 bfd_boolean unknown = FALSE;
2548 eabi = EF_ARM_EABI_VERSION (e_flags);
2549 e_flags &= ~ EF_ARM_EABIMASK;
2551 /* Handle "generic" ARM flags. */
2552 if (e_flags & EF_ARM_RELEXEC)
2554 strcat (buf, ", relocatable executable");
2555 e_flags &= ~ EF_ARM_RELEXEC;
2558 /* Now handle EABI specific flags. */
2562 strcat (buf, ", <unrecognized EABI>");
2567 case EF_ARM_EABI_VER1:
2568 strcat (buf, ", Version1 EABI");
2573 /* Process flags one bit at a time. */
2574 flag = e_flags & - e_flags;
2579 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2580 strcat (buf, ", sorted symbol tables");
2590 case EF_ARM_EABI_VER2:
2591 strcat (buf, ", Version2 EABI");
2596 /* Process flags one bit at a time. */
2597 flag = e_flags & - e_flags;
2602 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf, ", sorted symbol tables");
2606 case EF_ARM_DYNSYMSUSESEGIDX:
2607 strcat (buf, ", dynamic symbols use segment index");
2610 case EF_ARM_MAPSYMSFIRST:
2611 strcat (buf, ", mapping symbols precede others");
2621 case EF_ARM_EABI_VER3:
2622 strcat (buf, ", Version3 EABI");
2625 case EF_ARM_EABI_VER4:
2626 strcat (buf, ", Version4 EABI");
2631 /* Process flags one bit at a time. */
2632 flag = e_flags & - e_flags;
2638 strcat (buf, ", BE8");
2642 strcat (buf, ", LE8");
2652 case EF_ARM_EABI_VER5:
2653 strcat (buf, ", Version5 EABI");
2658 /* Process flags one bit at a time. */
2659 flag = e_flags & - e_flags;
2665 strcat (buf, ", BE8");
2669 strcat (buf, ", LE8");
2672 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2673 strcat (buf, ", soft-float ABI");
2676 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2677 strcat (buf, ", hard-float ABI");
2687 case EF_ARM_EABI_UNKNOWN:
2688 strcat (buf, ", GNU EABI");
2693 /* Process flags one bit at a time. */
2694 flag = e_flags & - e_flags;
2699 case EF_ARM_INTERWORK:
2700 strcat (buf, ", interworking enabled");
2703 case EF_ARM_APCS_26:
2704 strcat (buf, ", uses APCS/26");
2707 case EF_ARM_APCS_FLOAT:
2708 strcat (buf, ", uses APCS/float");
2712 strcat (buf, ", position independent");
2716 strcat (buf, ", 8 bit structure alignment");
2719 case EF_ARM_NEW_ABI:
2720 strcat (buf, ", uses new ABI");
2723 case EF_ARM_OLD_ABI:
2724 strcat (buf, ", uses old ABI");
2727 case EF_ARM_SOFT_FLOAT:
2728 strcat (buf, ", software FP");
2731 case EF_ARM_VFP_FLOAT:
2732 strcat (buf, ", VFP");
2735 case EF_ARM_MAVERICK_FLOAT:
2736 strcat (buf, ", Maverick FP");
2747 strcat (buf,_(", <unknown>"));
2751 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2753 --size; /* Leave space for null terminator. */
2755 switch (e_flags & EF_AVR_MACH)
2757 case E_AVR_MACH_AVR1:
2758 strncat (buf, ", avr:1", size);
2760 case E_AVR_MACH_AVR2:
2761 strncat (buf, ", avr:2", size);
2763 case E_AVR_MACH_AVR25:
2764 strncat (buf, ", avr:25", size);
2766 case E_AVR_MACH_AVR3:
2767 strncat (buf, ", avr:3", size);
2769 case E_AVR_MACH_AVR31:
2770 strncat (buf, ", avr:31", size);
2772 case E_AVR_MACH_AVR35:
2773 strncat (buf, ", avr:35", size);
2775 case E_AVR_MACH_AVR4:
2776 strncat (buf, ", avr:4", size);
2778 case E_AVR_MACH_AVR5:
2779 strncat (buf, ", avr:5", size);
2781 case E_AVR_MACH_AVR51:
2782 strncat (buf, ", avr:51", size);
2784 case E_AVR_MACH_AVR6:
2785 strncat (buf, ", avr:6", size);
2787 case E_AVR_MACH_AVRTINY:
2788 strncat (buf, ", avr:100", size);
2790 case E_AVR_MACH_XMEGA1:
2791 strncat (buf, ", avr:101", size);
2793 case E_AVR_MACH_XMEGA2:
2794 strncat (buf, ", avr:102", size);
2796 case E_AVR_MACH_XMEGA3:
2797 strncat (buf, ", avr:103", size);
2799 case E_AVR_MACH_XMEGA4:
2800 strncat (buf, ", avr:104", size);
2802 case E_AVR_MACH_XMEGA5:
2803 strncat (buf, ", avr:105", size);
2805 case E_AVR_MACH_XMEGA6:
2806 strncat (buf, ", avr:106", size);
2808 case E_AVR_MACH_XMEGA7:
2809 strncat (buf, ", avr:107", size);
2812 strncat (buf, ", avr:<unknown>", size);
2816 size -= strlen (buf);
2817 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2818 strncat (buf, ", link-relax", size);
2822 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2828 bfd_boolean has_fpu = FALSE;
2831 static const char *ABI_STRINGS[] =
2833 "ABI v0", /* use r5 as return register; only used in N1213HC */
2834 "ABI v1", /* use r0 as return register */
2835 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2836 "ABI v2fp", /* for FPU */
2840 static const char *VER_STRINGS[] =
2842 "Andes ELF V1.3 or older",
2846 static const char *ARCH_STRINGS[] =
2855 abi = EF_NDS_ABI & e_flags;
2856 arch = EF_NDS_ARCH & e_flags;
2857 config = EF_NDS_INST & e_flags;
2858 version = EF_NDS32_ELF_VERSION & e_flags;
2860 memset (buf, 0, size);
2867 case E_NDS_ABI_V2FP:
2868 case E_NDS_ABI_AABI:
2869 case E_NDS_ABI_V2FP_PLUS:
2870 /* In case there are holes in the array. */
2871 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2875 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2881 case E_NDS32_ELF_VER_1_2:
2882 case E_NDS32_ELF_VER_1_3:
2883 case E_NDS32_ELF_VER_1_4:
2884 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2888 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2892 if (E_NDS_ABI_V0 == abi)
2894 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2895 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2896 if (arch == E_NDS_ARCH_STAR_V1_0)
2897 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2903 case E_NDS_ARCH_STAR_V1_0:
2904 case E_NDS_ARCH_STAR_V2_0:
2905 case E_NDS_ARCH_STAR_V3_0:
2906 case E_NDS_ARCH_STAR_V3_M:
2907 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2911 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2912 /* ARCH version determines how the e_flags are interpreted.
2913 If it is unknown, we cannot proceed. */
2917 /* Newer ABI; Now handle architecture specific flags. */
2918 if (arch == E_NDS_ARCH_STAR_V1_0)
2920 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2921 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2923 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2924 r += snprintf (buf + r, size -r, ", MAC");
2926 if (config & E_NDS32_HAS_DIV_INST)
2927 r += snprintf (buf + r, size -r, ", DIV");
2929 if (config & E_NDS32_HAS_16BIT_INST)
2930 r += snprintf (buf + r, size -r, ", 16b");
2934 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2936 if (version <= E_NDS32_ELF_VER_1_3)
2937 r += snprintf (buf + r, size -r, ", [B8]");
2939 r += snprintf (buf + r, size -r, ", EX9");
2942 if (config & E_NDS32_HAS_MAC_DX_INST)
2943 r += snprintf (buf + r, size -r, ", MAC_DX");
2945 if (config & E_NDS32_HAS_DIV_DX_INST)
2946 r += snprintf (buf + r, size -r, ", DIV_DX");
2948 if (config & E_NDS32_HAS_16BIT_INST)
2950 if (version <= E_NDS32_ELF_VER_1_3)
2951 r += snprintf (buf + r, size -r, ", 16b");
2953 r += snprintf (buf + r, size -r, ", IFC");
2957 if (config & E_NDS32_HAS_EXT_INST)
2958 r += snprintf (buf + r, size -r, ", PERF1");
2960 if (config & E_NDS32_HAS_EXT2_INST)
2961 r += snprintf (buf + r, size -r, ", PERF2");
2963 if (config & E_NDS32_HAS_FPU_INST)
2966 r += snprintf (buf + r, size -r, ", FPU_SP");
2969 if (config & E_NDS32_HAS_FPU_DP_INST)
2972 r += snprintf (buf + r, size -r, ", FPU_DP");
2975 if (config & E_NDS32_HAS_FPU_MAC_INST)
2978 r += snprintf (buf + r, size -r, ", FPU_MAC");
2983 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2985 case E_NDS32_FPU_REG_8SP_4DP:
2986 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2988 case E_NDS32_FPU_REG_16SP_8DP:
2989 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2991 case E_NDS32_FPU_REG_32SP_16DP:
2992 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2994 case E_NDS32_FPU_REG_32SP_32DP:
2995 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3000 if (config & E_NDS32_HAS_AUDIO_INST)
3001 r += snprintf (buf + r, size -r, ", AUDIO");
3003 if (config & E_NDS32_HAS_STRING_INST)
3004 r += snprintf (buf + r, size -r, ", STR");
3006 if (config & E_NDS32_HAS_REDUCED_REGS)
3007 r += snprintf (buf + r, size -r, ", 16REG");
3009 if (config & E_NDS32_HAS_VIDEO_INST)
3011 if (version <= E_NDS32_ELF_VER_1_3)
3012 r += snprintf (buf + r, size -r, ", VIDEO");
3014 r += snprintf (buf + r, size -r, ", SATURATION");
3017 if (config & E_NDS32_HAS_ENCRIPT_INST)
3018 r += snprintf (buf + r, size -r, ", ENCRP");
3020 if (config & E_NDS32_HAS_L2C_INST)
3021 r += snprintf (buf + r, size -r, ", L2C");
3025 get_machine_flags (unsigned e_flags, unsigned e_machine)
3027 static char buf[1024];
3038 case EM_ARC_COMPACT2:
3039 case EM_ARC_COMPACT:
3040 decode_ARC_machine_flags (e_flags, e_machine, buf);
3044 decode_ARM_machine_flags (e_flags, buf);
3048 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3052 if (e_flags & EF_BFIN_PIC)
3053 strcat (buf, ", PIC");
3055 if (e_flags & EF_BFIN_FDPIC)
3056 strcat (buf, ", FDPIC");
3058 if (e_flags & EF_BFIN_CODE_IN_L1)
3059 strcat (buf, ", code in L1");
3061 if (e_flags & EF_BFIN_DATA_IN_L1)
3062 strcat (buf, ", data in L1");
3067 switch (e_flags & EF_FRV_CPU_MASK)
3069 case EF_FRV_CPU_GENERIC:
3073 strcat (buf, ", fr???");
3076 case EF_FRV_CPU_FR300:
3077 strcat (buf, ", fr300");
3080 case EF_FRV_CPU_FR400:
3081 strcat (buf, ", fr400");
3083 case EF_FRV_CPU_FR405:
3084 strcat (buf, ", fr405");
3087 case EF_FRV_CPU_FR450:
3088 strcat (buf, ", fr450");
3091 case EF_FRV_CPU_FR500:
3092 strcat (buf, ", fr500");
3094 case EF_FRV_CPU_FR550:
3095 strcat (buf, ", fr550");
3098 case EF_FRV_CPU_SIMPLE:
3099 strcat (buf, ", simple");
3101 case EF_FRV_CPU_TOMCAT:
3102 strcat (buf, ", tomcat");
3108 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3109 strcat (buf, ", m68000");
3110 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3111 strcat (buf, ", cpu32");
3112 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3113 strcat (buf, ", fido_a");
3116 char const * isa = _("unknown");
3117 char const * mac = _("unknown mac");
3118 char const * additional = NULL;
3120 switch (e_flags & EF_M68K_CF_ISA_MASK)
3122 case EF_M68K_CF_ISA_A_NODIV:
3124 additional = ", nodiv";
3126 case EF_M68K_CF_ISA_A:
3129 case EF_M68K_CF_ISA_A_PLUS:
3132 case EF_M68K_CF_ISA_B_NOUSP:
3134 additional = ", nousp";
3136 case EF_M68K_CF_ISA_B:
3139 case EF_M68K_CF_ISA_C:
3142 case EF_M68K_CF_ISA_C_NODIV:
3144 additional = ", nodiv";
3147 strcat (buf, ", cf, isa ");
3150 strcat (buf, additional);
3151 if (e_flags & EF_M68K_CF_FLOAT)
3152 strcat (buf, ", float");
3153 switch (e_flags & EF_M68K_CF_MAC_MASK)
3158 case EF_M68K_CF_MAC:
3161 case EF_M68K_CF_EMAC:
3164 case EF_M68K_CF_EMAC_B:
3177 switch (e_flags & EF_MEP_CPU_MASK)
3179 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3180 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3181 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3182 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3183 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3184 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3185 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3188 switch (e_flags & EF_MEP_COP_MASK)
3190 case EF_MEP_COP_NONE: break;
3191 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3192 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3193 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3194 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3195 default: strcat (buf, _("<unknown MeP copro type>")); break;
3198 if (e_flags & EF_MEP_LIBRARY)
3199 strcat (buf, ", Built for Library");
3201 if (e_flags & EF_MEP_INDEX_MASK)
3202 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3203 e_flags & EF_MEP_INDEX_MASK);
3205 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3206 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3207 e_flags & ~ EF_MEP_ALL_FLAGS);
3211 if (e_flags & EF_PPC_EMB)
3212 strcat (buf, ", emb");
3214 if (e_flags & EF_PPC_RELOCATABLE)
3215 strcat (buf, _(", relocatable"));
3217 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3218 strcat (buf, _(", relocatable-lib"));
3222 if (e_flags & EF_PPC64_ABI)
3224 char abi[] = ", abiv0";
3226 abi[6] += e_flags & EF_PPC64_ABI;
3232 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3233 strcat (buf, ", RH850 ABI");
3235 if (e_flags & EF_V800_850E3)
3236 strcat (buf, ", V3 architecture");
3238 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3239 strcat (buf, ", FPU not used");
3241 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3242 strcat (buf, ", regmode: COMMON");
3244 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3245 strcat (buf, ", r4 not used");
3247 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3248 strcat (buf, ", r30 not used");
3250 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3251 strcat (buf, ", r5 not used");
3253 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3254 strcat (buf, ", r2 not used");
3256 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3258 switch (e_flags & - e_flags)
3260 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3261 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3262 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3263 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3264 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3265 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3266 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3267 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3268 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3269 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3270 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3271 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3278 case EM_CYGNUS_V850:
3279 switch (e_flags & EF_V850_ARCH)
3281 case E_V850E3V5_ARCH:
3282 strcat (buf, ", v850e3v5");
3284 case E_V850E2V3_ARCH:
3285 strcat (buf, ", v850e2v3");
3288 strcat (buf, ", v850e2");
3291 strcat (buf, ", v850e1");
3294 strcat (buf, ", v850e");
3297 strcat (buf, ", v850");
3300 strcat (buf, _(", unknown v850 architecture variant"));
3306 case EM_CYGNUS_M32R:
3307 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3308 strcat (buf, ", m32r");
3312 case EM_MIPS_RS3_LE:
3313 if (e_flags & EF_MIPS_NOREORDER)
3314 strcat (buf, ", noreorder");
3316 if (e_flags & EF_MIPS_PIC)
3317 strcat (buf, ", pic");
3319 if (e_flags & EF_MIPS_CPIC)
3320 strcat (buf, ", cpic");
3322 if (e_flags & EF_MIPS_UCODE)
3323 strcat (buf, ", ugen_reserved");
3325 if (e_flags & EF_MIPS_ABI2)
3326 strcat (buf, ", abi2");
3328 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3329 strcat (buf, ", odk first");
3331 if (e_flags & EF_MIPS_32BITMODE)
3332 strcat (buf, ", 32bitmode");
3334 if (e_flags & EF_MIPS_NAN2008)
3335 strcat (buf, ", nan2008");
3337 if (e_flags & EF_MIPS_FP64)
3338 strcat (buf, ", fp64");
3340 switch ((e_flags & EF_MIPS_MACH))
3342 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3343 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3344 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3345 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3346 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3347 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3348 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3349 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3350 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3351 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3352 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3353 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3354 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3355 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3356 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3357 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3358 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3359 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3360 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3362 /* We simply ignore the field in this case to avoid confusion:
3363 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3366 default: strcat (buf, _(", unknown CPU")); break;
3369 switch ((e_flags & EF_MIPS_ABI))
3371 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3372 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3373 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3374 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3376 /* We simply ignore the field in this case to avoid confusion:
3377 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3378 This means it is likely to be an o32 file, but not for
3381 default: strcat (buf, _(", unknown ABI")); break;
3384 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3385 strcat (buf, ", mdmx");
3387 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3388 strcat (buf, ", mips16");
3390 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3391 strcat (buf, ", micromips");
3393 switch ((e_flags & EF_MIPS_ARCH))
3395 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3396 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3397 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3398 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3399 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3400 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3401 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3402 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3403 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3404 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3405 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3406 default: strcat (buf, _(", unknown ISA")); break;
3411 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3415 if (e_flags & EF_RISCV_RVC)
3416 strcat (buf, ", RVC");
3418 switch (e_flags & EF_RISCV_FLOAT_ABI)
3420 case EF_RISCV_FLOAT_ABI_SOFT:
3421 strcat (buf, ", soft-float ABI");
3424 case EF_RISCV_FLOAT_ABI_SINGLE:
3425 strcat (buf, ", single-float ABI");
3428 case EF_RISCV_FLOAT_ABI_DOUBLE:
3429 strcat (buf, ", double-float ABI");
3432 case EF_RISCV_FLOAT_ABI_QUAD:
3433 strcat (buf, ", quad-float ABI");
3439 switch ((e_flags & EF_SH_MACH_MASK))
3441 case EF_SH1: strcat (buf, ", sh1"); break;
3442 case EF_SH2: strcat (buf, ", sh2"); break;
3443 case EF_SH3: strcat (buf, ", sh3"); break;
3444 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3445 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3446 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3447 case EF_SH3E: strcat (buf, ", sh3e"); break;
3448 case EF_SH4: strcat (buf, ", sh4"); break;
3449 case EF_SH5: strcat (buf, ", sh5"); break;
3450 case EF_SH2E: strcat (buf, ", sh2e"); break;
3451 case EF_SH4A: strcat (buf, ", sh4a"); break;
3452 case EF_SH2A: strcat (buf, ", sh2a"); break;
3453 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3454 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3455 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3456 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3457 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3458 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3459 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3460 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3461 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3462 default: strcat (buf, _(", unknown ISA")); break;
3465 if (e_flags & EF_SH_PIC)
3466 strcat (buf, ", pic");
3468 if (e_flags & EF_SH_FDPIC)
3469 strcat (buf, ", fdpic");
3473 if (e_flags & EF_OR1K_NODELAY)
3474 strcat (buf, ", no delay");
3478 if (e_flags & EF_SPARC_32PLUS)
3479 strcat (buf, ", v8+");
3481 if (e_flags & EF_SPARC_SUN_US1)
3482 strcat (buf, ", ultrasparcI");
3484 if (e_flags & EF_SPARC_SUN_US3)
3485 strcat (buf, ", ultrasparcIII");
3487 if (e_flags & EF_SPARC_HAL_R1)
3488 strcat (buf, ", halr1");
3490 if (e_flags & EF_SPARC_LEDATA)
3491 strcat (buf, ", ledata");
3493 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3494 strcat (buf, ", tso");
3496 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3497 strcat (buf, ", pso");
3499 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3500 strcat (buf, ", rmo");
3504 switch (e_flags & EF_PARISC_ARCH)
3506 case EFA_PARISC_1_0:
3507 strcpy (buf, ", PA-RISC 1.0");
3509 case EFA_PARISC_1_1:
3510 strcpy (buf, ", PA-RISC 1.1");
3512 case EFA_PARISC_2_0:
3513 strcpy (buf, ", PA-RISC 2.0");
3518 if (e_flags & EF_PARISC_TRAPNIL)
3519 strcat (buf, ", trapnil");
3520 if (e_flags & EF_PARISC_EXT)
3521 strcat (buf, ", ext");
3522 if (e_flags & EF_PARISC_LSB)
3523 strcat (buf, ", lsb");
3524 if (e_flags & EF_PARISC_WIDE)
3525 strcat (buf, ", wide");
3526 if (e_flags & EF_PARISC_NO_KABP)
3527 strcat (buf, ", no kabp");
3528 if (e_flags & EF_PARISC_LAZYSWAP)
3529 strcat (buf, ", lazyswap");
3534 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3535 strcat (buf, ", new calling convention");
3537 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3538 strcat (buf, ", gnu calling convention");
3542 if ((e_flags & EF_IA_64_ABI64))
3543 strcat (buf, ", 64-bit");
3545 strcat (buf, ", 32-bit");
3546 if ((e_flags & EF_IA_64_REDUCEDFP))
3547 strcat (buf, ", reduced fp model");
3548 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3549 strcat (buf, ", no function descriptors, constant gp");
3550 else if ((e_flags & EF_IA_64_CONS_GP))
3551 strcat (buf, ", constant gp");
3552 if ((e_flags & EF_IA_64_ABSOLUTE))
3553 strcat (buf, ", absolute");
3554 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3556 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3557 strcat (buf, ", vms_linkages");
3558 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3560 case EF_IA_64_VMS_COMCOD_SUCCESS:
3562 case EF_IA_64_VMS_COMCOD_WARNING:
3563 strcat (buf, ", warning");
3565 case EF_IA_64_VMS_COMCOD_ERROR:
3566 strcat (buf, ", error");
3568 case EF_IA_64_VMS_COMCOD_ABORT:
3569 strcat (buf, ", abort");
3572 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573 e_flags & EF_IA_64_VMS_COMCOD);
3574 strcat (buf, ", <unknown>");
3580 if ((e_flags & EF_VAX_NONPIC))
3581 strcat (buf, ", non-PIC");
3582 if ((e_flags & EF_VAX_DFLOAT))
3583 strcat (buf, ", D-Float");
3584 if ((e_flags & EF_VAX_GFLOAT))
3585 strcat (buf, ", G-Float");
3589 if (e_flags & EF_VISIUM_ARCH_MCM)
3590 strcat (buf, ", mcm");
3591 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3592 strcat (buf, ", mcm24");
3593 if (e_flags & EF_VISIUM_ARCH_GR6)
3594 strcat (buf, ", gr6");
3598 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3600 case E_FLAG_RL78_ANY_CPU: break;
3601 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3602 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3603 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3605 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3606 strcat (buf, ", 64-bit doubles");
3610 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3611 strcat (buf, ", 64-bit doubles");
3612 if (e_flags & E_FLAG_RX_DSP)
3613 strcat (buf, ", dsp");
3614 if (e_flags & E_FLAG_RX_PID)
3615 strcat (buf, ", pid");
3616 if (e_flags & E_FLAG_RX_ABI)
3617 strcat (buf, ", RX ABI");
3618 if (e_flags & E_FLAG_RX_SINSNS_SET)
3619 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3620 ? ", uses String instructions" : ", bans String instructions");
3621 if (e_flags & E_FLAG_RX_V2)
3622 strcat (buf, ", V2");
3626 if (e_flags & EF_S390_HIGH_GPRS)
3627 strcat (buf, ", highgprs");
3631 if ((e_flags & EF_C6000_REL))
3632 strcat (buf, ", relocatable module");
3636 strcat (buf, _(": architecture variant: "));
3637 switch (e_flags & EF_MSP430_MACH)
3639 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3640 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3641 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3642 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3643 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3644 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3645 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3646 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3647 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3648 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3649 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3650 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3651 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3652 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3653 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3655 strcat (buf, _(": unknown")); break;
3658 if (e_flags & ~ EF_MSP430_MACH)
3659 strcat (buf, _(": unknown extra flag bits also present"));
3667 get_osabi_name (unsigned int osabi)
3669 static char buff[32];
3673 case ELFOSABI_NONE: return "UNIX - System V";
3674 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3675 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3676 case ELFOSABI_GNU: return "UNIX - GNU";
3677 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3678 case ELFOSABI_AIX: return "UNIX - AIX";
3679 case ELFOSABI_IRIX: return "UNIX - IRIX";
3680 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3681 case ELFOSABI_TRU64: return "UNIX - TRU64";
3682 case ELFOSABI_MODESTO: return "Novell - Modesto";
3683 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3684 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3685 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3686 case ELFOSABI_AROS: return "AROS";
3687 case ELFOSABI_FENIXOS: return "FenixOS";
3688 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3689 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3692 switch (elf_header.e_machine)
3697 case ELFOSABI_ARM: return "ARM";
3708 case ELFOSABI_STANDALONE: return _("Standalone App");
3717 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3718 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3727 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3733 get_aarch64_segment_type (unsigned long type)
3737 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3738 default: return NULL;
3743 get_arm_segment_type (unsigned long type)
3747 case PT_ARM_EXIDX: return "EXIDX";
3748 default: return NULL;
3753 get_s390_segment_type (unsigned long type)
3757 case PT_S390_PGSTE: return "S390_PGSTE";
3758 default: return NULL;
3763 get_mips_segment_type (unsigned long type)
3767 case PT_MIPS_REGINFO: return "REGINFO";
3768 case PT_MIPS_RTPROC: return "RTPROC";
3769 case PT_MIPS_OPTIONS: return "OPTIONS";
3770 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3771 default: return NULL;
3776 get_parisc_segment_type (unsigned long type)
3780 case PT_HP_TLS: return "HP_TLS";
3781 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3782 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3783 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3784 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3785 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3786 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3787 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3788 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3789 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3790 case PT_HP_PARALLEL: return "HP_PARALLEL";
3791 case PT_HP_FASTBIND: return "HP_FASTBIND";
3792 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3793 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3794 case PT_HP_STACK: return "HP_STACK";
3795 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3796 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3797 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3798 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3799 default: return NULL;
3804 get_ia64_segment_type (unsigned long type)
3808 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3809 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3810 case PT_HP_TLS: return "HP_TLS";
3811 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3812 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3813 case PT_IA_64_HP_STACK: return "HP_STACK";
3814 default: return NULL;
3819 get_tic6x_segment_type (unsigned long type)
3823 case PT_C6000_PHATTR: return "C6000_PHATTR";
3824 default: return NULL;
3829 get_solaris_segment_type (unsigned long type)
3833 case 0x6464e550: return "PT_SUNW_UNWIND";
3834 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3835 case 0x6ffffff7: return "PT_LOSUNW";
3836 case 0x6ffffffa: return "PT_SUNWBSS";
3837 case 0x6ffffffb: return "PT_SUNWSTACK";
3838 case 0x6ffffffc: return "PT_SUNWDTRACE";
3839 case 0x6ffffffd: return "PT_SUNWCAP";
3840 case 0x6fffffff: return "PT_HISUNW";
3841 default: return NULL;
3846 get_segment_type (unsigned long p_type)
3848 static char buff[32];
3852 case PT_NULL: return "NULL";
3853 case PT_LOAD: return "LOAD";
3854 case PT_DYNAMIC: return "DYNAMIC";
3855 case PT_INTERP: return "INTERP";
3856 case PT_NOTE: return "NOTE";
3857 case PT_SHLIB: return "SHLIB";
3858 case PT_PHDR: return "PHDR";
3859 case PT_TLS: return "TLS";
3860 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3861 case PT_GNU_STACK: return "GNU_STACK";
3862 case PT_GNU_RELRO: return "GNU_RELRO";
3865 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3867 sprintf (buff, "GNU_MBIND+%#lx",
3868 p_type - PT_GNU_MBIND_LO);
3870 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3872 const char * result;
3874 switch (elf_header.e_machine)
3877 result = get_aarch64_segment_type (p_type);
3880 result = get_arm_segment_type (p_type);
3883 case EM_MIPS_RS3_LE:
3884 result = get_mips_segment_type (p_type);
3887 result = get_parisc_segment_type (p_type);
3890 result = get_ia64_segment_type (p_type);
3893 result = get_tic6x_segment_type (p_type);
3897 result = get_s390_segment_type (p_type);
3907 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3909 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3911 const char * result;
3913 switch (elf_header.e_machine)
3916 result = get_parisc_segment_type (p_type);
3919 result = get_ia64_segment_type (p_type);
3922 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3923 result = get_solaris_segment_type (p_type);
3932 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3935 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3942 get_arc_section_type_name (unsigned int sh_type)
3946 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
3954 get_mips_section_type_name (unsigned int sh_type)
3958 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3959 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3960 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3961 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3962 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3963 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3964 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3965 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3966 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3967 case SHT_MIPS_RELD: return "MIPS_RELD";
3968 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3969 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3970 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3971 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3972 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3973 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3974 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3975 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3976 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3977 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3978 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3979 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3980 case SHT_MIPS_LINE: return "MIPS_LINE";
3981 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3982 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3983 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3984 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3985 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3986 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3987 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3988 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3989 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3990 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3991 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3992 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3993 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3994 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3995 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3996 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3997 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4005 get_parisc_section_type_name (unsigned int sh_type)
4009 case SHT_PARISC_EXT: return "PARISC_EXT";
4010 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4011 case SHT_PARISC_DOC: return "PARISC_DOC";
4012 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4013 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4014 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4015 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4016 default: return NULL;
4021 get_ia64_section_type_name (unsigned int sh_type)
4023 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4024 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4025 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
4029 case SHT_IA_64_EXT: return "IA_64_EXT";
4030 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4031 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4032 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4033 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4034 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4035 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4036 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4037 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4038 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4046 get_x86_64_section_type_name (unsigned int sh_type)
4050 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4051 default: return NULL;
4056 get_aarch64_section_type_name (unsigned int sh_type)
4060 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4061 default: return NULL;
4066 get_arm_section_type_name (unsigned int sh_type)
4070 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4071 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4072 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4073 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4074 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4075 default: return NULL;
4080 get_tic6x_section_type_name (unsigned int sh_type)
4084 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4085 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4086 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4087 case SHT_TI_ICODE: return "TI_ICODE";
4088 case SHT_TI_XREF: return "TI_XREF";
4089 case SHT_TI_HANDLER: return "TI_HANDLER";
4090 case SHT_TI_INITINFO: return "TI_INITINFO";
4091 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4092 default: return NULL;
4097 get_msp430x_section_type_name (unsigned int sh_type)
4101 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4102 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4103 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4104 default: return NULL;
4109 get_v850_section_type_name (unsigned int sh_type)
4113 case SHT_V850_SCOMMON: return "V850 Small Common";
4114 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4115 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4116 case SHT_RENESAS_IOP: return "RENESAS IOP";
4117 case SHT_RENESAS_INFO: return "RENESAS INFO";
4118 default: return NULL;
4123 get_section_type_name (unsigned int sh_type)
4125 static char buff[32];
4126 const char * result;
4130 case SHT_NULL: return "NULL";
4131 case SHT_PROGBITS: return "PROGBITS";
4132 case SHT_SYMTAB: return "SYMTAB";
4133 case SHT_STRTAB: return "STRTAB";
4134 case SHT_RELA: return "RELA";
4135 case SHT_HASH: return "HASH";
4136 case SHT_DYNAMIC: return "DYNAMIC";
4137 case SHT_NOTE: return "NOTE";
4138 case SHT_NOBITS: return "NOBITS";
4139 case SHT_REL: return "REL";
4140 case SHT_SHLIB: return "SHLIB";
4141 case SHT_DYNSYM: return "DYNSYM";
4142 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4143 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4144 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4145 case SHT_GNU_HASH: return "GNU_HASH";
4146 case SHT_GROUP: return "GROUP";
4147 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
4148 case SHT_GNU_verdef: return "VERDEF";
4149 case SHT_GNU_verneed: return "VERNEED";
4150 case SHT_GNU_versym: return "VERSYM";
4151 case 0x6ffffff0: return "VERSYM";
4152 case 0x6ffffffc: return "VERDEF";
4153 case 0x7ffffffd: return "AUXILIARY";
4154 case 0x7fffffff: return "FILTER";
4155 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4158 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4160 switch (elf_header.e_machine)
4163 case EM_ARC_COMPACT:
4164 case EM_ARC_COMPACT2:
4165 result = get_arc_section_type_name (sh_type);
4168 case EM_MIPS_RS3_LE:
4169 result = get_mips_section_type_name (sh_type);
4172 result = get_parisc_section_type_name (sh_type);
4175 result = get_ia64_section_type_name (sh_type);
4180 result = get_x86_64_section_type_name (sh_type);
4183 result = get_aarch64_section_type_name (sh_type);
4186 result = get_arm_section_type_name (sh_type);
4189 result = get_tic6x_section_type_name (sh_type);
4192 result = get_msp430x_section_type_name (sh_type);
4196 case EM_CYGNUS_V850:
4197 result = get_v850_section_type_name (sh_type);
4207 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4209 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4211 switch (elf_header.e_machine)
4214 result = get_ia64_section_type_name (sh_type);
4217 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4218 result = get_solaris_section_type (sh_type);
4223 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4224 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4225 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4226 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4238 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4240 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4242 switch (elf_header.e_machine)
4246 case EM_CYGNUS_V850:
4247 result = get_v850_section_type_name (sh_type);
4257 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4260 /* This message is probably going to be displayed in a 15
4261 character wide field, so put the hex value first. */
4262 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4268 #define OPTION_DEBUG_DUMP 512
4269 #define OPTION_DYN_SYMS 513
4270 #define OPTION_DWARF_DEPTH 514
4271 #define OPTION_DWARF_START 515
4272 #define OPTION_DWARF_CHECK 516
4274 static struct option options[] =
4276 {"all", no_argument, 0, 'a'},
4277 {"file-header", no_argument, 0, 'h'},
4278 {"program-headers", no_argument, 0, 'l'},
4279 {"headers", no_argument, 0, 'e'},
4280 {"histogram", no_argument, 0, 'I'},
4281 {"segments", no_argument, 0, 'l'},
4282 {"sections", no_argument, 0, 'S'},
4283 {"section-headers", no_argument, 0, 'S'},
4284 {"section-groups", no_argument, 0, 'g'},
4285 {"section-details", no_argument, 0, 't'},
4286 {"full-section-name",no_argument, 0, 'N'},
4287 {"symbols", no_argument, 0, 's'},
4288 {"syms", no_argument, 0, 's'},
4289 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4290 {"relocs", no_argument, 0, 'r'},
4291 {"notes", no_argument, 0, 'n'},
4292 {"dynamic", no_argument, 0, 'd'},
4293 {"arch-specific", no_argument, 0, 'A'},
4294 {"version-info", no_argument, 0, 'V'},
4295 {"use-dynamic", no_argument, 0, 'D'},
4296 {"unwind", no_argument, 0, 'u'},
4297 {"archive-index", no_argument, 0, 'c'},
4298 {"hex-dump", required_argument, 0, 'x'},
4299 {"relocated-dump", required_argument, 0, 'R'},
4300 {"string-dump", required_argument, 0, 'p'},
4301 {"decompress", no_argument, 0, 'z'},
4302 #ifdef SUPPORT_DISASSEMBLY
4303 {"instruction-dump", required_argument, 0, 'i'},
4305 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4307 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4308 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4309 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4311 {"version", no_argument, 0, 'v'},
4312 {"wide", no_argument, 0, 'W'},
4313 {"help", no_argument, 0, 'H'},
4314 {0, no_argument, 0, 0}
4318 usage (FILE * stream)
4320 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4321 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4322 fprintf (stream, _(" Options are:\n\
4323 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4324 -h --file-header Display the ELF file header\n\
4325 -l --program-headers Display the program headers\n\
4326 --segments An alias for --program-headers\n\
4327 -S --section-headers Display the sections' header\n\
4328 --sections An alias for --section-headers\n\
4329 -g --section-groups Display the section groups\n\
4330 -t --section-details Display the section details\n\
4331 -e --headers Equivalent to: -h -l -S\n\
4332 -s --syms Display the symbol table\n\
4333 --symbols An alias for --syms\n\
4334 --dyn-syms Display the dynamic symbol table\n\
4335 -n --notes Display the core notes (if present)\n\
4336 -r --relocs Display the relocations (if present)\n\
4337 -u --unwind Display the unwind info (if present)\n\
4338 -d --dynamic Display the dynamic section (if present)\n\
4339 -V --version-info Display the version sections (if present)\n\
4340 -A --arch-specific Display architecture specific information (if any)\n\
4341 -c --archive-index Display the symbol/file index in an archive\n\
4342 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4343 -x --hex-dump=<number|name>\n\
4344 Dump the contents of section <number|name> as bytes\n\
4345 -p --string-dump=<number|name>\n\
4346 Dump the contents of section <number|name> as strings\n\
4347 -R --relocated-dump=<number|name>\n\
4348 Dump the contents of section <number|name> as relocated bytes\n\
4349 -z --decompress Decompress section before dumping it\n\
4350 -w[lLiaprmfFsoRt] or\n\
4351 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4352 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4353 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4355 Display the contents of DWARF2 debug sections\n"));
4356 fprintf (stream, _("\
4357 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4358 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4360 #ifdef SUPPORT_DISASSEMBLY
4361 fprintf (stream, _("\
4362 -i --instruction-dump=<number|name>\n\
4363 Disassemble the contents of section <number|name>\n"));
4365 fprintf (stream, _("\
4366 -I --histogram Display histogram of bucket list lengths\n\
4367 -W --wide Allow output width to exceed 80 characters\n\
4368 @<file> Read options from <file>\n\
4369 -H --help Display this information\n\
4370 -v --version Display the version number of readelf\n"));
4372 if (REPORT_BUGS_TO[0] && stream == stdout)
4373 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4375 exit (stream == stdout ? 0 : 1);
4378 /* Record the fact that the user wants the contents of section number
4379 SECTION to be displayed using the method(s) encoded as flags bits
4380 in TYPE. Note, TYPE can be zero if we are creating the array for
4384 request_dump_bynumber (unsigned int section, dump_type type)
4386 if (section >= num_dump_sects)
4388 dump_type * new_dump_sects;
4390 new_dump_sects = (dump_type *) calloc (section + 1,
4391 sizeof (* dump_sects));
4393 if (new_dump_sects == NULL)
4394 error (_("Out of memory allocating dump request table.\n"));
4399 /* Copy current flag settings. */
4400 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4405 dump_sects = new_dump_sects;
4406 num_dump_sects = section + 1;
4411 dump_sects[section] |= type;
4416 /* Request a dump by section name. */
4419 request_dump_byname (const char * section, dump_type type)
4421 struct dump_list_entry * new_request;
4423 new_request = (struct dump_list_entry *)
4424 malloc (sizeof (struct dump_list_entry));
4426 error (_("Out of memory allocating dump request table.\n"));
4428 new_request->name = strdup (section);
4429 if (!new_request->name)
4430 error (_("Out of memory allocating dump request table.\n"));
4432 new_request->type = type;
4434 new_request->next = dump_sects_byname;
4435 dump_sects_byname = new_request;
4439 request_dump (dump_type type)
4445 section = strtoul (optarg, & cp, 0);
4447 if (! *cp && section >= 0)
4448 request_dump_bynumber (section, type);
4450 request_dump_byname (optarg, type);
4455 parse_args (int argc, char ** argv)
4462 while ((c = getopt_long
4463 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4481 do_section_groups = TRUE;
4484 do_histogram = TRUE;
4489 do_section_groups = TRUE;
4494 do_section_details = TRUE;
4505 do_using_dynamic = TRUE;
4529 do_histogram = TRUE;
4535 do_archive_index = TRUE;
4538 request_dump (HEX_DUMP);
4541 request_dump (STRING_DUMP);
4544 request_dump (RELOC_DUMP);
4547 decompress_dumps = TRUE;
4553 do_debugging = TRUE;
4554 dwarf_select_sections_all ();
4558 do_debugging = FALSE;
4559 dwarf_select_sections_by_letters (optarg);
4562 case OPTION_DEBUG_DUMP:
4565 do_debugging = TRUE;
4568 do_debugging = FALSE;
4569 dwarf_select_sections_by_names (optarg);
4572 case OPTION_DWARF_DEPTH:
4576 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4579 case OPTION_DWARF_START:
4583 dwarf_start_die = strtoul (optarg, & cp, 0);
4586 case OPTION_DWARF_CHECK:
4589 case OPTION_DYN_SYMS:
4592 #ifdef SUPPORT_DISASSEMBLY
4594 request_dump (DISASS_DUMP);
4598 print_version (program_name);
4607 /* xgettext:c-format */
4608 error (_("Invalid option '-%c'\n"), c);
4615 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4616 && !do_segments && !do_header && !do_dump && !do_version
4617 && !do_histogram && !do_debugging && !do_arch && !do_notes
4618 && !do_section_groups && !do_archive_index
4624 get_elf_class (unsigned int elf_class)
4626 static char buff[32];
4630 case ELFCLASSNONE: return _("none");
4631 case ELFCLASS32: return "ELF32";
4632 case ELFCLASS64: return "ELF64";
4634 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4640 get_data_encoding (unsigned int encoding)
4642 static char buff[32];
4646 case ELFDATANONE: return _("none");
4647 case ELFDATA2LSB: return _("2's complement, little endian");
4648 case ELFDATA2MSB: return _("2's complement, big endian");
4650 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4655 /* Decode the data held in 'elf_header'. */
4658 process_file_header (void)
4660 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4661 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4662 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4663 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4666 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4670 init_dwarf_regnames (elf_header.e_machine);
4676 printf (_("ELF Header:\n"));
4677 printf (_(" Magic: "));
4678 for (i = 0; i < EI_NIDENT; i++)
4679 printf ("%2.2x ", elf_header.e_ident[i]);
4681 printf (_(" Class: %s\n"),
4682 get_elf_class (elf_header.e_ident[EI_CLASS]));
4683 printf (_(" Data: %s\n"),
4684 get_data_encoding (elf_header.e_ident[EI_DATA]));
4685 printf (_(" Version: %d %s\n"),
4686 elf_header.e_ident[EI_VERSION],
4687 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4689 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4690 ? _("<unknown: %lx>")
4692 printf (_(" OS/ABI: %s\n"),
4693 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4694 printf (_(" ABI Version: %d\n"),
4695 elf_header.e_ident[EI_ABIVERSION]);
4696 printf (_(" Type: %s\n"),
4697 get_file_type (elf_header.e_type));
4698 printf (_(" Machine: %s\n"),
4699 get_machine_name (elf_header.e_machine));
4700 printf (_(" Version: 0x%lx\n"),
4701 (unsigned long) elf_header.e_version);
4703 printf (_(" Entry point address: "));
4704 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4705 printf (_("\n Start of program headers: "));
4706 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4707 printf (_(" (bytes into file)\n Start of section headers: "));
4708 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4709 printf (_(" (bytes into file)\n"));
4711 printf (_(" Flags: 0x%lx%s\n"),
4712 (unsigned long) elf_header.e_flags,
4713 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4714 printf (_(" Size of this header: %ld (bytes)\n"),
4715 (long) elf_header.e_ehsize);
4716 printf (_(" Size of program headers: %ld (bytes)\n"),
4717 (long) elf_header.e_phentsize);
4718 printf (_(" Number of program headers: %ld"),
4719 (long) elf_header.e_phnum);
4720 if (section_headers != NULL
4721 && elf_header.e_phnum == PN_XNUM
4722 && section_headers[0].sh_info != 0)
4723 printf (" (%ld)", (long) section_headers[0].sh_info);
4724 putc ('\n', stdout);
4725 printf (_(" Size of section headers: %ld (bytes)\n"),
4726 (long) elf_header.e_shentsize);
4727 printf (_(" Number of section headers: %ld"),
4728 (long) elf_header.e_shnum);
4729 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4730 printf (" (%ld)", (long) section_headers[0].sh_size);
4731 putc ('\n', stdout);
4732 printf (_(" Section header string table index: %ld"),
4733 (long) elf_header.e_shstrndx);
4734 if (section_headers != NULL
4735 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4736 printf (" (%u)", section_headers[0].sh_link);
4737 else if (elf_header.e_shstrndx != SHN_UNDEF
4738 && elf_header.e_shstrndx >= elf_header.e_shnum)
4739 printf (_(" <corrupt: out of range>"));
4740 putc ('\n', stdout);
4743 if (section_headers != NULL)
4745 if (elf_header.e_phnum == PN_XNUM
4746 && section_headers[0].sh_info != 0)
4747 elf_header.e_phnum = section_headers[0].sh_info;
4748 if (elf_header.e_shnum == SHN_UNDEF)
4749 elf_header.e_shnum = section_headers[0].sh_size;
4750 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4751 elf_header.e_shstrndx = section_headers[0].sh_link;
4752 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4753 elf_header.e_shstrndx = SHN_UNDEF;
4754 free (section_headers);
4755 section_headers = NULL;
4762 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4764 Elf32_External_Phdr * phdrs;
4765 Elf32_External_Phdr * external;
4766 Elf_Internal_Phdr * internal;
4768 unsigned int size = elf_header.e_phentsize;
4769 unsigned int num = elf_header.e_phnum;
4771 /* PR binutils/17531: Cope with unexpected section header sizes. */
4772 if (size == 0 || num == 0)
4774 if (size < sizeof * phdrs)
4776 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4779 if (size > sizeof * phdrs)
4780 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4782 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4783 size, num, _("program headers"));
4787 for (i = 0, internal = pheaders, external = phdrs;
4788 i < elf_header.e_phnum;
4789 i++, internal++, external++)
4791 internal->p_type = BYTE_GET (external->p_type);
4792 internal->p_offset = BYTE_GET (external->p_offset);
4793 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4794 internal->p_paddr = BYTE_GET (external->p_paddr);
4795 internal->p_filesz = BYTE_GET (external->p_filesz);
4796 internal->p_memsz = BYTE_GET (external->p_memsz);
4797 internal->p_flags = BYTE_GET (external->p_flags);
4798 internal->p_align = BYTE_GET (external->p_align);
4806 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4808 Elf64_External_Phdr * phdrs;
4809 Elf64_External_Phdr * external;
4810 Elf_Internal_Phdr * internal;
4812 unsigned int size = elf_header.e_phentsize;
4813 unsigned int num = elf_header.e_phnum;
4815 /* PR binutils/17531: Cope with unexpected section header sizes. */
4816 if (size == 0 || num == 0)
4818 if (size < sizeof * phdrs)
4820 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4823 if (size > sizeof * phdrs)
4824 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4826 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4827 size, num, _("program headers"));
4831 for (i = 0, internal = pheaders, external = phdrs;
4832 i < elf_header.e_phnum;
4833 i++, internal++, external++)
4835 internal->p_type = BYTE_GET (external->p_type);
4836 internal->p_flags = BYTE_GET (external->p_flags);
4837 internal->p_offset = BYTE_GET (external->p_offset);
4838 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4839 internal->p_paddr = BYTE_GET (external->p_paddr);
4840 internal->p_filesz = BYTE_GET (external->p_filesz);
4841 internal->p_memsz = BYTE_GET (external->p_memsz);
4842 internal->p_align = BYTE_GET (external->p_align);
4849 /* Returns TRUE if the program headers were read into `program_headers'. */
4852 get_program_headers (FILE * file)
4854 Elf_Internal_Phdr * phdrs;
4856 /* Check cache of prior read. */
4857 if (program_headers != NULL)
4860 /* Be kind to memory checkers by looking for
4861 e_phnum values which we know must be invalid. */
4862 if (elf_header.e_phnum
4863 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4864 >= current_file_size)
4866 error (_("Too many program headers - %#x - the file is not that big\n"),
4867 elf_header.e_phnum);
4871 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4872 sizeof (Elf_Internal_Phdr));
4875 error (_("Out of memory reading %u program headers\n"),
4876 elf_header.e_phnum);
4881 ? get_32bit_program_headers (file, phdrs)
4882 : get_64bit_program_headers (file, phdrs))
4884 program_headers = phdrs;
4892 /* Returns TRUE if the program headers were loaded. */
4895 process_program_headers (FILE * file)
4897 Elf_Internal_Phdr * segment;
4899 Elf_Internal_Phdr * previous_load = NULL;
4901 if (elf_header.e_phnum == 0)
4903 /* PR binutils/12467. */
4904 if (elf_header.e_phoff != 0)
4906 warn (_("possibly corrupt ELF header - it has a non-zero program"
4907 " header offset, but no program headers\n"));
4910 else if (do_segments)
4911 printf (_("\nThere are no program headers in this file.\n"));
4915 if (do_segments && !do_header)
4917 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4918 printf (_("Entry point "));
4919 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4920 printf (_("\nThere are %d program headers, starting at offset "),
4921 elf_header.e_phnum);
4922 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4926 if (! get_program_headers (file))
4931 if (elf_header.e_phnum > 1)
4932 printf (_("\nProgram Headers:\n"));
4934 printf (_("\nProgram Headers:\n"));
4938 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4941 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4945 (_(" Type Offset VirtAddr PhysAddr\n"));
4947 (_(" FileSiz MemSiz Flags Align\n"));
4954 for (i = 0, segment = program_headers;
4955 i < elf_header.e_phnum;
4960 printf (" %-14.14s ", get_segment_type (segment->p_type));
4964 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4965 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4966 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4967 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4968 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4970 (segment->p_flags & PF_R ? 'R' : ' '),
4971 (segment->p_flags & PF_W ? 'W' : ' '),
4972 (segment->p_flags & PF_X ? 'E' : ' '));
4973 printf ("%#lx", (unsigned long) segment->p_align);
4977 if ((unsigned long) segment->p_offset == segment->p_offset)
4978 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4981 print_vma (segment->p_offset, FULL_HEX);
4985 print_vma (segment->p_vaddr, FULL_HEX);
4987 print_vma (segment->p_paddr, FULL_HEX);
4990 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4991 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4994 print_vma (segment->p_filesz, FULL_HEX);
4998 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4999 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5002 print_vma (segment->p_memsz, FULL_HEX);
5006 (segment->p_flags & PF_R ? 'R' : ' '),
5007 (segment->p_flags & PF_W ? 'W' : ' '),
5008 (segment->p_flags & PF_X ? 'E' : ' '));
5010 if ((unsigned long) segment->p_align == segment->p_align)
5011 printf ("%#lx", (unsigned long) segment->p_align);
5014 print_vma (segment->p_align, PREFIX_HEX);
5019 print_vma (segment->p_offset, FULL_HEX);
5021 print_vma (segment->p_vaddr, FULL_HEX);
5023 print_vma (segment->p_paddr, FULL_HEX);
5025 print_vma (segment->p_filesz, FULL_HEX);
5027 print_vma (segment->p_memsz, FULL_HEX);
5029 (segment->p_flags & PF_R ? 'R' : ' '),
5030 (segment->p_flags & PF_W ? 'W' : ' '),
5031 (segment->p_flags & PF_X ? 'E' : ' '));
5032 print_vma (segment->p_align, PREFIX_HEX);
5035 putc ('\n', stdout);
5038 switch (segment->p_type)
5041 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5042 required by the ELF standard, several programs, including the Linux
5043 kernel, make use of non-ordered segments. */
5045 && previous_load->p_vaddr > segment->p_vaddr)
5046 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5048 if (segment->p_memsz < segment->p_filesz)
5049 error (_("the segment's file size is larger than its memory size\n"));
5050 previous_load = segment;
5054 /* PR 20815 - Verify that the program header is loaded into memory. */
5055 if (i > 0 && previous_load != NULL)
5056 error (_("the PHDR segment must occur before any LOAD segment\n"));
5057 if (elf_header.e_machine != EM_PARISC)
5061 for (j = 1; j < elf_header.e_phnum; j++)
5062 if (program_headers[j].p_vaddr <= segment->p_vaddr
5063 && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
5064 >= (segment->p_vaddr + segment->p_filesz))
5066 if (j == elf_header.e_phnum)
5067 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5073 error (_("more than one dynamic segment\n"));
5075 /* By default, assume that the .dynamic section is the first
5076 section in the DYNAMIC segment. */
5077 dynamic_addr = segment->p_offset;
5078 dynamic_size = segment->p_filesz;
5080 /* Try to locate the .dynamic section. If there is
5081 a section header table, we can easily locate it. */
5082 if (section_headers != NULL)
5084 Elf_Internal_Shdr * sec;
5086 sec = find_section (".dynamic");
5087 if (sec == NULL || sec->sh_size == 0)
5089 /* A corresponding .dynamic section is expected, but on
5090 IA-64/OpenVMS it is OK for it to be missing. */
5091 if (!is_ia64_vms ())
5092 error (_("no .dynamic section in the dynamic segment\n"));
5096 if (sec->sh_type == SHT_NOBITS)
5102 dynamic_addr = sec->sh_offset;
5103 dynamic_size = sec->sh_size;
5105 if (dynamic_addr < segment->p_offset
5106 || dynamic_addr > segment->p_offset + segment->p_filesz)
5107 warn (_("the .dynamic section is not contained"
5108 " within the dynamic segment\n"));
5109 else if (dynamic_addr > segment->p_offset)
5110 warn (_("the .dynamic section is not the first section"
5111 " in the dynamic segment.\n"));
5114 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5115 segment. Check this after matching against the section headers
5116 so we don't warn on debuginfo file (which have NOBITS .dynamic
5118 if (dynamic_addr + dynamic_size >= current_file_size)
5120 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121 dynamic_addr = dynamic_size = 0;
5126 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5128 error (_("Unable to find program interpreter name\n"));
5132 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5134 if (ret >= (int) sizeof (fmt) || ret < 0)
5135 error (_("Internal error: failed to create format string to display program interpreter\n"));
5137 program_interpreter[0] = 0;
5138 if (fscanf (file, fmt, program_interpreter) <= 0)
5139 error (_("Unable to read program interpreter name\n"));
5142 printf (_(" [Requesting program interpreter: %s]\n"),
5143 program_interpreter);
5149 if (do_segments && section_headers != NULL && string_table != NULL)
5151 printf (_("\n Section to Segment mapping:\n"));
5152 printf (_(" Segment Sections...\n"));
5154 for (i = 0; i < elf_header.e_phnum; i++)
5157 Elf_Internal_Shdr * section;
5159 segment = program_headers + i;
5160 section = section_headers + 1;
5162 printf (" %2.2d ", i);
5164 for (j = 1; j < elf_header.e_shnum; j++, section++)
5166 if (!ELF_TBSS_SPECIAL (section, segment)
5167 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5168 printf ("%s ", printable_section_name (section));
5179 /* Find the file offset corresponding to VMA by using the program headers. */
5182 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5184 Elf_Internal_Phdr * seg;
5186 if (! get_program_headers (file))
5188 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5192 for (seg = program_headers;
5193 seg < program_headers + elf_header.e_phnum;
5196 if (seg->p_type != PT_LOAD)
5199 if (vma >= (seg->p_vaddr & -seg->p_align)
5200 && vma + size <= seg->p_vaddr + seg->p_filesz)
5201 return vma - seg->p_vaddr + seg->p_offset;
5204 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205 (unsigned long) vma);
5210 /* Allocate memory and load the sections headers into the global pointer
5211 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5212 generate any error messages if the load fails. */
5215 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5217 Elf32_External_Shdr * shdrs;
5218 Elf_Internal_Shdr * internal;
5220 unsigned int size = elf_header.e_shentsize;
5221 unsigned int num = probe ? 1 : elf_header.e_shnum;
5223 /* PR binutils/17531: Cope with unexpected section header sizes. */
5224 if (size == 0 || num == 0)
5226 if (size < sizeof * shdrs)
5229 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5232 if (!probe && size > sizeof * shdrs)
5233 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5235 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5237 probe ? NULL : _("section headers"));
5241 if (section_headers != NULL)
5242 free (section_headers);
5243 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5244 sizeof (Elf_Internal_Shdr));
5245 if (section_headers == NULL)
5248 error (_("Out of memory reading %u section headers\n"), num);
5252 for (i = 0, internal = section_headers;
5256 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5257 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5258 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5259 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5260 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5261 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5262 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5263 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5264 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5265 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5266 if (!probe && internal->sh_link > num)
5267 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5268 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5269 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5277 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5279 Elf64_External_Shdr * shdrs;
5280 Elf_Internal_Shdr * internal;
5282 unsigned int size = elf_header.e_shentsize;
5283 unsigned int num = probe ? 1 : elf_header.e_shnum;
5285 /* PR binutils/17531: Cope with unexpected section header sizes. */
5286 if (size == 0 || num == 0)
5288 if (size < sizeof * shdrs)
5291 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5294 if (! probe && size > sizeof * shdrs)
5295 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5297 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5299 probe ? NULL : _("section headers"));
5303 if (section_headers != NULL)
5304 free (section_headers);
5305 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5306 sizeof (Elf_Internal_Shdr));
5307 if (section_headers == NULL)
5310 error (_("Out of memory reading %u section headers\n"), num);
5314 for (i = 0, internal = section_headers;
5318 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5319 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5320 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5321 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5322 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5323 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5324 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5325 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5326 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5327 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5328 if (!probe && internal->sh_link > num)
5329 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5330 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5331 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5338 static Elf_Internal_Sym *
5339 get_32bit_elf_symbols (FILE * file,
5340 Elf_Internal_Shdr * section,
5341 unsigned long * num_syms_return)
5343 unsigned long number = 0;
5344 Elf32_External_Sym * esyms = NULL;
5345 Elf_External_Sym_Shndx * shndx = NULL;
5346 Elf_Internal_Sym * isyms = NULL;
5347 Elf_Internal_Sym * psym;
5350 if (section->sh_size == 0)
5352 if (num_syms_return != NULL)
5353 * num_syms_return = 0;
5357 /* Run some sanity checks first. */
5358 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5360 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361 printable_section_name (section), (unsigned long) section->sh_entsize);
5365 if (section->sh_size > current_file_size)
5367 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368 printable_section_name (section), (unsigned long) section->sh_size);
5372 number = section->sh_size / section->sh_entsize;
5374 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5376 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5377 (unsigned long) section->sh_size,
5378 printable_section_name (section),
5379 (unsigned long) section->sh_entsize);
5383 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5384 section->sh_size, _("symbols"));
5389 elf_section_list * entry;
5392 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5393 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5395 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5396 entry->hdr->sh_offset,
5397 1, entry->hdr->sh_size,
5398 _("symbol table section indicies"));
5401 /* PR17531: file: heap-buffer-overflow */
5402 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5404 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5405 printable_section_name (entry->hdr),
5406 (unsigned long) entry->hdr->sh_size,
5407 (unsigned long) section->sh_size);
5413 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5417 error (_("Out of memory reading %lu symbols\n"),
5418 (unsigned long) number);
5422 for (j = 0, psym = isyms; j < number; j++, psym++)
5424 psym->st_name = BYTE_GET (esyms[j].st_name);
5425 psym->st_value = BYTE_GET (esyms[j].st_value);
5426 psym->st_size = BYTE_GET (esyms[j].st_size);
5427 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5428 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5430 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5431 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5432 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5433 psym->st_info = BYTE_GET (esyms[j].st_info);
5434 psym->st_other = BYTE_GET (esyms[j].st_other);
5443 if (num_syms_return != NULL)
5444 * num_syms_return = isyms == NULL ? 0 : number;
5449 static Elf_Internal_Sym *
5450 get_64bit_elf_symbols (FILE * file,
5451 Elf_Internal_Shdr * section,
5452 unsigned long * num_syms_return)
5454 unsigned long number = 0;
5455 Elf64_External_Sym * esyms = NULL;
5456 Elf_External_Sym_Shndx * shndx = NULL;
5457 Elf_Internal_Sym * isyms = NULL;
5458 Elf_Internal_Sym * psym;
5461 if (section->sh_size == 0)
5463 if (num_syms_return != NULL)
5464 * num_syms_return = 0;
5468 /* Run some sanity checks first. */
5469 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (section),
5473 (unsigned long) section->sh_entsize);
5477 if (section->sh_size > current_file_size)
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (section),
5481 (unsigned long) section->sh_size);
5485 number = section->sh_size / section->sh_entsize;
5487 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5489 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490 (unsigned long) section->sh_size,
5491 printable_section_name (section),
5492 (unsigned long) section->sh_entsize);
5496 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5497 section->sh_size, _("symbols"));
5502 elf_section_list * entry;
5505 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5506 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5508 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5509 entry->hdr->sh_offset,
5510 1, entry->hdr->sh_size,
5511 _("symbol table section indicies"));
5514 /* PR17531: file: heap-buffer-overflow */
5515 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5517 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5518 printable_section_name (entry->hdr),
5519 (unsigned long) entry->hdr->sh_size,
5520 (unsigned long) section->sh_size);
5526 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5530 error (_("Out of memory reading %lu symbols\n"),
5531 (unsigned long) number);
5535 for (j = 0, psym = isyms; j < number; j++, psym++)
5537 psym->st_name = BYTE_GET (esyms[j].st_name);
5538 psym->st_info = BYTE_GET (esyms[j].st_info);
5539 psym->st_other = BYTE_GET (esyms[j].st_other);
5540 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5542 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5544 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5545 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5546 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5548 psym->st_value = BYTE_GET (esyms[j].st_value);
5549 psym->st_size = BYTE_GET (esyms[j].st_size);
5558 if (num_syms_return != NULL)
5559 * num_syms_return = isyms == NULL ? 0 : number;
5565 get_elf_section_flags (bfd_vma sh_flags)
5567 static char buff[1024];
5569 unsigned int field_size = is_32bit_elf ? 8 : 16;
5571 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5572 bfd_vma os_flags = 0;
5573 bfd_vma proc_flags = 0;
5574 bfd_vma unknown_flags = 0;
5582 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5583 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5584 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5585 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5586 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5587 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5588 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5589 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5590 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5591 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5592 /* IA-64 specific. */
5593 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5594 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5595 /* IA-64 OpenVMS specific. */
5596 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5597 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5598 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5599 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5600 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5601 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5603 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604 /* SPARC specific. */
5605 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5608 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5612 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5614 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5617 if (do_section_details)
5619 sprintf (buff, "[%*.*lx]: ",
5620 field_size, field_size, (unsigned long) sh_flags);
5621 p += field_size + 4;
5628 flag = sh_flags & - sh_flags;
5631 if (do_section_details)
5635 case SHF_WRITE: sindex = 0; break;
5636 case SHF_ALLOC: sindex = 1; break;
5637 case SHF_EXECINSTR: sindex = 2; break;
5638 case SHF_MERGE: sindex = 3; break;
5639 case SHF_STRINGS: sindex = 4; break;
5640 case SHF_INFO_LINK: sindex = 5; break;
5641 case SHF_LINK_ORDER: sindex = 6; break;
5642 case SHF_OS_NONCONFORMING: sindex = 7; break;
5643 case SHF_GROUP: sindex = 8; break;
5644 case SHF_TLS: sindex = 9; break;
5645 case SHF_EXCLUDE: sindex = 18; break;
5646 case SHF_COMPRESSED: sindex = 20; break;
5647 case SHF_GNU_MBIND: sindex = 24; break;
5651 switch (elf_header.e_machine)
5654 if (flag == SHF_IA_64_SHORT)
5656 else if (flag == SHF_IA_64_NORECOV)
5659 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5662 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5663 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5664 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5665 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5666 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5667 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5678 case EM_OLD_SPARCV9:
5679 case EM_SPARC32PLUS:
5682 if (flag == SHF_ORDERED)
5689 case SHF_ENTRYSECT: sindex = 21; break;
5690 case SHF_ARM_PURECODE: sindex = 22; break;
5691 case SHF_COMDEF: sindex = 23; break;
5696 if (flag == SHF_PPC_VLE)
5707 if (p != buff + field_size + 4)
5709 if (size < (10 + 2))
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5719 size -= flags [sindex].len;
5720 p = stpcpy (p, flags [sindex].str);
5722 else if (flag & SHF_MASKOS)
5724 else if (flag & SHF_MASKPROC)
5727 unknown_flags |= flag;
5733 case SHF_WRITE: *p = 'W'; break;
5734 case SHF_ALLOC: *p = 'A'; break;
5735 case SHF_EXECINSTR: *p = 'X'; break;
5736 case SHF_MERGE: *p = 'M'; break;
5737 case SHF_STRINGS: *p = 'S'; break;
5738 case SHF_INFO_LINK: *p = 'I'; break;
5739 case SHF_LINK_ORDER: *p = 'L'; break;
5740 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5741 case SHF_GROUP: *p = 'G'; break;
5742 case SHF_TLS: *p = 'T'; break;
5743 case SHF_EXCLUDE: *p = 'E'; break;
5744 case SHF_COMPRESSED: *p = 'C'; break;
5745 case SHF_GNU_MBIND: *p = 'D'; break;
5748 if ((elf_header.e_machine == EM_X86_64
5749 || elf_header.e_machine == EM_L1OM
5750 || elf_header.e_machine == EM_K1OM)
5751 && flag == SHF_X86_64_LARGE)
5753 else if (elf_header.e_machine == EM_ARM
5754 && flag == SHF_ARM_PURECODE)
5756 else if (elf_header.e_machine == EM_PPC
5757 && flag == SHF_PPC_VLE)
5759 else if (flag & SHF_MASKOS)
5762 sh_flags &= ~ SHF_MASKOS;
5764 else if (flag & SHF_MASKPROC)
5767 sh_flags &= ~ SHF_MASKPROC;
5777 if (do_section_details)
5781 size -= 5 + field_size;
5782 if (p != buff + field_size + 4)
5786 warn (_("Internal error: not enough buffer room for section flag info"));
5787 return _("<unknown>");
5793 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5794 (unsigned long) os_flags);
5795 p += 5 + field_size;
5799 size -= 7 + field_size;
5800 if (p != buff + field_size + 4)
5804 warn (_("Internal error: not enough buffer room for section flag info"));
5805 return _("<unknown>");
5811 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5812 (unsigned long) proc_flags);
5813 p += 7 + field_size;
5817 size -= 10 + field_size;
5818 if (p != buff + field_size + 4)
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5829 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5830 (unsigned long) unknown_flags);
5831 p += 10 + field_size;
5840 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5844 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5846 if (size < sizeof (* echdr))
5848 error (_("Compressed section is too small even for a compression header\n"));
5852 chdr->ch_type = BYTE_GET (echdr->ch_type);
5853 chdr->ch_size = BYTE_GET (echdr->ch_size);
5854 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5855 return sizeof (*echdr);
5859 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5861 if (size < sizeof (* echdr))
5863 error (_("Compressed section is too small even for a compression header\n"));
5867 chdr->ch_type = BYTE_GET (echdr->ch_type);
5868 chdr->ch_size = BYTE_GET (echdr->ch_size);
5869 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5870 return sizeof (*echdr);
5875 process_section_headers (FILE * file)
5877 Elf_Internal_Shdr * section;
5880 section_headers = NULL;
5882 if (elf_header.e_shnum == 0)
5884 /* PR binutils/12467. */
5885 if (elf_header.e_shoff != 0)
5887 warn (_("possibly corrupt ELF file header - it has a non-zero"
5888 " section header offset, but no section headers\n"));
5891 else if (do_sections)
5892 printf (_("\nThere are no sections in this file.\n"));
5897 if (do_sections && !do_header)
5898 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5899 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5903 if (! get_32bit_section_headers (file, FALSE))
5908 if (! get_64bit_section_headers (file, FALSE))
5912 /* Read in the string table, so that we have names to display. */
5913 if (elf_header.e_shstrndx != SHN_UNDEF
5914 && elf_header.e_shstrndx < elf_header.e_shnum)
5916 section = section_headers + elf_header.e_shstrndx;
5918 if (section->sh_size != 0)
5920 string_table = (char *) get_data (NULL, file, section->sh_offset,
5921 1, section->sh_size,
5924 string_table_length = string_table != NULL ? section->sh_size : 0;
5928 /* Scan the sections for the dynamic symbol table
5929 and dynamic string table and debug sections. */
5930 dynamic_symbols = NULL;
5931 dynamic_strings = NULL;
5932 dynamic_syminfo = NULL;
5933 symtab_shndx_list = NULL;
5935 eh_addr_size = is_32bit_elf ? 4 : 8;
5936 switch (elf_header.e_machine)
5939 case EM_MIPS_RS3_LE:
5940 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5941 FDE addresses. However, the ABI also has a semi-official ILP32
5942 variant for which the normal FDE address size rules apply.
5944 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5945 section, where XX is the size of longs in bits. Unfortunately,
5946 earlier compilers provided no way of distinguishing ILP32 objects
5947 from LP64 objects, so if there's any doubt, we should assume that
5948 the official LP64 form is being used. */
5949 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5950 && find_section (".gcc_compiled_long32") == NULL)
5956 switch (elf_header.e_flags & EF_H8_MACH)
5958 case E_H8_MACH_H8300:
5959 case E_H8_MACH_H8300HN:
5960 case E_H8_MACH_H8300SN:
5961 case E_H8_MACH_H8300SXN:
5964 case E_H8_MACH_H8300H:
5965 case E_H8_MACH_H8300S:
5966 case E_H8_MACH_H8300SX:
5974 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5976 case EF_M32C_CPU_M16C:
5983 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5986 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5987 if (section->sh_entsize != expected_entsize) \
5990 sprintf_vma (buf, section->sh_entsize); \
5991 /* Note: coded this way so that there is a single string for \
5993 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5994 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5995 (unsigned) expected_entsize); \
5996 section->sh_entsize = expected_entsize; \
6001 #define CHECK_ENTSIZE(section, i, type) \
6002 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6003 sizeof (Elf64_External_##type))
6005 for (i = 0, section = section_headers;
6006 i < elf_header.e_shnum;
6009 char * name = SECTION_NAME (section);
6011 if (section->sh_type == SHT_DYNSYM)
6013 if (dynamic_symbols != NULL)
6015 error (_("File contains multiple dynamic symbol tables\n"));
6019 CHECK_ENTSIZE (section, i, Sym);
6020 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
6022 else if (section->sh_type == SHT_STRTAB
6023 && streq (name, ".dynstr"))
6025 if (dynamic_strings != NULL)
6027 error (_("File contains multiple dynamic string tables\n"));
6031 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
6032 1, section->sh_size,
6033 _("dynamic strings"));
6034 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6036 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6038 elf_section_list * entry = xmalloc (sizeof * entry);
6039 entry->hdr = section;
6040 entry->next = symtab_shndx_list;
6041 symtab_shndx_list = entry;
6043 else if (section->sh_type == SHT_SYMTAB)
6044 CHECK_ENTSIZE (section, i, Sym);
6045 else if (section->sh_type == SHT_GROUP)
6046 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6047 else if (section->sh_type == SHT_REL)
6048 CHECK_ENTSIZE (section, i, Rel);
6049 else if (section->sh_type == SHT_RELA)
6050 CHECK_ENTSIZE (section, i, Rela);
6051 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6052 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6053 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6054 || do_debug_str || do_debug_loc || do_debug_ranges
6055 || do_debug_addr || do_debug_cu_index)
6056 && (const_strneq (name, ".debug_")
6057 || const_strneq (name, ".zdebug_")))
6060 name += sizeof (".zdebug_") - 1;
6062 name += sizeof (".debug_") - 1;
6065 || (do_debug_info && const_strneq (name, "info"))
6066 || (do_debug_info && const_strneq (name, "types"))
6067 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6068 || (do_debug_lines && strcmp (name, "line") == 0)
6069 || (do_debug_lines && const_strneq (name, "line."))
6070 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6071 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6072 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6073 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6074 || (do_debug_aranges && const_strneq (name, "aranges"))
6075 || (do_debug_ranges && const_strneq (name, "ranges"))
6076 || (do_debug_ranges && const_strneq (name, "rnglists"))
6077 || (do_debug_frames && const_strneq (name, "frame"))
6078 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6079 || (do_debug_macinfo && const_strneq (name, "macro"))
6080 || (do_debug_str && const_strneq (name, "str"))
6081 || (do_debug_loc && const_strneq (name, "loc"))
6082 || (do_debug_loc && const_strneq (name, "loclists"))
6083 || (do_debug_addr && const_strneq (name, "addr"))
6084 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6085 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6087 request_dump_bynumber (i, DEBUG_DUMP);
6089 /* Linkonce section to be combined with .debug_info at link time. */
6090 else if ((do_debugging || do_debug_info)
6091 && const_strneq (name, ".gnu.linkonce.wi."))
6092 request_dump_bynumber (i, DEBUG_DUMP);
6093 else if (do_debug_frames && streq (name, ".eh_frame"))
6094 request_dump_bynumber (i, DEBUG_DUMP);
6095 else if (do_gdb_index && (streq (name, ".gdb_index")
6096 || streq (name, ".debug_names")))
6097 request_dump_bynumber (i, DEBUG_DUMP);
6098 /* Trace sections for Itanium VMS. */
6099 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6100 || do_trace_aranges)
6101 && const_strneq (name, ".trace_"))
6103 name += sizeof (".trace_") - 1;
6106 || (do_trace_info && streq (name, "info"))
6107 || (do_trace_abbrevs && streq (name, "abbrev"))
6108 || (do_trace_aranges && streq (name, "aranges"))
6110 request_dump_bynumber (i, DEBUG_DUMP);
6117 if (elf_header.e_shnum > 1)
6118 printf (_("\nSection Headers:\n"));
6120 printf (_("\nSection Header:\n"));
6124 if (do_section_details)
6126 printf (_(" [Nr] Name\n"));
6127 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6131 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6135 if (do_section_details)
6137 printf (_(" [Nr] Name\n"));
6138 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6142 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6146 if (do_section_details)
6148 printf (_(" [Nr] Name\n"));
6149 printf (_(" Type Address Offset Link\n"));
6150 printf (_(" Size EntSize Info Align\n"));
6154 printf (_(" [Nr] Name Type Address Offset\n"));
6155 printf (_(" Size EntSize Flags Link Info Align\n"));
6159 if (do_section_details)
6160 printf (_(" Flags\n"));
6162 for (i = 0, section = section_headers;
6163 i < elf_header.e_shnum;
6166 /* Run some sanity checks on the section header. */
6168 /* Check the sh_link field. */
6169 switch (section->sh_type)
6171 case SHT_SYMTAB_SHNDX:
6175 case SHT_GNU_versym:
6178 if (section->sh_link < 1
6179 || section->sh_link >= elf_header.e_shnum
6180 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6181 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6182 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6183 i, section->sh_link);
6189 case SHT_GNU_verneed:
6190 case SHT_GNU_verdef:
6191 case SHT_GNU_LIBLIST:
6192 if (section->sh_link < 1
6193 || section->sh_link >= elf_header.e_shnum
6194 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6195 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6196 i, section->sh_link);
6199 case SHT_INIT_ARRAY:
6200 case SHT_FINI_ARRAY:
6201 case SHT_PREINIT_ARRAY:
6202 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6203 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6204 i, section->sh_link);
6208 /* FIXME: Add support for target specific section types. */
6209 #if 0 /* Currently we do not check other section types as there are too
6210 many special cases. Stab sections for example have a type
6211 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6213 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6214 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6215 i, section->sh_link);
6220 /* Check the sh_info field. */
6221 switch (section->sh_type)
6225 if (section->sh_info < 1
6226 || section->sh_info >= elf_header.e_shnum
6227 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6228 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6229 && section_headers[section->sh_info].sh_type != SHT_NOTE
6230 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6231 /* FIXME: Are other section types valid ? */
6232 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6234 if (section->sh_info == 0
6235 && (streq (SECTION_NAME (section), ".rel.dyn")
6236 || streq (SECTION_NAME (section), ".rela.dyn")))
6237 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6238 of zero. The relocations in these sections may apply
6239 to many different sections. */
6242 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6243 i, section->sh_info);
6249 case SHT_SYMTAB_SHNDX:
6250 case SHT_INIT_ARRAY:
6251 case SHT_FINI_ARRAY:
6252 case SHT_PREINIT_ARRAY:
6253 if (section->sh_info != 0)
6254 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6255 i, section->sh_info);
6261 /* A symbol index - we assume that it is valid. */
6265 /* FIXME: Add support for target specific section types. */
6266 if (section->sh_type == SHT_NOBITS)
6267 /* NOBITS section headers with non-zero sh_info fields can be
6268 created when a binary is stripped of everything but its debug
6269 information. The stripped sections have their headers
6270 preserved but their types set to SHT_NOBITS. So do not check
6271 this type of section. */
6273 else if (section->sh_flags & SHF_INFO_LINK)
6275 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6276 warn (_("[%2u]: Expected link to another section in info field"), i);
6278 else if (section->sh_type < SHT_LOOS
6279 && (section->sh_flags & SHF_GNU_MBIND) == 0
6280 && section->sh_info != 0)
6281 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6282 i, section->sh_info);
6286 /* Check the sh_size field. */
6287 if (section->sh_size > current_file_size
6288 && section->sh_type != SHT_NOBITS
6289 && section->sh_type != SHT_NULL
6290 && section->sh_type < SHT_LOOS)
6291 warn (_("Size of section %u is larger than the entire file!\n"), i);
6293 printf (" [%2u] ", i);
6294 if (do_section_details)
6295 printf ("%s\n ", printable_section_name (section));
6297 print_symbol (-17, SECTION_NAME (section));
6299 printf (do_wide ? " %-15s " : " %-15.15s ",
6300 get_section_type_name (section->sh_type));
6304 const char * link_too_big = NULL;
6306 print_vma (section->sh_addr, LONG_HEX);
6308 printf ( " %6.6lx %6.6lx %2.2lx",
6309 (unsigned long) section->sh_offset,
6310 (unsigned long) section->sh_size,
6311 (unsigned long) section->sh_entsize);
6313 if (do_section_details)
6314 fputs (" ", stdout);
6316 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6318 if (section->sh_link >= elf_header.e_shnum)
6321 /* The sh_link value is out of range. Normally this indicates
6322 an error but it can have special values in Solaris binaries. */
6323 switch (elf_header.e_machine)
6330 case EM_OLD_SPARCV9:
6331 case EM_SPARC32PLUS:
6334 if (section->sh_link == (SHN_BEFORE & 0xffff))
6335 link_too_big = "BEFORE";
6336 else if (section->sh_link == (SHN_AFTER & 0xffff))
6337 link_too_big = "AFTER";
6344 if (do_section_details)
6346 if (link_too_big != NULL && * link_too_big)
6347 printf ("<%s> ", link_too_big);
6349 printf ("%2u ", section->sh_link);
6350 printf ("%3u %2lu\n", section->sh_info,
6351 (unsigned long) section->sh_addralign);
6354 printf ("%2u %3u %2lu\n",
6357 (unsigned long) section->sh_addralign);
6359 if (link_too_big && ! * link_too_big)
6360 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6361 i, section->sh_link);
6365 print_vma (section->sh_addr, LONG_HEX);
6367 if ((long) section->sh_offset == section->sh_offset)
6368 printf (" %6.6lx", (unsigned long) section->sh_offset);
6372 print_vma (section->sh_offset, LONG_HEX);
6375 if ((unsigned long) section->sh_size == section->sh_size)
6376 printf (" %6.6lx", (unsigned long) section->sh_size);
6380 print_vma (section->sh_size, LONG_HEX);
6383 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6384 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6388 print_vma (section->sh_entsize, LONG_HEX);
6391 if (do_section_details)
6392 fputs (" ", stdout);
6394 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6396 printf ("%2u %3u ", section->sh_link, section->sh_info);
6398 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6399 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6402 print_vma (section->sh_addralign, DEC);
6406 else if (do_section_details)
6408 printf (" %-15.15s ",
6409 get_section_type_name (section->sh_type));
6410 print_vma (section->sh_addr, LONG_HEX);
6411 if ((long) section->sh_offset == section->sh_offset)
6412 printf (" %16.16lx", (unsigned long) section->sh_offset);
6416 print_vma (section->sh_offset, LONG_HEX);
6418 printf (" %u\n ", section->sh_link);
6419 print_vma (section->sh_size, LONG_HEX);
6421 print_vma (section->sh_entsize, LONG_HEX);
6423 printf (" %-16u %lu\n",
6425 (unsigned long) section->sh_addralign);
6430 print_vma (section->sh_addr, LONG_HEX);
6431 if ((long) section->sh_offset == section->sh_offset)
6432 printf (" %8.8lx", (unsigned long) section->sh_offset);
6436 print_vma (section->sh_offset, LONG_HEX);
6439 print_vma (section->sh_size, LONG_HEX);
6441 print_vma (section->sh_entsize, LONG_HEX);
6443 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6445 printf (" %2u %3u %lu\n",
6448 (unsigned long) section->sh_addralign);
6451 if (do_section_details)
6453 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6454 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6456 /* Minimum section size is 12 bytes for 32-bit compression
6457 header + 12 bytes for compressed data header. */
6458 unsigned char buf[24];
6460 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6461 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6462 sizeof (buf), _("compression header")))
6464 Elf_Internal_Chdr chdr;
6466 (void) get_compression_header (&chdr, buf, sizeof (buf));
6468 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6471 printf (_(" [<unknown>: 0x%x], "),
6473 print_vma (chdr.ch_size, LONG_HEX);
6474 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6480 if (!do_section_details)
6482 /* The ordering of the letters shown here matches the ordering of the
6483 corresponding SHF_xxx values, and hence the order in which these
6484 letters will be displayed to the user. */
6485 printf (_("Key to Flags:\n\
6486 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6487 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6488 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6489 if (elf_header.e_machine == EM_X86_64
6490 || elf_header.e_machine == EM_L1OM
6491 || elf_header.e_machine == EM_K1OM)
6492 printf (_("l (large), "));
6493 else if (elf_header.e_machine == EM_ARM)
6494 printf (_("y (purecode), "));
6495 else if (elf_header.e_machine == EM_PPC)
6496 printf (_("v (VLE), "));
6497 printf ("p (processor specific)\n");
6504 get_group_flags (unsigned int flags)
6506 static char buff[128];
6510 else if (flags == GRP_COMDAT)
6513 snprintf (buff, 14, _("[0x%x: "), flags);
6515 flags &= ~ GRP_COMDAT;
6516 if (flags & GRP_MASKOS)
6518 strcat (buff, "<OS specific>");
6519 flags &= ~ GRP_MASKOS;
6522 if (flags & GRP_MASKPROC)
6524 strcat (buff, "<PROC specific>");
6525 flags &= ~ GRP_MASKPROC;
6529 strcat (buff, "<unknown>");
6536 process_section_groups (FILE * file)
6538 Elf_Internal_Shdr * section;
6540 struct group * group;
6541 Elf_Internal_Shdr * symtab_sec;
6542 Elf_Internal_Shdr * strtab_sec;
6543 Elf_Internal_Sym * symtab;
6544 unsigned long num_syms;
6548 /* Don't process section groups unless needed. */
6549 if (!do_unwind && !do_section_groups)
6552 if (elf_header.e_shnum == 0)
6554 if (do_section_groups)
6555 printf (_("\nThere are no sections to group in this file.\n"));
6560 if (section_headers == NULL)
6562 error (_("Section headers are not available!\n"));
6563 /* PR 13622: This can happen with a corrupt ELF header. */
6567 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6568 sizeof (struct group *));
6570 if (section_headers_groups == NULL)
6572 error (_("Out of memory reading %u section group headers\n"),
6573 elf_header.e_shnum);
6577 /* Scan the sections for the group section. */
6579 for (i = 0, section = section_headers;
6580 i < elf_header.e_shnum;
6582 if (section->sh_type == SHT_GROUP)
6585 if (group_count == 0)
6587 if (do_section_groups)
6588 printf (_("\nThere are no section groups in this file.\n"));
6593 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6595 if (section_groups == NULL)
6597 error (_("Out of memory reading %lu groups\n"),
6598 (unsigned long) group_count);
6608 for (i = 0, section = section_headers, group = section_groups;
6609 i < elf_header.e_shnum;
6612 if (section->sh_type == SHT_GROUP)
6614 const char * name = printable_section_name (section);
6615 const char * group_name;
6616 unsigned char * start;
6617 unsigned char * indices;
6618 unsigned int entry, j, size;
6619 Elf_Internal_Shdr * sec;
6620 Elf_Internal_Sym * sym;
6622 /* Get the symbol table. */
6623 if (section->sh_link >= elf_header.e_shnum
6624 || ((sec = section_headers + section->sh_link)->sh_type
6627 error (_("Bad sh_link in group section `%s'\n"), name);
6631 if (symtab_sec != sec)
6636 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6641 error (_("Corrupt header in group section `%s'\n"), name);
6645 if (section->sh_info >= num_syms)
6647 error (_("Bad sh_info in group section `%s'\n"), name);
6651 sym = symtab + section->sh_info;
6653 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6655 if (sym->st_shndx == 0
6656 || sym->st_shndx >= elf_header.e_shnum)
6658 error (_("Bad sh_info in group section `%s'\n"), name);
6662 group_name = SECTION_NAME (section_headers + sym->st_shndx);
6671 /* Get the string table. */
6672 if (symtab_sec->sh_link >= elf_header.e_shnum)
6681 != (sec = section_headers + symtab_sec->sh_link))
6687 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6688 1, strtab_sec->sh_size,
6690 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6692 group_name = sym->st_name < strtab_size
6693 ? strtab + sym->st_name : _("<corrupt>");
6696 /* PR 17531: file: loop. */
6697 if (section->sh_entsize > section->sh_size)
6699 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6700 printable_section_name (section),
6701 (unsigned long) section->sh_entsize,
6702 (unsigned long) section->sh_size);
6706 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6707 1, section->sh_size,
6713 size = (section->sh_size / section->sh_entsize) - 1;
6714 entry = byte_get (indices, 4);
6717 if (do_section_groups)
6719 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6720 get_group_flags (entry), i, name, group_name, size);
6722 printf (_(" [Index] Name\n"));
6725 group->group_index = i;
6727 for (j = 0; j < size; j++)
6729 struct group_list * g;
6731 entry = byte_get (indices, 4);
6734 if (entry >= elf_header.e_shnum)
6736 static unsigned num_group_errors = 0;
6738 if (num_group_errors ++ < 10)
6740 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6741 entry, i, elf_header.e_shnum - 1);
6742 if (num_group_errors == 10)
6743 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6748 if (section_headers_groups [entry] != NULL)
6752 static unsigned num_errs = 0;
6754 if (num_errs ++ < 10)
6756 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6758 section_headers_groups [entry]->group_index);
6760 warn (_("Further error messages about already contained group sections suppressed\n"));
6766 /* Intel C/C++ compiler may put section 0 in a
6767 section group. We just warn it the first time
6768 and ignore it afterwards. */
6769 static bfd_boolean warned = FALSE;
6772 error (_("section 0 in group section [%5u]\n"),
6773 section_headers_groups [entry]->group_index);
6779 section_headers_groups [entry] = group;
6781 if (do_section_groups)
6783 sec = section_headers + entry;
6784 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6787 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6788 g->section_index = entry;
6789 g->next = group->root;
6807 /* Data used to display dynamic fixups. */
6809 struct ia64_vms_dynfixup
6811 bfd_vma needed_ident; /* Library ident number. */
6812 bfd_vma needed; /* Index in the dstrtab of the library name. */
6813 bfd_vma fixup_needed; /* Index of the library. */
6814 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6815 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6818 /* Data used to display dynamic relocations. */
6820 struct ia64_vms_dynimgrela
6822 bfd_vma img_rela_cnt; /* Number of relocations. */
6823 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6826 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6830 dump_ia64_vms_dynamic_fixups (FILE * file,
6831 struct ia64_vms_dynfixup * fixup,
6832 const char * strtab,
6833 unsigned int strtab_sz)
6835 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6837 const char * lib_name;
6839 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6840 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6841 _("dynamic section image fixups"));
6845 if (fixup->needed < strtab_sz)
6846 lib_name = strtab + fixup->needed;
6849 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6850 (unsigned long) fixup->needed);
6853 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6854 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6856 (_("Seg Offset Type SymVec DataType\n"));
6858 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6863 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6864 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6865 type = BYTE_GET (imfs [i].type);
6866 rtype = elf_ia64_reloc_type (type);
6868 printf (" 0x%08x ", type);
6870 printf (" %-32s ", rtype);
6871 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6872 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6879 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6882 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6884 Elf64_External_VMS_IMAGE_RELA *imrs;
6887 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6888 1, imgrela->img_rela_cnt * sizeof (*imrs),
6889 _("dynamic section image relocations"));
6893 printf (_("\nImage relocs\n"));
6895 (_("Seg Offset Type Addend Seg Sym Off\n"));
6897 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6902 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6903 printf ("%08" BFD_VMA_FMT "x ",
6904 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6905 type = BYTE_GET (imrs [i].type);
6906 rtype = elf_ia64_reloc_type (type);
6908 printf ("0x%08x ", type);
6910 printf ("%-31s ", rtype);
6911 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6912 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6913 printf ("%08" BFD_VMA_FMT "x\n",
6914 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6921 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6924 process_ia64_vms_dynamic_relocs (FILE *file)
6926 struct ia64_vms_dynfixup fixup;
6927 struct ia64_vms_dynimgrela imgrela;
6928 Elf_Internal_Dyn *entry;
6929 bfd_vma strtab_off = 0;
6930 bfd_vma strtab_sz = 0;
6931 char *strtab = NULL;
6932 bfd_boolean res = TRUE;
6934 memset (&fixup, 0, sizeof (fixup));
6935 memset (&imgrela, 0, sizeof (imgrela));
6937 /* Note: the order of the entries is specified by the OpenVMS specs. */
6938 for (entry = dynamic_section;
6939 entry < dynamic_section + dynamic_nent;
6942 switch (entry->d_tag)
6944 case DT_IA_64_VMS_STRTAB_OFFSET:
6945 strtab_off = entry->d_un.d_val;
6948 strtab_sz = entry->d_un.d_val;
6950 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6951 1, strtab_sz, _("dynamic string section"));
6954 case DT_IA_64_VMS_NEEDED_IDENT:
6955 fixup.needed_ident = entry->d_un.d_val;
6958 fixup.needed = entry->d_un.d_val;
6960 case DT_IA_64_VMS_FIXUP_NEEDED:
6961 fixup.fixup_needed = entry->d_un.d_val;
6963 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6964 fixup.fixup_rela_cnt = entry->d_un.d_val;
6966 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6967 fixup.fixup_rela_off = entry->d_un.d_val;
6968 if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6971 case DT_IA_64_VMS_IMG_RELA_CNT:
6972 imgrela.img_rela_cnt = entry->d_un.d_val;
6974 case DT_IA_64_VMS_IMG_RELA_OFF:
6975 imgrela.img_rela_off = entry->d_un.d_val;
6976 if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6998 dynamic_relocations [] =
7000 { "REL", DT_REL, DT_RELSZ, FALSE },
7001 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7002 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7005 /* Process the reloc section. */
7008 process_relocs (FILE * file)
7010 unsigned long rel_size;
7011 unsigned long rel_offset;
7016 if (do_using_dynamic)
7020 bfd_boolean has_dynamic_reloc;
7023 has_dynamic_reloc = FALSE;
7025 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7027 is_rela = dynamic_relocations [i].rela;
7028 name = dynamic_relocations [i].name;
7029 rel_size = dynamic_info [dynamic_relocations [i].size];
7030 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7033 has_dynamic_reloc = TRUE;
7035 if (is_rela == UNKNOWN)
7037 if (dynamic_relocations [i].reloc == DT_JMPREL)
7038 switch (dynamic_info[DT_PLTREL])
7052 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7053 name, rel_offset, rel_size);
7055 dump_relocations (file,
7056 offset_from_vma (file, rel_offset, rel_size),
7058 dynamic_symbols, num_dynamic_syms,
7059 dynamic_strings, dynamic_strings_length,
7060 is_rela, TRUE /* is_dynamic */);
7065 if (process_ia64_vms_dynamic_relocs (file))
7066 has_dynamic_reloc = TRUE;
7068 if (! has_dynamic_reloc)
7069 printf (_("\nThere are no dynamic relocations in this file.\n"));
7073 Elf_Internal_Shdr * section;
7075 bfd_boolean found = FALSE;
7077 for (i = 0, section = section_headers;
7078 i < elf_header.e_shnum;
7081 if ( section->sh_type != SHT_RELA
7082 && section->sh_type != SHT_REL)
7085 rel_offset = section->sh_offset;
7086 rel_size = section->sh_size;
7090 Elf_Internal_Shdr * strsec;
7093 printf (_("\nRelocation section "));
7095 if (string_table == NULL)
7096 printf ("%d", section->sh_name);
7098 printf ("'%s'", printable_section_name (section));
7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
7103 is_rela = section->sh_type == SHT_RELA;
7105 if (section->sh_link != 0
7106 && section->sh_link < elf_header.e_shnum)
7108 Elf_Internal_Shdr * symsec;
7109 Elf_Internal_Sym * symtab;
7110 unsigned long nsyms;
7111 unsigned long strtablen = 0;
7112 char * strtab = NULL;
7114 symsec = section_headers + section->sh_link;
7115 if (symsec->sh_type != SHT_SYMTAB
7116 && symsec->sh_type != SHT_DYNSYM)
7119 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
7124 if (symsec->sh_link != 0
7125 && symsec->sh_link < elf_header.e_shnum)
7127 strsec = section_headers + symsec->sh_link;
7129 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7132 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7135 dump_relocations (file, rel_offset, rel_size,
7136 symtab, nsyms, strtab, strtablen,
7138 symsec->sh_type == SHT_DYNSYM);
7144 dump_relocations (file, rel_offset, rel_size,
7145 NULL, 0, NULL, 0, is_rela,
7146 FALSE /* is_dynamic */);
7154 /* Users sometimes forget the -D option, so try to be helpful. */
7155 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7157 if (dynamic_info [dynamic_relocations [i].size])
7159 printf (_("\nThere are no static relocations in this file."));
7160 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7165 if (i == ARRAY_SIZE (dynamic_relocations))
7166 printf (_("\nThere are no relocations in this file.\n"));
7173 /* An absolute address consists of a section and an offset. If the
7174 section is NULL, the offset itself is the address, otherwise, the
7175 address equals to LOAD_ADDRESS(section) + offset. */
7179 unsigned short section;
7183 #define ABSADDR(a) \
7185 ? section_headers [(a).section].sh_addr + (a).offset \
7188 /* Find the nearest symbol at or below ADDR. Returns the symbol
7189 name, if found, and the offset from the symbol to ADDR. */
7192 find_symbol_for_address (Elf_Internal_Sym * symtab,
7193 unsigned long nsyms,
7194 const char * strtab,
7195 unsigned long strtab_size,
7196 struct absaddr addr,
7197 const char ** symname,
7200 bfd_vma dist = 0x100000;
7201 Elf_Internal_Sym * sym;
7202 Elf_Internal_Sym * beg;
7203 Elf_Internal_Sym * end;
7204 Elf_Internal_Sym * best = NULL;
7206 REMOVE_ARCH_BITS (addr.offset);
7208 end = symtab + nsyms;
7214 sym = beg + (end - beg) / 2;
7216 value = sym->st_value;
7217 REMOVE_ARCH_BITS (value);
7219 if (sym->st_name != 0
7220 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7221 && addr.offset >= value
7222 && addr.offset - value < dist)
7225 dist = addr.offset - value;
7230 if (addr.offset < value)
7238 *symname = (best->st_name >= strtab_size
7239 ? _("<corrupt>") : strtab + best->st_name);
7245 *offset = addr.offset;
7248 static /* signed */ int
7249 symcmp (const void *p, const void *q)
7251 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7252 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7254 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7257 /* Process the unwind section. */
7259 #include "unwind-ia64.h"
7261 struct ia64_unw_table_entry
7263 struct absaddr start;
7265 struct absaddr info;
7268 struct ia64_unw_aux_info
7270 struct ia64_unw_table_entry * table; /* Unwind table. */
7271 unsigned long table_len; /* Length of unwind table. */
7272 unsigned char * info; /* Unwind info. */
7273 unsigned long info_size; /* Size of unwind info. */
7274 bfd_vma info_addr; /* Starting address of unwind info. */
7275 bfd_vma seg_base; /* Starting address of segment. */
7276 Elf_Internal_Sym * symtab; /* The symbol table. */
7277 unsigned long nsyms; /* Number of symbols. */
7278 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7279 unsigned long nfuns; /* Number of entries in funtab. */
7280 char * strtab; /* The string table. */
7281 unsigned long strtab_size; /* Size of string table. */
7285 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7287 struct ia64_unw_table_entry * tp;
7288 unsigned long j, nfuns;
7290 bfd_boolean res = TRUE;
7292 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7293 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7294 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7295 aux->funtab[nfuns++] = aux->symtab[j];
7297 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7299 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7303 const unsigned char * dp;
7304 const unsigned char * head;
7305 const unsigned char * end;
7306 const char * procname;
7308 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7309 aux->strtab_size, tp->start, &procname, &offset);
7311 fputs ("\n<", stdout);
7315 fputs (procname, stdout);
7318 printf ("+%lx", (unsigned long) offset);
7321 fputs (">: [", stdout);
7322 print_vma (tp->start.offset, PREFIX_HEX);
7323 fputc ('-', stdout);
7324 print_vma (tp->end.offset, PREFIX_HEX);
7325 printf ("], info at +0x%lx\n",
7326 (unsigned long) (tp->info.offset - aux->seg_base));
7328 /* PR 17531: file: 86232b32. */
7329 if (aux->info == NULL)
7332 /* PR 17531: file: 0997b4d1. */
7333 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7335 warn (_("Invalid offset %lx in table entry %ld\n"),
7336 (long) tp->info.offset, (long) (tp - aux->table));
7341 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7342 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7344 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7345 (unsigned) UNW_VER (stamp),
7346 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7347 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7348 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7349 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7351 if (UNW_VER (stamp) != 1)
7353 printf (_("\tUnknown version.\n"));
7358 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7359 /* PR 17531: file: 16ceda89. */
7360 if (end > aux->info + aux->info_size)
7361 end = aux->info + aux->info_size;
7362 for (dp = head + 8; dp < end;)
7363 dp = unw_decode (dp, in_body, & in_body, end);
7372 slurp_ia64_unwind_table (FILE * file,
7373 struct ia64_unw_aux_info * aux,
7374 Elf_Internal_Shdr * sec)
7376 unsigned long size, nrelas, i;
7377 Elf_Internal_Phdr * seg;
7378 struct ia64_unw_table_entry * tep;
7379 Elf_Internal_Shdr * relsec;
7380 Elf_Internal_Rela * rela;
7381 Elf_Internal_Rela * rp;
7382 unsigned char * table;
7384 Elf_Internal_Sym * sym;
7385 const char * relname;
7389 /* First, find the starting address of the segment that includes
7392 if (elf_header.e_phnum)
7394 if (! get_program_headers (file))
7397 for (seg = program_headers;
7398 seg < program_headers + elf_header.e_phnum;
7401 if (seg->p_type != PT_LOAD)
7404 if (sec->sh_addr >= seg->p_vaddr
7405 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7407 aux->seg_base = seg->p_vaddr;
7413 /* Second, build the unwind table from the contents of the unwind section: */
7414 size = sec->sh_size;
7415 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7420 aux->table_len = size / (3 * eh_addr_size);
7421 aux->table = (struct ia64_unw_table_entry *)
7422 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7425 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7427 tep->start.section = SHN_UNDEF;
7428 tep->end.section = SHN_UNDEF;
7429 tep->info.section = SHN_UNDEF;
7430 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7431 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7432 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7433 tep->start.offset += aux->seg_base;
7434 tep->end.offset += aux->seg_base;
7435 tep->info.offset += aux->seg_base;
7439 /* Third, apply any relocations to the unwind table: */
7440 for (relsec = section_headers;
7441 relsec < section_headers + elf_header.e_shnum;
7444 if (relsec->sh_type != SHT_RELA
7445 || relsec->sh_info >= elf_header.e_shnum
7446 || section_headers + relsec->sh_info != sec)
7449 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7458 for (rp = rela; rp < rela + nrelas; ++rp)
7460 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7461 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7463 /* PR 17531: file: 9fa67536. */
7464 if (relname == NULL)
7466 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7470 if (! const_strneq (relname, "R_IA64_SEGREL"))
7472 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7476 i = rp->r_offset / (3 * eh_addr_size);
7478 /* PR 17531: file: 5bc8d9bf. */
7479 if (i >= aux->table_len)
7481 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7485 switch (rp->r_offset / eh_addr_size % 3)
7488 aux->table[i].start.section = sym->st_shndx;
7489 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7492 aux->table[i].end.section = sym->st_shndx;
7493 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7496 aux->table[i].info.section = sym->st_shndx;
7497 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7511 ia64_process_unwind (FILE * file)
7513 Elf_Internal_Shdr * sec;
7514 Elf_Internal_Shdr * unwsec = NULL;
7515 Elf_Internal_Shdr * strsec;
7516 unsigned long i, unwcount = 0, unwstart = 0;
7517 struct ia64_unw_aux_info aux;
7518 bfd_boolean res = TRUE;
7520 memset (& aux, 0, sizeof (aux));
7522 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7524 if (sec->sh_type == SHT_SYMTAB
7525 && sec->sh_link < elf_header.e_shnum)
7527 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7529 strsec = section_headers + sec->sh_link;
7530 if (aux.strtab != NULL)
7532 error (_("Multiple auxillary string tables encountered\n"));
7536 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7539 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7541 else if (sec->sh_type == SHT_IA_64_UNWIND)
7546 printf (_("\nThere are no unwind sections in this file.\n"));
7548 while (unwcount-- > 0)
7553 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7554 i < elf_header.e_shnum; ++i, ++sec)
7555 if (sec->sh_type == SHT_IA_64_UNWIND)
7560 /* We have already counted the number of SHT_IA64_UNWIND
7561 sections so the loop above should never fail. */
7562 assert (unwsec != NULL);
7565 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7567 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7569 /* We need to find which section group it is in. */
7570 struct group_list * g;
7572 if (section_headers_groups == NULL
7573 || section_headers_groups [i] == NULL)
7574 i = elf_header.e_shnum;
7577 g = section_headers_groups [i]->root;
7579 for (; g != NULL; g = g->next)
7581 sec = section_headers + g->section_index;
7583 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7588 i = elf_header.e_shnum;
7591 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7593 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7594 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7595 suffix = SECTION_NAME (unwsec) + len;
7596 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7598 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7599 && streq (SECTION_NAME (sec) + len2, suffix))
7604 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7605 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7606 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7607 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7609 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7610 suffix = SECTION_NAME (unwsec) + len;
7611 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7613 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7614 && streq (SECTION_NAME (sec) + len2, suffix))
7618 if (i == elf_header.e_shnum)
7620 printf (_("\nCould not find unwind info section for "));
7622 if (string_table == NULL)
7623 printf ("%d", unwsec->sh_name);
7625 printf ("'%s'", printable_section_name (unwsec));
7629 aux.info_addr = sec->sh_addr;
7630 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7633 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7635 printf (_("\nUnwind section "));
7637 if (string_table == NULL)
7638 printf ("%d", unwsec->sh_name);
7640 printf ("'%s'", printable_section_name (unwsec));
7642 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7643 (unsigned long) unwsec->sh_offset,
7644 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7646 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7647 && aux.table_len > 0)
7648 dump_ia64_unwind (& aux);
7651 free ((char *) aux.table);
7653 free ((char *) aux.info);
7662 free ((char *) aux.strtab);
7667 struct hppa_unw_table_entry
7669 struct absaddr start;
7671 unsigned int Cannot_unwind:1; /* 0 */
7672 unsigned int Millicode:1; /* 1 */
7673 unsigned int Millicode_save_sr0:1; /* 2 */
7674 unsigned int Region_description:2; /* 3..4 */
7675 unsigned int reserved1:1; /* 5 */
7676 unsigned int Entry_SR:1; /* 6 */
7677 unsigned int Entry_FR:4; /* Number saved 7..10 */
7678 unsigned int Entry_GR:5; /* Number saved 11..15 */
7679 unsigned int Args_stored:1; /* 16 */
7680 unsigned int Variable_Frame:1; /* 17 */
7681 unsigned int Separate_Package_Body:1; /* 18 */
7682 unsigned int Frame_Extension_Millicode:1; /* 19 */
7683 unsigned int Stack_Overflow_Check:1; /* 20 */
7684 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7685 unsigned int Ada_Region:1; /* 22 */
7686 unsigned int cxx_info:1; /* 23 */
7687 unsigned int cxx_try_catch:1; /* 24 */
7688 unsigned int sched_entry_seq:1; /* 25 */
7689 unsigned int reserved2:1; /* 26 */
7690 unsigned int Save_SP:1; /* 27 */
7691 unsigned int Save_RP:1; /* 28 */
7692 unsigned int Save_MRP_in_frame:1; /* 29 */
7693 unsigned int extn_ptr_defined:1; /* 30 */
7694 unsigned int Cleanup_defined:1; /* 31 */
7696 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7697 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7698 unsigned int Large_frame:1; /* 2 */
7699 unsigned int Pseudo_SP_Set:1; /* 3 */
7700 unsigned int reserved4:1; /* 4 */
7701 unsigned int Total_frame_size:27; /* 5..31 */
7704 struct hppa_unw_aux_info
7706 struct hppa_unw_table_entry * table; /* Unwind table. */
7707 unsigned long table_len; /* Length of unwind table. */
7708 bfd_vma seg_base; /* Starting address of segment. */
7709 Elf_Internal_Sym * symtab; /* The symbol table. */
7710 unsigned long nsyms; /* Number of symbols. */
7711 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7712 unsigned long nfuns; /* Number of entries in funtab. */
7713 char * strtab; /* The string table. */
7714 unsigned long strtab_size; /* Size of string table. */
7718 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7720 struct hppa_unw_table_entry * tp;
7721 unsigned long j, nfuns;
7722 bfd_boolean res = TRUE;
7724 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7725 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7726 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7727 aux->funtab[nfuns++] = aux->symtab[j];
7729 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7731 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7734 const char * procname;
7736 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7737 aux->strtab_size, tp->start, &procname,
7740 fputs ("\n<", stdout);
7744 fputs (procname, stdout);
7747 printf ("+%lx", (unsigned long) offset);
7750 fputs (">: [", stdout);
7751 print_vma (tp->start.offset, PREFIX_HEX);
7752 fputc ('-', stdout);
7753 print_vma (tp->end.offset, PREFIX_HEX);
7756 #define PF(_m) if (tp->_m) printf (#_m " ");
7757 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7760 PF(Millicode_save_sr0);
7761 /* PV(Region_description); */
7767 PF(Separate_Package_Body);
7768 PF(Frame_Extension_Millicode);
7769 PF(Stack_Overflow_Check);
7770 PF(Two_Instruction_SP_Increment);
7774 PF(sched_entry_seq);
7777 PF(Save_MRP_in_frame);
7778 PF(extn_ptr_defined);
7779 PF(Cleanup_defined);
7780 PF(MPE_XL_interrupt_marker);
7781 PF(HP_UX_interrupt_marker);
7784 PV(Total_frame_size);
7797 slurp_hppa_unwind_table (FILE * file,
7798 struct hppa_unw_aux_info * aux,
7799 Elf_Internal_Shdr * sec)
7801 unsigned long size, unw_ent_size, nentries, nrelas, i;
7802 Elf_Internal_Phdr * seg;
7803 struct hppa_unw_table_entry * tep;
7804 Elf_Internal_Shdr * relsec;
7805 Elf_Internal_Rela * rela;
7806 Elf_Internal_Rela * rp;
7807 unsigned char * table;
7809 Elf_Internal_Sym * sym;
7810 const char * relname;
7812 /* First, find the starting address of the segment that includes
7814 if (elf_header.e_phnum)
7816 if (! get_program_headers (file))
7819 for (seg = program_headers;
7820 seg < program_headers + elf_header.e_phnum;
7823 if (seg->p_type != PT_LOAD)
7826 if (sec->sh_addr >= seg->p_vaddr
7827 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7829 aux->seg_base = seg->p_vaddr;
7835 /* Second, build the unwind table from the contents of the unwind
7837 size = sec->sh_size;
7838 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7844 nentries = size / unw_ent_size;
7845 size = unw_ent_size * nentries;
7847 tep = aux->table = (struct hppa_unw_table_entry *)
7848 xcmalloc (nentries, sizeof (aux->table[0]));
7850 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7852 unsigned int tmp1, tmp2;
7854 tep->start.section = SHN_UNDEF;
7855 tep->end.section = SHN_UNDEF;
7857 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7858 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7859 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7860 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7862 tep->start.offset += aux->seg_base;
7863 tep->end.offset += aux->seg_base;
7865 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7866 tep->Millicode = (tmp1 >> 30) & 0x1;
7867 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7868 tep->Region_description = (tmp1 >> 27) & 0x3;
7869 tep->reserved1 = (tmp1 >> 26) & 0x1;
7870 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7871 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7872 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7873 tep->Args_stored = (tmp1 >> 15) & 0x1;
7874 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7875 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7876 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7877 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7878 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7879 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7880 tep->cxx_info = (tmp1 >> 8) & 0x1;
7881 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7882 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7883 tep->reserved2 = (tmp1 >> 5) & 0x1;
7884 tep->Save_SP = (tmp1 >> 4) & 0x1;
7885 tep->Save_RP = (tmp1 >> 3) & 0x1;
7886 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7887 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7888 tep->Cleanup_defined = tmp1 & 0x1;
7890 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7891 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7892 tep->Large_frame = (tmp2 >> 29) & 0x1;
7893 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7894 tep->reserved4 = (tmp2 >> 27) & 0x1;
7895 tep->Total_frame_size = tmp2 & 0x7ffffff;
7899 /* Third, apply any relocations to the unwind table. */
7900 for (relsec = section_headers;
7901 relsec < section_headers + elf_header.e_shnum;
7904 if (relsec->sh_type != SHT_RELA
7905 || relsec->sh_info >= elf_header.e_shnum
7906 || section_headers + relsec->sh_info != sec)
7909 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7913 for (rp = rela; rp < rela + nrelas; ++rp)
7915 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7916 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7918 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7919 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7921 warn (_("Skipping unexpected relocation type %s\n"), relname);
7925 i = rp->r_offset / unw_ent_size;
7927 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7930 aux->table[i].start.section = sym->st_shndx;
7931 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7934 aux->table[i].end.section = sym->st_shndx;
7935 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7945 aux->table_len = nentries;
7951 hppa_process_unwind (FILE * file)
7953 struct hppa_unw_aux_info aux;
7954 Elf_Internal_Shdr * unwsec = NULL;
7955 Elf_Internal_Shdr * strsec;
7956 Elf_Internal_Shdr * sec;
7958 bfd_boolean res = TRUE;
7960 if (string_table == NULL)
7963 memset (& aux, 0, sizeof (aux));
7965 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7967 if (sec->sh_type == SHT_SYMTAB
7968 && sec->sh_link < elf_header.e_shnum)
7970 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7972 strsec = section_headers + sec->sh_link;
7973 if (aux.strtab != NULL)
7975 error (_("Multiple auxillary string tables encountered\n"));
7979 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7982 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7984 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7989 printf (_("\nThere are no unwind sections in this file.\n"));
7991 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7993 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7995 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7996 printable_section_name (sec),
7997 (unsigned long) sec->sh_offset,
7998 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
8000 if (! slurp_hppa_unwind_table (file, &aux, sec))
8003 if (aux.table_len > 0)
8005 if (! dump_hppa_unwind (&aux))
8010 free ((char *) aux.table);
8018 free ((char *) aux.strtab);
8025 unsigned char * data; /* The unwind data. */
8026 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8027 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8028 unsigned long nrelas; /* The number of relocations. */
8029 unsigned int rel_type; /* REL or RELA ? */
8030 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8033 struct arm_unw_aux_info
8035 FILE * file; /* The file containing the unwind sections. */
8036 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8037 unsigned long nsyms; /* Number of symbols. */
8038 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8039 unsigned long nfuns; /* Number of these symbols. */
8040 char * strtab; /* The file's string table. */
8041 unsigned long strtab_size; /* Size of string table. */
8045 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
8046 bfd_vma fn, struct absaddr addr)
8048 const char *procname;
8051 if (addr.section == SHN_UNDEF)
8054 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
8055 aux->strtab_size, addr, &procname,
8058 print_vma (fn, PREFIX_HEX);
8062 fputs (" <", stdout);
8063 fputs (procname, stdout);
8066 printf ("+0x%lx", (unsigned long) sym_offset);
8067 fputc ('>', stdout);
8074 arm_free_section (struct arm_section *arm_sec)
8076 if (arm_sec->data != NULL)
8077 free (arm_sec->data);
8079 if (arm_sec->rela != NULL)
8080 free (arm_sec->rela);
8083 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8084 cached section and install SEC instead.
8085 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8086 and return its valued in * WORDP, relocating if necessary.
8087 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8088 relocation's offset in ADDR.
8089 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8090 into the string table of the symbol associated with the reloc. If no
8091 reloc was applied store -1 there.
8092 5) Return TRUE upon success, FALSE otherwise. */
8095 get_unwind_section_word (struct arm_unw_aux_info * aux,
8096 struct arm_section * arm_sec,
8097 Elf_Internal_Shdr * sec,
8098 bfd_vma word_offset,
8099 unsigned int * wordp,
8100 struct absaddr * addr,
8103 Elf_Internal_Rela *rp;
8104 Elf_Internal_Sym *sym;
8105 const char * relname;
8107 bfd_boolean wrapped;
8109 if (sec == NULL || arm_sec == NULL)
8112 addr->section = SHN_UNDEF;
8115 if (sym_name != NULL)
8116 *sym_name = (bfd_vma) -1;
8118 /* If necessary, update the section cache. */
8119 if (sec != arm_sec->sec)
8121 Elf_Internal_Shdr *relsec;
8123 arm_free_section (arm_sec);
8126 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
8127 sec->sh_size, _("unwind data"));
8128 arm_sec->rela = NULL;
8129 arm_sec->nrelas = 0;
8131 for (relsec = section_headers;
8132 relsec < section_headers + elf_header.e_shnum;
8135 if (relsec->sh_info >= elf_header.e_shnum
8136 || section_headers + relsec->sh_info != sec
8137 /* PR 15745: Check the section type as well. */
8138 || (relsec->sh_type != SHT_REL
8139 && relsec->sh_type != SHT_RELA))
8142 arm_sec->rel_type = relsec->sh_type;
8143 if (relsec->sh_type == SHT_REL)
8145 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
8147 & arm_sec->rela, & arm_sec->nrelas))
8150 else /* relsec->sh_type == SHT_RELA */
8152 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8154 & arm_sec->rela, & arm_sec->nrelas))
8160 arm_sec->next_rela = arm_sec->rela;
8163 /* If there is no unwind data we can do nothing. */
8164 if (arm_sec->data == NULL)
8167 /* If the offset is invalid then fail. */
8168 if (/* PR 21343 *//* PR 18879 */
8170 || word_offset > (sec->sh_size - 4)
8171 || ((bfd_signed_vma) word_offset) < 0)
8174 /* Get the word at the required offset. */
8175 word = byte_get (arm_sec->data + word_offset, 4);
8177 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8178 if (arm_sec->rela == NULL)
8184 /* Look through the relocs to find the one that applies to the provided offset. */
8186 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8188 bfd_vma prelval, offset;
8190 if (rp->r_offset > word_offset && !wrapped)
8195 if (rp->r_offset > word_offset)
8198 if (rp->r_offset & 3)
8200 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8201 (unsigned long) rp->r_offset);
8205 if (rp->r_offset < word_offset)
8208 /* PR 17531: file: 027-161405-0.004 */
8209 if (aux->symtab == NULL)
8212 if (arm_sec->rel_type == SHT_REL)
8214 offset = word & 0x7fffffff;
8215 if (offset & 0x40000000)
8216 offset |= ~ (bfd_vma) 0x7fffffff;
8218 else if (arm_sec->rel_type == SHT_RELA)
8219 offset = rp->r_addend;
8222 error (_("Unknown section relocation type %d encountered\n"),
8227 /* PR 17531 file: 027-1241568-0.004. */
8228 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8230 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8231 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8235 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8236 offset += sym->st_value;
8237 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8239 /* Check that we are processing the expected reloc type. */
8240 if (elf_header.e_machine == EM_ARM)
8242 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8243 if (relname == NULL)
8245 warn (_("Skipping unknown ARM relocation type: %d\n"),
8246 (int) ELF32_R_TYPE (rp->r_info));
8250 if (streq (relname, "R_ARM_NONE"))
8253 if (! streq (relname, "R_ARM_PREL31"))
8255 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8259 else if (elf_header.e_machine == EM_TI_C6000)
8261 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8262 if (relname == NULL)
8264 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8265 (int) ELF32_R_TYPE (rp->r_info));
8269 if (streq (relname, "R_C6000_NONE"))
8272 if (! streq (relname, "R_C6000_PREL31"))
8274 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8282 /* This function currently only supports ARM and TI unwinders. */
8283 warn (_("Only TI and ARM unwinders are currently supported\n"));
8287 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8288 addr->section = sym->st_shndx;
8289 addr->offset = offset;
8292 * sym_name = sym->st_name;
8297 arm_sec->next_rela = rp;
8302 static const char *tic6x_unwind_regnames[16] =
8304 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8305 "A14", "A13", "A12", "A11", "A10",
8306 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8310 decode_tic6x_unwind_regmask (unsigned int mask)
8314 for (i = 12; mask; mask >>= 1, i--)
8318 fputs (tic6x_unwind_regnames[i], stdout);
8320 fputs (", ", stdout);
8326 if (remaining == 0 && more_words) \
8329 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8330 data_offset, & word, & addr, NULL)) \
8336 #define GET_OP(OP) \
8341 (OP) = word >> 24; \
8346 printf (_("[Truncated opcode]\n")); \
8349 printf ("0x%02x ", OP)
8352 decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8354 unsigned int remaining,
8355 unsigned int more_words,
8356 bfd_vma data_offset,
8357 Elf_Internal_Shdr * data_sec,
8358 struct arm_section * data_arm_sec)
8360 struct absaddr addr;
8361 bfd_boolean res = TRUE;
8363 /* Decode the unwinding instructions. */
8366 unsigned int op, op2;
8375 printf (" 0x%02x ", op);
8377 if ((op & 0xc0) == 0x00)
8379 int offset = ((op & 0x3f) << 2) + 4;
8381 printf (" vsp = vsp + %d", offset);
8383 else if ((op & 0xc0) == 0x40)
8385 int offset = ((op & 0x3f) << 2) + 4;
8387 printf (" vsp = vsp - %d", offset);
8389 else if ((op & 0xf0) == 0x80)
8392 if (op == 0x80 && op2 == 0)
8393 printf (_("Refuse to unwind"));
8396 unsigned int mask = ((op & 0x0f) << 8) | op2;
8397 bfd_boolean first = TRUE;
8401 for (i = 0; i < 12; i++)
8402 if (mask & (1 << i))
8408 printf ("r%d", 4 + i);
8413 else if ((op & 0xf0) == 0x90)
8415 if (op == 0x9d || op == 0x9f)
8416 printf (_(" [Reserved]"));
8418 printf (" vsp = r%d", op & 0x0f);
8420 else if ((op & 0xf0) == 0xa0)
8422 int end = 4 + (op & 0x07);
8423 bfd_boolean first = TRUE;
8427 for (i = 4; i <= end; i++)
8443 else if (op == 0xb0)
8444 printf (_(" finish"));
8445 else if (op == 0xb1)
8448 if (op2 == 0 || (op2 & 0xf0) != 0)
8449 printf (_("[Spare]"));
8452 unsigned int mask = op2 & 0x0f;
8453 bfd_boolean first = TRUE;
8457 for (i = 0; i < 12; i++)
8458 if (mask & (1 << i))
8469 else if (op == 0xb2)
8471 unsigned char buf[9];
8472 unsigned int i, len;
8473 unsigned long offset;
8475 for (i = 0; i < sizeof (buf); i++)
8478 if ((buf[i] & 0x80) == 0)
8481 if (i == sizeof (buf))
8483 error (_("corrupt change to vsp"));
8488 offset = read_uleb128 (buf, &len, buf + i + 1);
8489 assert (len == i + 1);
8490 offset = offset * 4 + 0x204;
8491 printf ("vsp = vsp + %ld", offset);
8494 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8496 unsigned int first, last;
8503 printf ("pop {D%d", first);
8505 printf ("-D%d", first + last);
8508 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8510 unsigned int count = op & 0x07;
8514 printf ("-D%d", 8 + count);
8517 else if (op >= 0xc0 && op <= 0xc5)
8519 unsigned int count = op & 0x07;
8521 printf (" pop {wR10");
8523 printf ("-wR%d", 10 + count);
8526 else if (op == 0xc6)
8528 unsigned int first, last;
8533 printf ("pop {wR%d", first);
8535 printf ("-wR%d", first + last);
8538 else if (op == 0xc7)
8541 if (op2 == 0 || (op2 & 0xf0) != 0)
8542 printf (_("[Spare]"));
8545 unsigned int mask = op2 & 0x0f;
8546 bfd_boolean first = TRUE;
8550 for (i = 0; i < 4; i++)
8551 if (mask & (1 << i))
8557 printf ("wCGR%d", i);
8564 printf (_(" [unsupported opcode]"));
8575 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8577 unsigned int remaining,
8578 unsigned int more_words,
8579 bfd_vma data_offset,
8580 Elf_Internal_Shdr * data_sec,
8581 struct arm_section * data_arm_sec)
8583 struct absaddr addr;
8585 /* Decode the unwinding instructions. */
8588 unsigned int op, op2;
8597 printf (" 0x%02x ", op);
8599 if ((op & 0xc0) == 0x00)
8601 int offset = ((op & 0x3f) << 3) + 8;
8602 printf (" sp = sp + %d", offset);
8604 else if ((op & 0xc0) == 0x80)
8607 if (op == 0x80 && op2 == 0)
8608 printf (_("Refuse to unwind"));
8611 unsigned int mask = ((op & 0x1f) << 8) | op2;
8613 printf ("pop compact {");
8617 decode_tic6x_unwind_regmask (mask);
8621 else if ((op & 0xf0) == 0xc0)
8629 unsigned int offset;
8633 /* Scan entire instruction first so that GET_OP output is not
8634 interleaved with disassembly. */
8636 for (i = 0; nregs < (op & 0xf); i++)
8642 regpos[nregs].offset = i * 2;
8643 regpos[nregs].reg = reg;
8650 regpos[nregs].offset = i * 2 + 1;
8651 regpos[nregs].reg = reg;
8656 printf (_("pop frame {"));
8658 for (i = i * 2; i > 0; i--)
8660 if (regpos[reg].offset == i - 1)
8662 name = tic6x_unwind_regnames[regpos[reg].reg];
8669 fputs (name, stdout);
8676 else if (op == 0xd0)
8677 printf (" MOV FP, SP");
8678 else if (op == 0xd1)
8679 printf (" __c6xabi_pop_rts");
8680 else if (op == 0xd2)
8682 unsigned char buf[9];
8683 unsigned int i, len;
8684 unsigned long offset;
8686 for (i = 0; i < sizeof (buf); i++)
8689 if ((buf[i] & 0x80) == 0)
8692 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8693 if (i == sizeof (buf))
8695 warn (_("Corrupt stack pointer adjustment detected\n"));
8699 offset = read_uleb128 (buf, &len, buf + i + 1);
8700 assert (len == i + 1);
8701 offset = offset * 8 + 0x408;
8702 printf (_("sp = sp + %ld"), offset);
8704 else if ((op & 0xf0) == 0xe0)
8706 if ((op & 0x0f) == 7)
8709 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8713 printf (_(" [unsupported opcode]"));
8722 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8726 offset = word & 0x7fffffff;
8727 if (offset & 0x40000000)
8728 offset |= ~ (bfd_vma) 0x7fffffff;
8730 if (elf_header.e_machine == EM_TI_C6000)
8733 return offset + where;
8737 decode_arm_unwind (struct arm_unw_aux_info * aux,
8739 unsigned int remaining,
8740 bfd_vma data_offset,
8741 Elf_Internal_Shdr * data_sec,
8742 struct arm_section * data_arm_sec)
8745 unsigned int more_words = 0;
8746 struct absaddr addr;
8747 bfd_vma sym_name = (bfd_vma) -1;
8748 bfd_boolean res = TRUE;
8752 /* Fetch the first word.
8753 Note - when decoding an object file the address extracted
8754 here will always be 0. So we also pass in the sym_name
8755 parameter so that we can find the symbol associated with
8756 the personality routine. */
8757 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8758 & word, & addr, & sym_name))
8764 if ((word & 0x80000000) == 0)
8766 /* Expand prel31 for personality routine. */
8768 const char *procname;
8770 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8771 printf (_(" Personality routine: "));
8773 && addr.section == SHN_UNDEF && addr.offset == 0
8774 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8776 procname = aux->strtab + sym_name;
8777 print_vma (fn, PREFIX_HEX);
8780 fputs (" <", stdout);
8781 fputs (procname, stdout);
8782 fputc ('>', stdout);
8786 procname = arm_print_vma_and_name (aux, fn, addr);
8787 fputc ('\n', stdout);
8789 /* The GCC personality routines use the standard compact
8790 encoding, starting with one byte giving the number of
8792 if (procname != NULL
8793 && (const_strneq (procname, "__gcc_personality_v0")
8794 || const_strneq (procname, "__gxx_personality_v0")
8795 || const_strneq (procname, "__gcj_personality_v0")
8796 || const_strneq (procname, "__gnu_objc_personality_v0")))
8803 printf (_(" [Truncated data]\n"));
8806 more_words = word >> 24;
8816 /* ARM EHABI Section 6.3:
8818 An exception-handling table entry for the compact model looks like:
8822 1 0 index Data for personalityRoutine[index] */
8824 if (elf_header.e_machine == EM_ARM
8825 && (word & 0x70000000))
8827 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8831 per_index = (word >> 24) & 0x7f;
8832 printf (_(" Compact model index: %d\n"), per_index);
8839 else if (per_index < 3)
8841 more_words = (word >> 16) & 0xff;
8847 switch (elf_header.e_machine)
8852 if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8853 data_offset, data_sec, data_arm_sec))
8858 warn (_("Unknown ARM compact model index encountered\n"));
8859 printf (_(" [reserved]\n"));
8867 if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8868 data_offset, data_sec, data_arm_sec))
8871 else if (per_index < 5)
8873 if (((word >> 17) & 0x7f) == 0x7f)
8874 printf (_(" Restore stack from frame pointer\n"));
8876 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8877 printf (_(" Registers restored: "));
8879 printf (" (compact) ");
8880 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8882 printf (_(" Return register: %s\n"),
8883 tic6x_unwind_regnames[word & 0xf]);
8886 printf (_(" [reserved (%d)]\n"), per_index);
8890 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8891 elf_header.e_machine);
8895 /* Decode the descriptors. Not implemented. */
8901 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8903 struct arm_section exidx_arm_sec, extab_arm_sec;
8904 unsigned int i, exidx_len;
8905 unsigned long j, nfuns;
8906 bfd_boolean res = TRUE;
8908 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8909 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8910 exidx_len = exidx_sec->sh_size / 8;
8912 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8913 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8914 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8915 aux->funtab[nfuns++] = aux->symtab[j];
8917 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8919 for (i = 0; i < exidx_len; i++)
8921 unsigned int exidx_fn, exidx_entry;
8922 struct absaddr fn_addr, entry_addr;
8925 fputc ('\n', stdout);
8927 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8928 8 * i, & exidx_fn, & fn_addr, NULL)
8929 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8930 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8933 arm_free_section (& exidx_arm_sec);
8934 arm_free_section (& extab_arm_sec);
8938 /* ARM EHABI, Section 5:
8939 An index table entry consists of 2 words.
8940 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8941 if (exidx_fn & 0x80000000)
8943 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8947 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8949 arm_print_vma_and_name (aux, fn, fn_addr);
8950 fputs (": ", stdout);
8952 if (exidx_entry == 1)
8954 print_vma (exidx_entry, PREFIX_HEX);
8955 fputs (" [cantunwind]\n", stdout);
8957 else if (exidx_entry & 0x80000000)
8959 print_vma (exidx_entry, PREFIX_HEX);
8960 fputc ('\n', stdout);
8961 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8965 bfd_vma table, table_offset = 0;
8966 Elf_Internal_Shdr *table_sec;
8968 fputs ("@", stdout);
8969 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8970 print_vma (table, PREFIX_HEX);
8973 /* Locate the matching .ARM.extab. */
8974 if (entry_addr.section != SHN_UNDEF
8975 && entry_addr.section < elf_header.e_shnum)
8977 table_sec = section_headers + entry_addr.section;
8978 table_offset = entry_addr.offset;
8980 if (table_offset > table_sec->sh_size
8981 || ((bfd_signed_vma) table_offset) < 0)
8983 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8984 (unsigned long) table_offset,
8985 printable_section_name (table_sec));
8992 table_sec = find_section_by_address (table);
8993 if (table_sec != NULL)
8994 table_offset = table - table_sec->sh_addr;
8997 if (table_sec == NULL)
8999 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9000 (unsigned long) table);
9005 if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
9014 arm_free_section (&exidx_arm_sec);
9015 arm_free_section (&extab_arm_sec);
9020 /* Used for both ARM and C6X unwinding tables. */
9023 arm_process_unwind (FILE *file)
9025 struct arm_unw_aux_info aux;
9026 Elf_Internal_Shdr *unwsec = NULL;
9027 Elf_Internal_Shdr *strsec;
9028 Elf_Internal_Shdr *sec;
9030 unsigned int sec_type;
9031 bfd_boolean res = TRUE;
9033 switch (elf_header.e_machine)
9036 sec_type = SHT_ARM_EXIDX;
9040 sec_type = SHT_C6000_UNWIND;
9044 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9045 elf_header.e_machine);
9049 if (string_table == NULL)
9052 memset (& aux, 0, sizeof (aux));
9055 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9057 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
9059 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
9061 strsec = section_headers + sec->sh_link;
9063 /* PR binutils/17531 file: 011-12666-0.004. */
9064 if (aux.strtab != NULL)
9066 error (_("Multiple string tables found in file.\n"));
9070 aux.strtab = get_data (NULL, file, strsec->sh_offset,
9071 1, strsec->sh_size, _("string table"));
9072 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9074 else if (sec->sh_type == sec_type)
9079 printf (_("\nThere are no unwind sections in this file.\n"));
9081 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
9083 if (sec->sh_type == sec_type)
9085 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9086 printable_section_name (sec),
9087 (unsigned long) sec->sh_offset,
9088 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
9090 if (! dump_arm_unwind (&aux, sec))
9098 free ((char *) aux.strtab);
9104 process_unwind (FILE * file)
9106 struct unwind_handler
9108 unsigned int machtype;
9109 bfd_boolean (* handler)(FILE *);
9112 { EM_ARM, arm_process_unwind },
9113 { EM_IA_64, ia64_process_unwind },
9114 { EM_PARISC, hppa_process_unwind },
9115 { EM_TI_C6000, arm_process_unwind },
9123 for (i = 0; handlers[i].handler != NULL; i++)
9124 if (elf_header.e_machine == handlers[i].machtype)
9125 return handlers[i].handler (file);
9127 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9128 get_machine_name (elf_header.e_machine));
9133 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9135 switch (entry->d_tag)
9138 if (entry->d_un.d_val == 0)
9142 static const char * opts[] =
9144 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9145 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9146 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9147 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9151 bfd_boolean first = TRUE;
9153 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9154 if (entry->d_un.d_val & (1 << cnt))
9156 printf ("%s%s", first ? "" : " ", opts[cnt]);
9162 case DT_MIPS_IVERSION:
9163 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9164 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9168 sprintf_vma (buf, entry->d_un.d_ptr);
9169 /* Note: coded this way so that there is a single string for translation. */
9170 printf (_("<corrupt: %s>"), buf);
9174 case DT_MIPS_TIME_STAMP:
9178 time_t atime = entry->d_un.d_val;
9180 tmp = gmtime (&atime);
9181 /* PR 17531: file: 6accc532. */
9183 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9185 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9186 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9187 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9188 printf (_("Time Stamp: %s"), timebuf);
9192 case DT_MIPS_RLD_VERSION:
9193 case DT_MIPS_LOCAL_GOTNO:
9194 case DT_MIPS_CONFLICTNO:
9195 case DT_MIPS_LIBLISTNO:
9196 case DT_MIPS_SYMTABNO:
9197 case DT_MIPS_UNREFEXTNO:
9198 case DT_MIPS_HIPAGENO:
9199 case DT_MIPS_DELTA_CLASS_NO:
9200 case DT_MIPS_DELTA_INSTANCE_NO:
9201 case DT_MIPS_DELTA_RELOC_NO:
9202 case DT_MIPS_DELTA_SYM_NO:
9203 case DT_MIPS_DELTA_CLASSSYM_NO:
9204 case DT_MIPS_COMPACT_SIZE:
9205 print_vma (entry->d_un.d_val, DEC);
9209 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9215 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9217 switch (entry->d_tag)
9219 case DT_HP_DLD_FLAGS:
9228 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9229 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9230 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9231 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9232 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9233 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9234 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9235 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9236 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9237 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9238 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9239 { DT_HP_GST, "HP_GST" },
9240 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9241 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9242 { DT_HP_NODELETE, "HP_NODELETE" },
9243 { DT_HP_GROUP, "HP_GROUP" },
9244 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9246 bfd_boolean first = TRUE;
9248 bfd_vma val = entry->d_un.d_val;
9250 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9251 if (val & flags[cnt].bit)
9255 fputs (flags[cnt].str, stdout);
9257 val ^= flags[cnt].bit;
9260 if (val != 0 || first)
9264 print_vma (val, HEX);
9270 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9278 /* VMS vs Unix time offset and factor. */
9280 #define VMS_EPOCH_OFFSET 35067168000000000LL
9281 #define VMS_GRANULARITY_FACTOR 10000000
9283 /* Display a VMS time in a human readable format. */
9286 print_vms_time (bfd_int64_t vmstime)
9291 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9292 tm = gmtime (&unxtime);
9293 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9294 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9295 tm->tm_hour, tm->tm_min, tm->tm_sec);
9300 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9302 switch (entry->d_tag)
9304 case DT_IA_64_PLT_RESERVE:
9305 /* First 3 slots reserved. */
9306 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9308 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9311 case DT_IA_64_VMS_LINKTIME:
9313 print_vms_time (entry->d_un.d_val);
9317 case DT_IA_64_VMS_LNKFLAGS:
9318 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9319 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9320 printf (" CALL_DEBUG");
9321 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9322 printf (" NOP0BUFS");
9323 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9324 printf (" P0IMAGE");
9325 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9326 printf (" MKTHREADS");
9327 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9328 printf (" UPCALLS");
9329 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9331 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9332 printf (" INITIALIZE");
9333 if (entry->d_un.d_val & VMS_LF_MAIN)
9335 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9336 printf (" EXE_INIT");
9337 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9338 printf (" TBK_IN_IMG");
9339 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9340 printf (" DBG_IN_IMG");
9341 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9342 printf (" TBK_IN_DSF");
9343 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9344 printf (" DBG_IN_DSF");
9345 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9346 printf (" SIGNATURES");
9347 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9348 printf (" REL_SEG_OFF");
9352 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9359 get_32bit_dynamic_section (FILE * file)
9361 Elf32_External_Dyn * edyn;
9362 Elf32_External_Dyn * ext;
9363 Elf_Internal_Dyn * entry;
9365 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9366 dynamic_size, _("dynamic section"));
9370 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9371 might not have the luxury of section headers. Look for the DT_NULL
9372 terminator to determine the number of entries. */
9373 for (ext = edyn, dynamic_nent = 0;
9374 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9378 if (BYTE_GET (ext->d_tag) == DT_NULL)
9382 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9384 if (dynamic_section == NULL)
9386 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387 (unsigned long) dynamic_nent);
9392 for (ext = edyn, entry = dynamic_section;
9393 entry < dynamic_section + dynamic_nent;
9396 entry->d_tag = BYTE_GET (ext->d_tag);
9397 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9406 get_64bit_dynamic_section (FILE * file)
9408 Elf64_External_Dyn * edyn;
9409 Elf64_External_Dyn * ext;
9410 Elf_Internal_Dyn * entry;
9412 /* Read in the data. */
9413 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9414 dynamic_size, _("dynamic section"));
9418 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9419 might not have the luxury of section headers. Look for the DT_NULL
9420 terminator to determine the number of entries. */
9421 for (ext = edyn, dynamic_nent = 0;
9422 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9423 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9427 if (BYTE_GET (ext->d_tag) == DT_NULL)
9431 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9433 if (dynamic_section == NULL)
9435 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9436 (unsigned long) dynamic_nent);
9441 /* Convert from external to internal formats. */
9442 for (ext = edyn, entry = dynamic_section;
9443 entry < dynamic_section + dynamic_nent;
9446 entry->d_tag = BYTE_GET (ext->d_tag);
9447 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9456 print_dynamic_flags (bfd_vma flags)
9458 bfd_boolean first = TRUE;
9464 flag = flags & - flags;
9474 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9475 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9476 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9477 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9478 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9479 default: fputs (_("unknown"), stdout); break;
9485 /* Parse and display the contents of the dynamic section. */
9488 process_dynamic_section (FILE * file)
9490 Elf_Internal_Dyn * entry;
9492 if (dynamic_size == 0)
9495 printf (_("\nThere is no dynamic section in this file.\n"));
9502 if (! get_32bit_dynamic_section (file))
9507 if (! get_64bit_dynamic_section (file))
9511 /* Find the appropriate symbol table. */
9512 if (dynamic_symbols == NULL)
9514 for (entry = dynamic_section;
9515 entry < dynamic_section + dynamic_nent;
9518 Elf_Internal_Shdr section;
9520 if (entry->d_tag != DT_SYMTAB)
9523 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9525 /* Since we do not know how big the symbol table is,
9526 we default to reading in the entire file (!) and
9527 processing that. This is overkill, I know, but it
9529 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9530 if ((bfd_size_type) section.sh_offset > current_file_size)
9532 /* See PR 21379 for a reproducer. */
9533 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9537 if (archive_file_offset != 0)
9538 section.sh_size = archive_file_size - section.sh_offset;
9541 if (fseek (file, 0, SEEK_END))
9542 error (_("Unable to seek to end of file!\n"));
9544 section.sh_size = ftell (file) - section.sh_offset;
9548 section.sh_entsize = sizeof (Elf32_External_Sym);
9550 section.sh_entsize = sizeof (Elf64_External_Sym);
9551 section.sh_name = string_table_length;
9553 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
9554 if (num_dynamic_syms < 1)
9556 error (_("Unable to determine the number of symbols to load\n"));
9562 /* Similarly find a string table. */
9563 if (dynamic_strings == NULL)
9565 for (entry = dynamic_section;
9566 entry < dynamic_section + dynamic_nent;
9569 unsigned long offset;
9572 if (entry->d_tag != DT_STRTAB)
9575 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9577 /* Since we do not know how big the string table is,
9578 we default to reading in the entire file (!) and
9579 processing that. This is overkill, I know, but it
9582 offset = offset_from_vma (file, entry->d_un.d_val, 0);
9584 if (archive_file_offset != 0)
9585 str_tab_len = archive_file_size - offset;
9588 if (fseek (file, 0, SEEK_END))
9589 error (_("Unable to seek to end of file\n"));
9590 str_tab_len = ftell (file) - offset;
9593 if (str_tab_len < 1)
9596 (_("Unable to determine the length of the dynamic string table\n"));
9600 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9602 _("dynamic string table"));
9603 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9608 /* And find the syminfo section if available. */
9609 if (dynamic_syminfo == NULL)
9611 unsigned long syminsz = 0;
9613 for (entry = dynamic_section;
9614 entry < dynamic_section + dynamic_nent;
9617 if (entry->d_tag == DT_SYMINENT)
9619 /* Note: these braces are necessary to avoid a syntax
9620 error from the SunOS4 C compiler. */
9621 /* PR binutils/17531: A corrupt file can trigger this test.
9622 So do not use an assert, instead generate an error message. */
9623 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9624 error (_("Bad value (%d) for SYMINENT entry\n"),
9625 (int) entry->d_un.d_val);
9627 else if (entry->d_tag == DT_SYMINSZ)
9628 syminsz = entry->d_un.d_val;
9629 else if (entry->d_tag == DT_SYMINFO)
9630 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9634 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9636 Elf_External_Syminfo * extsyminfo;
9637 Elf_External_Syminfo * extsym;
9638 Elf_Internal_Syminfo * syminfo;
9640 /* There is a syminfo section. Read the data. */
9641 extsyminfo = (Elf_External_Syminfo *)
9642 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9643 _("symbol information"));
9647 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9648 if (dynamic_syminfo == NULL)
9650 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9651 (unsigned long) syminsz);
9655 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9656 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9657 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9658 ++syminfo, ++extsym)
9660 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9661 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9668 if (do_dynamic && dynamic_addr)
9669 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9670 dynamic_addr, (unsigned long) dynamic_nent);
9672 printf (_(" Tag Type Name/Value\n"));
9674 for (entry = dynamic_section;
9675 entry < dynamic_section + dynamic_nent;
9683 print_vma (entry->d_tag, FULL_HEX);
9684 dtype = get_dynamic_type (entry->d_tag);
9685 printf (" (%s)%*s", dtype,
9686 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9689 switch (entry->d_tag)
9693 print_dynamic_flags (entry->d_un.d_val);
9703 switch (entry->d_tag)
9706 printf (_("Auxiliary library"));
9710 printf (_("Filter library"));
9714 printf (_("Configuration file"));
9718 printf (_("Dependency audit library"));
9722 printf (_("Audit library"));
9726 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9727 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9731 print_vma (entry->d_un.d_val, PREFIX_HEX);
9740 printf (_("Flags:"));
9742 if (entry->d_un.d_val == 0)
9743 printf (_(" None\n"));
9746 unsigned long int val = entry->d_un.d_val;
9748 if (val & DTF_1_PARINIT)
9750 printf (" PARINIT");
9751 val ^= DTF_1_PARINIT;
9753 if (val & DTF_1_CONFEXP)
9755 printf (" CONFEXP");
9756 val ^= DTF_1_CONFEXP;
9759 printf (" %lx", val);
9768 printf (_("Flags:"));
9770 if (entry->d_un.d_val == 0)
9771 printf (_(" None\n"));
9774 unsigned long int val = entry->d_un.d_val;
9776 if (val & DF_P1_LAZYLOAD)
9778 printf (" LAZYLOAD");
9779 val ^= DF_P1_LAZYLOAD;
9781 if (val & DF_P1_GROUPPERM)
9783 printf (" GROUPPERM");
9784 val ^= DF_P1_GROUPPERM;
9787 printf (" %lx", val);
9796 printf (_("Flags:"));
9797 if (entry->d_un.d_val == 0)
9798 printf (_(" None\n"));
9801 unsigned long int val = entry->d_un.d_val;
9808 if (val & DF_1_GLOBAL)
9813 if (val & DF_1_GROUP)
9818 if (val & DF_1_NODELETE)
9820 printf (" NODELETE");
9821 val ^= DF_1_NODELETE;
9823 if (val & DF_1_LOADFLTR)
9825 printf (" LOADFLTR");
9826 val ^= DF_1_LOADFLTR;
9828 if (val & DF_1_INITFIRST)
9830 printf (" INITFIRST");
9831 val ^= DF_1_INITFIRST;
9833 if (val & DF_1_NOOPEN)
9838 if (val & DF_1_ORIGIN)
9843 if (val & DF_1_DIRECT)
9848 if (val & DF_1_TRANS)
9853 if (val & DF_1_INTERPOSE)
9855 printf (" INTERPOSE");
9856 val ^= DF_1_INTERPOSE;
9858 if (val & DF_1_NODEFLIB)
9860 printf (" NODEFLIB");
9861 val ^= DF_1_NODEFLIB;
9863 if (val & DF_1_NODUMP)
9868 if (val & DF_1_CONFALT)
9870 printf (" CONFALT");
9871 val ^= DF_1_CONFALT;
9873 if (val & DF_1_ENDFILTEE)
9875 printf (" ENDFILTEE");
9876 val ^= DF_1_ENDFILTEE;
9878 if (val & DF_1_DISPRELDNE)
9880 printf (" DISPRELDNE");
9881 val ^= DF_1_DISPRELDNE;
9883 if (val & DF_1_DISPRELPND)
9885 printf (" DISPRELPND");
9886 val ^= DF_1_DISPRELPND;
9888 if (val & DF_1_NODIRECT)
9890 printf (" NODIRECT");
9891 val ^= DF_1_NODIRECT;
9893 if (val & DF_1_IGNMULDEF)
9895 printf (" IGNMULDEF");
9896 val ^= DF_1_IGNMULDEF;
9898 if (val & DF_1_NOKSYMS)
9900 printf (" NOKSYMS");
9901 val ^= DF_1_NOKSYMS;
9903 if (val & DF_1_NOHDR)
9908 if (val & DF_1_EDITED)
9913 if (val & DF_1_NORELOC)
9915 printf (" NORELOC");
9916 val ^= DF_1_NORELOC;
9918 if (val & DF_1_SYMINTPOSE)
9920 printf (" SYMINTPOSE");
9921 val ^= DF_1_SYMINTPOSE;
9923 if (val & DF_1_GLOBAUDIT)
9925 printf (" GLOBAUDIT");
9926 val ^= DF_1_GLOBAUDIT;
9928 if (val & DF_1_SINGLETON)
9930 printf (" SINGLETON");
9931 val ^= DF_1_SINGLETON;
9933 if (val & DF_1_STUB)
9944 printf (" %lx", val);
9951 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9953 puts (get_dynamic_type (entry->d_un.d_val));
9973 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9979 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9980 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9986 switch (entry->d_tag)
9989 printf (_("Shared library: [%s]"), name);
9991 if (streq (name, program_interpreter))
9992 printf (_(" program interpreter"));
9996 printf (_("Library soname: [%s]"), name);
10000 printf (_("Library rpath: [%s]"), name);
10004 printf (_("Library runpath: [%s]"), name);
10008 print_vma (entry->d_un.d_val, PREFIX_HEX);
10013 print_vma (entry->d_un.d_val, PREFIX_HEX);
10026 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10027 /* Fall through. */
10031 case DT_INIT_ARRAYSZ:
10032 case DT_FINI_ARRAYSZ:
10033 case DT_GNU_CONFLICTSZ:
10034 case DT_GNU_LIBLISTSZ:
10037 print_vma (entry->d_un.d_val, UNSIGNED);
10038 printf (_(" (bytes)\n"));
10043 case DT_VERNEEDNUM:
10048 print_vma (entry->d_un.d_val, UNSIGNED);
10057 case DT_INIT_ARRAY:
10058 case DT_FINI_ARRAY:
10061 if (entry->d_tag == DT_USED
10062 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10064 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10068 printf (_("Not needed object: [%s]\n"), name);
10073 print_vma (entry->d_un.d_val, PREFIX_HEX);
10079 /* The value of this entry is ignored. */
10084 case DT_GNU_PRELINKED:
10088 time_t atime = entry->d_un.d_val;
10090 tmp = gmtime (&atime);
10091 /* PR 17533 file: 041-1244816-0.004. */
10093 printf (_("<corrupt time val: %lx"),
10094 (unsigned long) atime);
10096 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10097 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10098 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10104 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10107 print_vma (entry->d_un.d_val, PREFIX_HEX);
10113 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10114 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10119 switch (elf_header.e_machine)
10122 case EM_MIPS_RS3_LE:
10123 dynamic_section_mips_val (entry);
10126 dynamic_section_parisc_val (entry);
10129 dynamic_section_ia64_val (entry);
10132 print_vma (entry->d_un.d_val, PREFIX_HEX);
10144 get_ver_flags (unsigned int flags)
10146 static char buff[32];
10153 if (flags & VER_FLG_BASE)
10154 strcat (buff, "BASE");
10156 if (flags & VER_FLG_WEAK)
10158 if (flags & VER_FLG_BASE)
10159 strcat (buff, " | ");
10161 strcat (buff, "WEAK");
10164 if (flags & VER_FLG_INFO)
10166 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10167 strcat (buff, " | ");
10169 strcat (buff, "INFO");
10172 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10174 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10175 strcat (buff, " | ");
10177 strcat (buff, _("<unknown>"));
10183 /* Display the contents of the version sections. */
10186 process_version_sections (FILE * file)
10188 Elf_Internal_Shdr * section;
10190 bfd_boolean found = FALSE;
10195 for (i = 0, section = section_headers;
10196 i < elf_header.e_shnum;
10199 switch (section->sh_type)
10201 case SHT_GNU_verdef:
10203 Elf_External_Verdef * edefs;
10210 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10211 printable_section_name (section),
10214 printf (_(" Addr: 0x"));
10215 printf_vma (section->sh_addr);
10216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10217 (unsigned long) section->sh_offset, section->sh_link,
10218 printable_section_name_from_index (section->sh_link));
10220 edefs = (Elf_External_Verdef *)
10221 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10222 _("version definition section"));
10225 endbuf = (char *) edefs + section->sh_size;
10227 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10230 Elf_External_Verdef * edef;
10231 Elf_Internal_Verdef ent;
10232 Elf_External_Verdaux * eaux;
10233 Elf_Internal_Verdaux aux;
10234 unsigned long isum;
10237 vstart = ((char *) edefs) + idx;
10238 if (vstart + sizeof (*edef) > endbuf)
10241 edef = (Elf_External_Verdef *) vstart;
10243 ent.vd_version = BYTE_GET (edef->vd_version);
10244 ent.vd_flags = BYTE_GET (edef->vd_flags);
10245 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10246 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10247 ent.vd_hash = BYTE_GET (edef->vd_hash);
10248 ent.vd_aux = BYTE_GET (edef->vd_aux);
10249 ent.vd_next = BYTE_GET (edef->vd_next);
10251 printf (_(" %#06lx: Rev: %d Flags: %s"),
10252 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10254 printf (_(" Index: %d Cnt: %d "),
10255 ent.vd_ndx, ent.vd_cnt);
10257 /* Check for overflow. */
10258 if (ent.vd_aux > (size_t) (endbuf - vstart))
10261 vstart += ent.vd_aux;
10263 if (vstart + sizeof (*eaux) > endbuf)
10265 eaux = (Elf_External_Verdaux *) vstart;
10267 aux.vda_name = BYTE_GET (eaux->vda_name);
10268 aux.vda_next = BYTE_GET (eaux->vda_next);
10270 if (VALID_DYNAMIC_NAME (aux.vda_name))
10271 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10273 printf (_("Name index: %ld\n"), aux.vda_name);
10275 isum = idx + ent.vd_aux;
10277 for (j = 1; j < ent.vd_cnt; j++)
10279 if (aux.vda_next < sizeof (*eaux)
10280 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10282 warn (_("Invalid vda_next field of %lx\n"),
10287 /* Check for overflow. */
10288 if (aux.vda_next > (size_t) (endbuf - vstart))
10291 isum += aux.vda_next;
10292 vstart += aux.vda_next;
10294 if (vstart + sizeof (*eaux) > endbuf)
10296 eaux = (Elf_External_Verdaux *) vstart;
10298 aux.vda_name = BYTE_GET (eaux->vda_name);
10299 aux.vda_next = BYTE_GET (eaux->vda_next);
10301 if (VALID_DYNAMIC_NAME (aux.vda_name))
10302 printf (_(" %#06lx: Parent %d: %s\n"),
10303 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10305 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10306 isum, j, aux.vda_name);
10309 if (j < ent.vd_cnt)
10310 printf (_(" Version def aux past end of section\n"));
10313 file: id:000001,src:000172+005151,op:splice,rep:2. */
10314 if (ent.vd_next < sizeof (*edef)
10315 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10317 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10318 cnt = section->sh_info;
10321 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10324 idx += ent.vd_next;
10327 if (cnt < section->sh_info)
10328 printf (_(" Version definition past end of section\n"));
10334 case SHT_GNU_verneed:
10336 Elf_External_Verneed * eneed;
10343 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10344 printable_section_name (section), section->sh_info);
10346 printf (_(" Addr: 0x"));
10347 printf_vma (section->sh_addr);
10348 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10349 (unsigned long) section->sh_offset, section->sh_link,
10350 printable_section_name_from_index (section->sh_link));
10352 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10353 section->sh_offset, 1,
10355 _("Version Needs section"));
10358 endbuf = (char *) eneed + section->sh_size;
10360 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10362 Elf_External_Verneed * entry;
10363 Elf_Internal_Verneed ent;
10364 unsigned long isum;
10368 vstart = ((char *) eneed) + idx;
10369 if (vstart + sizeof (*entry) > endbuf)
10372 entry = (Elf_External_Verneed *) vstart;
10374 ent.vn_version = BYTE_GET (entry->vn_version);
10375 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10376 ent.vn_file = BYTE_GET (entry->vn_file);
10377 ent.vn_aux = BYTE_GET (entry->vn_aux);
10378 ent.vn_next = BYTE_GET (entry->vn_next);
10380 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10382 if (VALID_DYNAMIC_NAME (ent.vn_file))
10383 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10385 printf (_(" File: %lx"), ent.vn_file);
10387 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10389 /* Check for overflow. */
10390 if (ent.vn_aux > (size_t) (endbuf - vstart))
10392 vstart += ent.vn_aux;
10394 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10396 Elf_External_Vernaux * eaux;
10397 Elf_Internal_Vernaux aux;
10399 if (vstart + sizeof (*eaux) > endbuf)
10401 eaux = (Elf_External_Vernaux *) vstart;
10403 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10404 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10405 aux.vna_other = BYTE_GET (eaux->vna_other);
10406 aux.vna_name = BYTE_GET (eaux->vna_name);
10407 aux.vna_next = BYTE_GET (eaux->vna_next);
10409 if (VALID_DYNAMIC_NAME (aux.vna_name))
10410 printf (_(" %#06lx: Name: %s"),
10411 isum, GET_DYNAMIC_NAME (aux.vna_name));
10413 printf (_(" %#06lx: Name index: %lx"),
10414 isum, aux.vna_name);
10416 printf (_(" Flags: %s Version: %d\n"),
10417 get_ver_flags (aux.vna_flags), aux.vna_other);
10419 if (aux.vna_next < sizeof (*eaux)
10420 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10422 warn (_("Invalid vna_next field of %lx\n"),
10427 /* Check for overflow. */
10428 if (aux.vna_next > (size_t) (endbuf - vstart))
10430 isum += aux.vna_next;
10431 vstart += aux.vna_next;
10434 if (j < ent.vn_cnt)
10435 warn (_("Missing Version Needs auxillary information\n"));
10437 if (ent.vn_next < sizeof (*entry)
10438 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10440 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10441 cnt = section->sh_info;
10444 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10446 idx += ent.vn_next;
10449 if (cnt < section->sh_info)
10450 warn (_("Missing Version Needs information\n"));
10456 case SHT_GNU_versym:
10458 Elf_Internal_Shdr * link_section;
10461 unsigned char * edata;
10462 unsigned short * data;
10464 Elf_Internal_Sym * symbols;
10465 Elf_Internal_Shdr * string_sec;
10466 unsigned long num_syms;
10469 if (section->sh_link >= elf_header.e_shnum)
10472 link_section = section_headers + section->sh_link;
10473 total = section->sh_size / sizeof (Elf_External_Versym);
10475 if (link_section->sh_link >= elf_header.e_shnum)
10480 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10481 if (symbols == NULL)
10484 string_sec = section_headers + link_section->sh_link;
10486 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10487 string_sec->sh_size,
10488 _("version string table"));
10495 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10496 printable_section_name (section), (unsigned long) total);
10498 printf (_(" Addr: "));
10499 printf_vma (section->sh_addr);
10500 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10501 (unsigned long) section->sh_offset, section->sh_link,
10502 printable_section_name (link_section));
10504 off = offset_from_vma (file,
10505 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10506 total * sizeof (short));
10507 edata = (unsigned char *) get_data (NULL, file, off, total,
10509 _("version symbol data"));
10517 data = (short unsigned int *) cmalloc (total, sizeof (short));
10519 for (cnt = total; cnt --;)
10520 data[cnt] = byte_get (edata + cnt * sizeof (short),
10525 for (cnt = 0; cnt < total; cnt += 4)
10529 char *invalid = _("*invalid*");
10531 printf (" %03x:", cnt);
10533 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10534 switch (data[cnt + j])
10537 fputs (_(" 0 (*local*) "), stdout);
10541 fputs (_(" 1 (*global*) "), stdout);
10545 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10546 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10548 /* If this index value is greater than the size of the symbols
10549 array, break to avoid an out-of-bounds read. */
10550 if ((unsigned long)(cnt + j) >= num_syms)
10552 warn (_("invalid index into symbol array\n"));
10557 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10559 Elf_Internal_Verneed ivn;
10560 unsigned long offset;
10562 offset = offset_from_vma
10563 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10564 sizeof (Elf_External_Verneed));
10568 Elf_Internal_Vernaux ivna;
10569 Elf_External_Verneed evn;
10570 Elf_External_Vernaux evna;
10571 unsigned long a_off;
10573 if (get_data (&evn, file, offset, sizeof (evn), 1,
10574 _("version need")) == NULL)
10577 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10578 ivn.vn_next = BYTE_GET (evn.vn_next);
10580 a_off = offset + ivn.vn_aux;
10584 if (get_data (&evna, file, a_off, sizeof (evna),
10585 1, _("version need aux (2)")) == NULL)
10588 ivna.vna_other = 0;
10592 ivna.vna_next = BYTE_GET (evna.vna_next);
10593 ivna.vna_other = BYTE_GET (evna.vna_other);
10596 a_off += ivna.vna_next;
10598 while (ivna.vna_other != data[cnt + j]
10599 && ivna.vna_next != 0);
10601 if (ivna.vna_other == data[cnt + j])
10603 ivna.vna_name = BYTE_GET (evna.vna_name);
10605 if (ivna.vna_name >= string_sec->sh_size)
10608 name = strtab + ivna.vna_name;
10612 offset += ivn.vn_next;
10614 while (ivn.vn_next);
10617 if (data[cnt + j] != 0x8001
10618 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10620 Elf_Internal_Verdef ivd;
10621 Elf_External_Verdef evd;
10622 unsigned long offset;
10624 offset = offset_from_vma
10625 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10630 if (get_data (&evd, file, offset, sizeof (evd), 1,
10631 _("version def")) == NULL)
10634 /* PR 17531: file: 046-1082287-0.004. */
10635 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10640 ivd.vd_next = BYTE_GET (evd.vd_next);
10641 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10644 offset += ivd.vd_next;
10646 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10647 && ivd.vd_next != 0);
10649 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10651 Elf_External_Verdaux evda;
10652 Elf_Internal_Verdaux ivda;
10654 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10656 if (get_data (&evda, file,
10657 offset - ivd.vd_next + ivd.vd_aux,
10659 _("version def aux")) == NULL)
10662 ivda.vda_name = BYTE_GET (evda.vda_name);
10664 if (ivda.vda_name >= string_sec->sh_size)
10666 else if (name != NULL && name != invalid)
10667 name = _("*both*");
10669 name = strtab + ivda.vda_name;
10673 nn += printf ("(%s%-*s",
10675 12 - (int) strlen (name),
10679 printf ("%*c", 18 - nn, ' ');
10697 printf (_("\nNo version information found in this file.\n"));
10702 static const char *
10703 get_symbol_binding (unsigned int binding)
10705 static char buff[32];
10709 case STB_LOCAL: return "LOCAL";
10710 case STB_GLOBAL: return "GLOBAL";
10711 case STB_WEAK: return "WEAK";
10713 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10714 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10716 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10718 if (binding == STB_GNU_UNIQUE
10719 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10720 /* GNU is still using the default value 0. */
10721 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10723 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10726 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10731 static const char *
10732 get_symbol_type (unsigned int type)
10734 static char buff[32];
10738 case STT_NOTYPE: return "NOTYPE";
10739 case STT_OBJECT: return "OBJECT";
10740 case STT_FUNC: return "FUNC";
10741 case STT_SECTION: return "SECTION";
10742 case STT_FILE: return "FILE";
10743 case STT_COMMON: return "COMMON";
10744 case STT_TLS: return "TLS";
10745 case STT_RELC: return "RELC";
10746 case STT_SRELC: return "SRELC";
10748 if (type >= STT_LOPROC && type <= STT_HIPROC)
10750 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10751 return "THUMB_FUNC";
10753 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10756 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10757 return "PARISC_MILLI";
10759 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10761 else if (type >= STT_LOOS && type <= STT_HIOS)
10763 if (elf_header.e_machine == EM_PARISC)
10765 if (type == STT_HP_OPAQUE)
10766 return "HP_OPAQUE";
10767 if (type == STT_HP_STUB)
10771 if (type == STT_GNU_IFUNC
10772 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10773 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10774 /* GNU is still using the default value 0. */
10775 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10778 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10781 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10786 static const char *
10787 get_symbol_visibility (unsigned int visibility)
10789 switch (visibility)
10791 case STV_DEFAULT: return "DEFAULT";
10792 case STV_INTERNAL: return "INTERNAL";
10793 case STV_HIDDEN: return "HIDDEN";
10794 case STV_PROTECTED: return "PROTECTED";
10796 error (_("Unrecognized visibility value: %u"), visibility);
10797 return _("<unknown>");
10801 static const char *
10802 get_solaris_symbol_visibility (unsigned int visibility)
10804 switch (visibility)
10806 case 4: return "EXPORTED";
10807 case 5: return "SINGLETON";
10808 case 6: return "ELIMINATE";
10809 default: return get_symbol_visibility (visibility);
10813 static const char *
10814 get_mips_symbol_other (unsigned int other)
10818 case STO_OPTIONAL: return "OPTIONAL";
10819 case STO_MIPS_PLT: return "MIPS PLT";
10820 case STO_MIPS_PIC: return "MIPS PIC";
10821 case STO_MICROMIPS: return "MICROMIPS";
10822 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10823 case STO_MIPS16: return "MIPS16";
10824 default: return NULL;
10828 static const char *
10829 get_ia64_symbol_other (unsigned int other)
10831 if (is_ia64_vms ())
10833 static char res[32];
10837 /* Function types is for images and .STB files only. */
10838 switch (elf_header.e_type)
10842 switch (VMS_ST_FUNC_TYPE (other))
10844 case VMS_SFT_CODE_ADDR:
10845 strcat (res, " CA");
10847 case VMS_SFT_SYMV_IDX:
10848 strcat (res, " VEC");
10851 strcat (res, " FD");
10853 case VMS_SFT_RESERVE:
10854 strcat (res, " RSV");
10857 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10858 VMS_ST_FUNC_TYPE (other));
10859 strcat (res, " <unknown>");
10866 switch (VMS_ST_LINKAGE (other))
10868 case VMS_STL_IGNORE:
10869 strcat (res, " IGN");
10871 case VMS_STL_RESERVE:
10872 strcat (res, " RSV");
10875 strcat (res, " STD");
10878 strcat (res, " LNK");
10881 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10882 VMS_ST_LINKAGE (other));
10883 strcat (res, " <unknown>");
10895 static const char *
10896 get_ppc64_symbol_other (unsigned int other)
10898 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10900 static char buf[32];
10901 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10902 PPC64_LOCAL_ENTRY_OFFSET (other));
10908 static const char *
10909 get_symbol_other (unsigned int other)
10911 const char * result = NULL;
10912 static char buff [32];
10917 switch (elf_header.e_machine)
10920 result = get_mips_symbol_other (other);
10923 result = get_ia64_symbol_other (other);
10926 result = get_ppc64_symbol_other (other);
10936 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10940 static const char *
10941 get_symbol_index_type (unsigned int type)
10943 static char buff[32];
10947 case SHN_UNDEF: return "UND";
10948 case SHN_ABS: return "ABS";
10949 case SHN_COMMON: return "COM";
10951 if (type == SHN_IA_64_ANSI_COMMON
10952 && elf_header.e_machine == EM_IA_64
10953 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10955 else if ((elf_header.e_machine == EM_X86_64
10956 || elf_header.e_machine == EM_L1OM
10957 || elf_header.e_machine == EM_K1OM)
10958 && type == SHN_X86_64_LCOMMON)
10959 return "LARGE_COM";
10960 else if ((type == SHN_MIPS_SCOMMON
10961 && elf_header.e_machine == EM_MIPS)
10962 || (type == SHN_TIC6X_SCOMMON
10963 && elf_header.e_machine == EM_TI_C6000))
10965 else if (type == SHN_MIPS_SUNDEFINED
10966 && elf_header.e_machine == EM_MIPS)
10968 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10969 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10970 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10971 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10972 else if (type >= SHN_LORESERVE)
10973 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10974 else if (type >= elf_header.e_shnum)
10975 sprintf (buff, _("bad section index[%3d]"), type);
10977 sprintf (buff, "%3d", type);
10985 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10987 unsigned char * e_data;
10990 /* If the size_t type is smaller than the bfd_size_type, eg because
10991 you are building a 32-bit tool on a 64-bit host, then make sure
10992 that when (number) is cast to (size_t) no information is lost. */
10993 if (sizeof (size_t) < sizeof (bfd_size_type)
10994 && (bfd_size_type) ((size_t) number) != number)
10996 error (_("Size truncation prevents reading %s elements of size %u\n"),
10997 bfd_vmatoa ("u", number), ent_size);
11001 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11002 attempting to allocate memory when the read is bound to fail. */
11003 if (ent_size * number > current_file_size)
11005 error (_("Invalid number of dynamic entries: %s\n"),
11006 bfd_vmatoa ("u", number));
11010 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11011 if (e_data == NULL)
11013 error (_("Out of memory reading %s dynamic entries\n"),
11014 bfd_vmatoa ("u", number));
11018 if (fread (e_data, ent_size, (size_t) number, file) != number)
11020 error (_("Unable to read in %s bytes of dynamic data\n"),
11021 bfd_vmatoa ("u", number * ent_size));
11026 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11027 if (i_data == NULL)
11029 error (_("Out of memory allocating space for %s dynamic entries\n"),
11030 bfd_vmatoa ("u", number));
11036 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11044 print_dynamic_symbol (bfd_vma si, unsigned long hn)
11046 Elf_Internal_Sym * psym;
11049 n = print_vma (si, DEC_5);
11051 fputs (&" "[n], stdout);
11052 printf (" %3lu: ", hn);
11054 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11056 printf (_("<No info available for dynamic symbol number %lu>\n"),
11057 (unsigned long) si);
11061 psym = dynamic_symbols + si;
11062 print_vma (psym->st_value, LONG_HEX);
11064 print_vma (psym->st_size, DEC_5);
11066 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11067 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11069 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11070 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11073 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11075 printf (" %-7s", get_symbol_visibility (vis));
11076 /* Check to see if any other bits in the st_other field are set.
11077 Note - displaying this information disrupts the layout of the
11078 table being generated, but for the moment this case is very
11080 if (psym->st_other ^ vis)
11081 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11084 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
11085 if (VALID_DYNAMIC_NAME (psym->st_name))
11086 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11088 printf (_(" <corrupt: %14ld>"), psym->st_name);
11092 static const char *
11093 get_symbol_version_string (FILE * file,
11094 bfd_boolean is_dynsym,
11095 const char * strtab,
11096 unsigned long int strtab_size,
11098 Elf_Internal_Sym * psym,
11099 enum versioned_symbol_info * sym_info,
11100 unsigned short * vna_other)
11102 unsigned char data[2];
11103 unsigned short vers_data;
11104 unsigned long offset;
11107 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11110 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11111 sizeof data + si * sizeof (vers_data));
11113 if (get_data (&data, file, offset + si * sizeof (vers_data),
11114 sizeof (data), 1, _("version data")) == NULL)
11117 vers_data = byte_get (data, 2);
11119 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11122 /* Usually we'd only see verdef for defined symbols, and verneed for
11123 undefined symbols. However, symbols defined by the linker in
11124 .dynbss for variables copied from a shared library in order to
11125 avoid text relocations are defined yet have verneed. We could
11126 use a heuristic to detect the special case, for example, check
11127 for verneed first on symbols defined in SHT_NOBITS sections, but
11128 it is simpler and more reliable to just look for both verdef and
11129 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11131 if (psym->st_shndx != SHN_UNDEF
11132 && vers_data != 0x8001
11133 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11135 Elf_Internal_Verdef ivd;
11136 Elf_Internal_Verdaux ivda;
11137 Elf_External_Verdaux evda;
11140 off = offset_from_vma (file,
11141 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11142 sizeof (Elf_External_Verdef));
11146 Elf_External_Verdef evd;
11148 if (get_data (&evd, file, off, sizeof (evd), 1,
11149 _("version def")) == NULL)
11157 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11158 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11159 ivd.vd_next = BYTE_GET (evd.vd_next);
11162 off += ivd.vd_next;
11164 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11166 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11168 off -= ivd.vd_next;
11171 if (get_data (&evda, file, off, sizeof (evda), 1,
11172 _("version def aux")) != NULL)
11174 ivda.vda_name = BYTE_GET (evda.vda_name);
11176 if (psym->st_name != ivda.vda_name)
11178 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11179 ? symbol_hidden : symbol_public);
11180 return (ivda.vda_name < strtab_size
11181 ? strtab + ivda.vda_name : _("<corrupt>"));
11187 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11189 Elf_External_Verneed evn;
11190 Elf_Internal_Verneed ivn;
11191 Elf_Internal_Vernaux ivna;
11193 offset = offset_from_vma (file,
11194 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11198 unsigned long vna_off;
11200 if (get_data (&evn, file, offset, sizeof (evn), 1,
11201 _("version need")) == NULL)
11204 ivna.vna_other = 0;
11209 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11210 ivn.vn_next = BYTE_GET (evn.vn_next);
11212 vna_off = offset + ivn.vn_aux;
11216 Elf_External_Vernaux evna;
11218 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11219 _("version need aux (3)")) == NULL)
11222 ivna.vna_other = 0;
11227 ivna.vna_other = BYTE_GET (evna.vna_other);
11228 ivna.vna_next = BYTE_GET (evna.vna_next);
11229 ivna.vna_name = BYTE_GET (evna.vna_name);
11232 vna_off += ivna.vna_next;
11234 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11236 if (ivna.vna_other == vers_data)
11239 offset += ivn.vn_next;
11241 while (ivn.vn_next != 0);
11243 if (ivna.vna_other == vers_data)
11245 *sym_info = symbol_undefined;
11246 *vna_other = ivna.vna_other;
11247 return (ivna.vna_name < strtab_size
11248 ? strtab + ivna.vna_name : _("<corrupt>"));
11254 /* Dump the symbol table. */
11256 process_symbol_table (FILE * file)
11258 Elf_Internal_Shdr * section;
11259 bfd_size_type nbuckets = 0;
11260 bfd_size_type nchains = 0;
11261 bfd_vma * buckets = NULL;
11262 bfd_vma * chains = NULL;
11263 bfd_vma ngnubuckets = 0;
11264 bfd_vma * gnubuckets = NULL;
11265 bfd_vma * gnuchains = NULL;
11266 bfd_vma gnusymidx = 0;
11267 bfd_size_type ngnuchains = 0;
11269 if (!do_syms && !do_dyn_syms && !do_histogram)
11272 if (dynamic_info[DT_HASH]
11274 || (do_using_dynamic
11276 && dynamic_strings != NULL)))
11278 unsigned char nb[8];
11279 unsigned char nc[8];
11280 unsigned int hash_ent_size = 4;
11282 if ((elf_header.e_machine == EM_ALPHA
11283 || elf_header.e_machine == EM_S390
11284 || elf_header.e_machine == EM_S390_OLD)
11285 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11289 (archive_file_offset
11290 + offset_from_vma (file, dynamic_info[DT_HASH],
11291 sizeof nb + sizeof nc)),
11294 error (_("Unable to seek to start of dynamic information\n"));
11298 if (fread (nb, hash_ent_size, 1, file) != 1)
11300 error (_("Failed to read in number of buckets\n"));
11304 if (fread (nc, hash_ent_size, 1, file) != 1)
11306 error (_("Failed to read in number of chains\n"));
11310 nbuckets = byte_get (nb, hash_ent_size);
11311 nchains = byte_get (nc, hash_ent_size);
11313 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11314 chains = get_dynamic_data (file, nchains, hash_ent_size);
11317 if (buckets == NULL || chains == NULL)
11319 if (do_using_dynamic)
11330 if (dynamic_info_DT_GNU_HASH
11332 || (do_using_dynamic
11334 && dynamic_strings != NULL)))
11336 unsigned char nb[16];
11337 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11338 bfd_vma buckets_vma;
11341 (archive_file_offset
11342 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11346 error (_("Unable to seek to start of dynamic information\n"));
11350 if (fread (nb, 16, 1, file) != 1)
11352 error (_("Failed to read in number of buckets\n"));
11356 ngnubuckets = byte_get (nb, 4);
11357 gnusymidx = byte_get (nb + 4, 4);
11358 bitmaskwords = byte_get (nb + 8, 4);
11359 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11361 buckets_vma += bitmaskwords * 4;
11363 buckets_vma += bitmaskwords * 8;
11366 (archive_file_offset
11367 + offset_from_vma (file, buckets_vma, 4)),
11370 error (_("Unable to seek to start of dynamic information\n"));
11374 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11376 if (gnubuckets == NULL)
11379 for (i = 0; i < ngnubuckets; i++)
11380 if (gnubuckets[i] != 0)
11382 if (gnubuckets[i] < gnusymidx)
11385 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11386 maxchain = gnubuckets[i];
11389 if (maxchain == 0xffffffff)
11392 maxchain -= gnusymidx;
11395 (archive_file_offset
11396 + offset_from_vma (file, buckets_vma
11397 + 4 * (ngnubuckets + maxchain), 4)),
11400 error (_("Unable to seek to start of dynamic information\n"));
11406 if (fread (nb, 4, 1, file) != 1)
11408 error (_("Failed to determine last chain length\n"));
11412 if (maxchain + 1 == 0)
11417 while ((byte_get (nb, 4) & 1) == 0);
11420 (archive_file_offset
11421 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11424 error (_("Unable to seek to start of dynamic information\n"));
11428 gnuchains = get_dynamic_data (file, maxchain, 4);
11429 ngnuchains = maxchain;
11432 if (gnuchains == NULL)
11437 if (do_using_dynamic)
11442 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11444 && do_using_dynamic
11445 && dynamic_strings != NULL
11446 && dynamic_symbols != NULL)
11450 if (dynamic_info[DT_HASH])
11455 printf (_("\nSymbol table for image:\n"));
11457 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11459 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11461 visited = xcmalloc (nchains, 1);
11462 memset (visited, 0, nchains);
11463 for (hn = 0; hn < nbuckets; hn++)
11465 for (si = buckets[hn]; si > 0; si = chains[si])
11467 print_dynamic_symbol (si, hn);
11468 if (si >= nchains || visited[si])
11470 error (_("histogram chain is corrupt\n"));
11479 if (dynamic_info_DT_GNU_HASH)
11481 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11483 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11485 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11487 for (hn = 0; hn < ngnubuckets; ++hn)
11488 if (gnubuckets[hn] != 0)
11490 bfd_vma si = gnubuckets[hn];
11491 bfd_vma off = si - gnusymidx;
11495 print_dynamic_symbol (si, hn);
11498 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11502 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11503 && section_headers != NULL)
11507 for (i = 0, section = section_headers;
11508 i < elf_header.e_shnum;
11512 char * strtab = NULL;
11513 unsigned long int strtab_size = 0;
11514 Elf_Internal_Sym * symtab;
11515 Elf_Internal_Sym * psym;
11516 unsigned long num_syms;
11518 if ((section->sh_type != SHT_SYMTAB
11519 && section->sh_type != SHT_DYNSYM)
11521 && section->sh_type == SHT_SYMTAB))
11524 if (section->sh_entsize == 0)
11526 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11527 printable_section_name (section));
11531 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11532 printable_section_name (section),
11533 (unsigned long) (section->sh_size / section->sh_entsize));
11536 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11538 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11540 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11541 if (symtab == NULL)
11544 if (section->sh_link == elf_header.e_shstrndx)
11546 strtab = string_table;
11547 strtab_size = string_table_length;
11549 else if (section->sh_link < elf_header.e_shnum)
11551 Elf_Internal_Shdr * string_sec;
11553 string_sec = section_headers + section->sh_link;
11555 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11556 1, string_sec->sh_size,
11557 _("string table"));
11558 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11561 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11563 const char *version_string;
11564 enum versioned_symbol_info sym_info;
11565 unsigned short vna_other;
11567 printf ("%6d: ", si);
11568 print_vma (psym->st_value, LONG_HEX);
11570 print_vma (psym->st_size, DEC_5);
11571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11573 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11574 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11577 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11579 printf (" %-7s", get_symbol_visibility (vis));
11580 /* Check to see if any other bits in the st_other field are set.
11581 Note - displaying this information disrupts the layout of the
11582 table being generated, but for the moment this case is very rare. */
11583 if (psym->st_other ^ vis)
11584 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11586 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11587 print_symbol (25, psym->st_name < strtab_size
11588 ? strtab + psym->st_name : _("<corrupt>"));
11591 = get_symbol_version_string (file,
11592 section->sh_type == SHT_DYNSYM,
11593 strtab, strtab_size, si,
11594 psym, &sym_info, &vna_other);
11595 if (version_string)
11597 if (sym_info == symbol_undefined)
11598 printf ("@%s (%d)", version_string, vna_other);
11600 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11606 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11607 && si >= section->sh_info
11608 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11609 && elf_header.e_machine != EM_MIPS
11610 /* Solaris binaries have been found to violate this requirement as
11611 well. Not sure if this is a bug or an ABI requirement. */
11612 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11613 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11614 si, printable_section_name (section), section->sh_info);
11618 if (strtab != string_table)
11624 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11626 if (do_histogram && buckets != NULL)
11628 unsigned long * lengths;
11629 unsigned long * counts;
11632 unsigned long maxlength = 0;
11633 unsigned long nzero_counts = 0;
11634 unsigned long nsyms = 0;
11637 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11638 (unsigned long) nbuckets);
11640 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11641 if (lengths == NULL)
11643 error (_("Out of memory allocating space for histogram buckets\n"));
11646 visited = xcmalloc (nchains, 1);
11647 memset (visited, 0, nchains);
11649 printf (_(" Length Number %% of total Coverage\n"));
11650 for (hn = 0; hn < nbuckets; ++hn)
11652 for (si = buckets[hn]; si > 0; si = chains[si])
11655 if (maxlength < ++lengths[hn])
11657 if (si >= nchains || visited[si])
11659 error (_("histogram chain is corrupt\n"));
11667 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11668 if (counts == NULL)
11671 error (_("Out of memory allocating space for histogram counts\n"));
11675 for (hn = 0; hn < nbuckets; ++hn)
11676 ++counts[lengths[hn]];
11681 printf (" 0 %-10lu (%5.1f%%)\n",
11682 counts[0], (counts[0] * 100.0) / nbuckets);
11683 for (i = 1; i <= maxlength; ++i)
11685 nzero_counts += counts[i] * i;
11686 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11687 i, counts[i], (counts[i] * 100.0) / nbuckets,
11688 (nzero_counts * 100.0) / nsyms);
11696 if (buckets != NULL)
11702 if (do_histogram && gnubuckets != NULL)
11704 unsigned long * lengths;
11705 unsigned long * counts;
11707 unsigned long maxlength = 0;
11708 unsigned long nzero_counts = 0;
11709 unsigned long nsyms = 0;
11711 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11712 (unsigned long) ngnubuckets);
11714 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11715 if (lengths == NULL)
11717 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11721 printf (_(" Length Number %% of total Coverage\n"));
11723 for (hn = 0; hn < ngnubuckets; ++hn)
11724 if (gnubuckets[hn] != 0)
11726 bfd_vma off, length = 1;
11728 for (off = gnubuckets[hn] - gnusymidx;
11729 /* PR 17531 file: 010-77222-0.004. */
11730 off < ngnuchains && (gnuchains[off] & 1) == 0;
11733 lengths[hn] = length;
11734 if (length > maxlength)
11735 maxlength = length;
11739 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11740 if (counts == NULL)
11743 error (_("Out of memory allocating space for gnu histogram counts\n"));
11747 for (hn = 0; hn < ngnubuckets; ++hn)
11748 ++counts[lengths[hn]];
11750 if (ngnubuckets > 0)
11753 printf (" 0 %-10lu (%5.1f%%)\n",
11754 counts[0], (counts[0] * 100.0) / ngnubuckets);
11755 for (j = 1; j <= maxlength; ++j)
11757 nzero_counts += counts[j] * j;
11758 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11759 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11760 (nzero_counts * 100.0) / nsyms);
11774 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11778 if (dynamic_syminfo == NULL
11780 /* No syminfo, this is ok. */
11783 /* There better should be a dynamic symbol section. */
11784 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11788 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11789 dynamic_syminfo_offset, dynamic_syminfo_nent);
11791 printf (_(" Num: Name BoundTo Flags\n"));
11792 for (i = 0; i < dynamic_syminfo_nent; ++i)
11794 unsigned short int flags = dynamic_syminfo[i].si_flags;
11796 printf ("%4d: ", i);
11797 if (i >= num_dynamic_syms)
11798 printf (_("<corrupt index>"));
11799 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11800 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11802 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11805 switch (dynamic_syminfo[i].si_boundto)
11807 case SYMINFO_BT_SELF:
11808 fputs ("SELF ", stdout);
11810 case SYMINFO_BT_PARENT:
11811 fputs ("PARENT ", stdout);
11814 if (dynamic_syminfo[i].si_boundto > 0
11815 && dynamic_syminfo[i].si_boundto < dynamic_nent
11816 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11818 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11822 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11826 if (flags & SYMINFO_FLG_DIRECT)
11827 printf (" DIRECT");
11828 if (flags & SYMINFO_FLG_PASSTHRU)
11829 printf (" PASSTHRU");
11830 if (flags & SYMINFO_FLG_COPY)
11832 if (flags & SYMINFO_FLG_LAZYLOAD)
11833 printf (" LAZYLOAD");
11841 #define IN_RANGE(START,END,ADDR,OFF) \
11842 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11844 /* Check to see if the given reloc needs to be handled in a target specific
11845 manner. If so then process the reloc and return TRUE otherwise return
11848 If called with reloc == NULL, then this is a signal that reloc processing
11849 for the current section has finished, and any saved state should be
11853 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11854 unsigned char * start,
11855 unsigned char * end,
11856 Elf_Internal_Sym * symtab,
11857 unsigned long num_syms)
11859 unsigned int reloc_type = 0;
11860 unsigned long sym_index = 0;
11864 reloc_type = get_reloc_type (reloc->r_info);
11865 sym_index = get_reloc_symindex (reloc->r_info);
11868 switch (elf_header.e_machine)
11871 case EM_MSP430_OLD:
11873 static Elf_Internal_Sym * saved_sym = NULL;
11881 switch (reloc_type)
11883 case 10: /* R_MSP430_SYM_DIFF */
11884 if (uses_msp430x_relocs ())
11886 /* Fall through. */
11887 case 21: /* R_MSP430X_SYM_DIFF */
11889 if (sym_index >= num_syms)
11890 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11893 saved_sym = symtab + sym_index;
11896 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11897 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11898 goto handle_sym_diff;
11900 case 5: /* R_MSP430_16_BYTE */
11901 case 9: /* R_MSP430_8 */
11902 if (uses_msp430x_relocs ())
11904 goto handle_sym_diff;
11906 case 2: /* R_MSP430_ABS16 */
11907 case 15: /* R_MSP430X_ABS16 */
11908 if (! uses_msp430x_relocs ())
11910 goto handle_sym_diff;
11913 if (saved_sym != NULL)
11915 int reloc_size = reloc_type == 1 ? 4 : 2;
11918 if (sym_index >= num_syms)
11919 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11923 value = reloc->r_addend + (symtab[sym_index].st_value
11924 - saved_sym->st_value);
11926 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11927 byte_put (start + reloc->r_offset, value, reloc_size);
11930 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11931 (long) reloc->r_offset);
11940 if (saved_sym != NULL)
11941 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11948 case EM_CYGNUS_MN10300:
11950 static Elf_Internal_Sym * saved_sym = NULL;
11958 switch (reloc_type)
11960 case 34: /* R_MN10300_ALIGN */
11962 case 33: /* R_MN10300_SYM_DIFF */
11963 if (sym_index >= num_syms)
11964 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11967 saved_sym = symtab + sym_index;
11970 case 1: /* R_MN10300_32 */
11971 case 2: /* R_MN10300_16 */
11972 if (saved_sym != NULL)
11974 int reloc_size = reloc_type == 1 ? 4 : 2;
11977 if (sym_index >= num_syms)
11978 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11982 value = reloc->r_addend + (symtab[sym_index].st_value
11983 - saved_sym->st_value);
11985 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11986 byte_put (start + reloc->r_offset, value, reloc_size);
11988 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11989 (long) reloc->r_offset);
11997 if (saved_sym != NULL)
11998 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12006 static bfd_vma saved_sym1 = 0;
12007 static bfd_vma saved_sym2 = 0;
12008 static bfd_vma value;
12012 saved_sym1 = saved_sym2 = 0;
12016 switch (reloc_type)
12018 case 0x80: /* R_RL78_SYM. */
12019 saved_sym1 = saved_sym2;
12020 if (sym_index >= num_syms)
12021 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12025 saved_sym2 = symtab[sym_index].st_value;
12026 saved_sym2 += reloc->r_addend;
12030 case 0x83: /* R_RL78_OPsub. */
12031 value = saved_sym1 - saved_sym2;
12032 saved_sym2 = saved_sym1 = 0;
12036 case 0x41: /* R_RL78_ABS32. */
12037 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12038 byte_put (start + reloc->r_offset, value, 4);
12040 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12041 (long) reloc->r_offset);
12045 case 0x43: /* R_RL78_ABS16. */
12046 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12047 byte_put (start + reloc->r_offset, value, 2);
12049 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12050 (long) reloc->r_offset);
12064 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12065 DWARF debug sections. This is a target specific test. Note - we do not
12066 go through the whole including-target-headers-multiple-times route, (as
12067 we have already done with <elf/h8.h>) because this would become very
12068 messy and even then this function would have to contain target specific
12069 information (the names of the relocs instead of their numeric values).
12070 FIXME: This is not the correct way to solve this problem. The proper way
12071 is to have target specific reloc sizing and typing functions created by
12072 the reloc-macros.h header, in the same way that it already creates the
12073 reloc naming functions. */
12076 is_32bit_abs_reloc (unsigned int reloc_type)
12078 /* Please keep this table alpha-sorted for ease of visual lookup. */
12079 switch (elf_header.e_machine)
12083 return reloc_type == 1; /* R_386_32. */
12085 return reloc_type == 1; /* R_68K_32. */
12087 return reloc_type == 1; /* R_860_32. */
12089 return reloc_type == 2; /* R_960_32. */
12091 return (reloc_type == 258
12092 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12093 case EM_ADAPTEVA_EPIPHANY:
12094 return reloc_type == 3;
12096 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12098 return reloc_type == 1; /* R_ARC_32. */
12099 case EM_ARC_COMPACT:
12100 case EM_ARC_COMPACT2:
12101 return reloc_type == 4; /* R_ARC_32. */
12103 return reloc_type == 2; /* R_ARM_ABS32 */
12106 return reloc_type == 1;
12108 return reloc_type == 0x12; /* R_byte4_data. */
12110 return reloc_type == 3; /* R_CRIS_32. */
12112 return reloc_type == 3; /* R_CR16_NUM32. */
12114 return reloc_type == 15; /* R_CRX_NUM32. */
12115 case EM_CYGNUS_FRV:
12116 return reloc_type == 1;
12117 case EM_CYGNUS_D10V:
12119 return reloc_type == 6; /* R_D10V_32. */
12120 case EM_CYGNUS_D30V:
12122 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12124 return reloc_type == 3; /* R_DLX_RELOC_32. */
12125 case EM_CYGNUS_FR30:
12127 return reloc_type == 3; /* R_FR30_32. */
12129 return reloc_type == 1; /* R_FT32_32. */
12133 return reloc_type == 1; /* R_H8_DIR32. */
12135 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12136 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12137 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12138 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12141 return reloc_type == 2; /* R_IP2K_32. */
12143 return reloc_type == 2; /* R_IQ2000_32. */
12144 case EM_LATTICEMICO32:
12145 return reloc_type == 3; /* R_LM32_32. */
12148 return reloc_type == 3; /* R_M32C_32. */
12150 return reloc_type == 34; /* R_M32R_32_RELA. */
12153 return reloc_type == 6; /* R_M68HC11_32. */
12155 return reloc_type == 1; /* R_MCORE_ADDR32. */
12156 case EM_CYGNUS_MEP:
12157 return reloc_type == 4; /* R_MEP_32. */
12159 return reloc_type == 2; /* R_METAG_ADDR32. */
12160 case EM_MICROBLAZE:
12161 return reloc_type == 1; /* R_MICROBLAZE_32. */
12163 return reloc_type == 2; /* R_MIPS_32. */
12165 return reloc_type == 4; /* R_MMIX_32. */
12166 case EM_CYGNUS_MN10200:
12168 return reloc_type == 1; /* R_MN10200_32. */
12169 case EM_CYGNUS_MN10300:
12171 return reloc_type == 1; /* R_MN10300_32. */
12173 return reloc_type == 1; /* R_MOXIE_32. */
12174 case EM_MSP430_OLD:
12176 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12178 return reloc_type == 2; /* R_MT_32. */
12180 return reloc_type == 20; /* R_NDS32_RELA. */
12181 case EM_ALTERA_NIOS2:
12182 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12184 return reloc_type == 1; /* R_NIOS_32. */
12186 return reloc_type == 1; /* R_OR1K_32. */
12188 return (reloc_type == 1 /* R_PARISC_DIR32. */
12189 || reloc_type == 41); /* R_PARISC_SECREL32. */
12192 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12194 return reloc_type == 1; /* R_PPC64_ADDR32. */
12196 return reloc_type == 1; /* R_PPC_ADDR32. */
12198 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12200 return reloc_type == 1; /* R_RISCV_32. */
12202 return reloc_type == 1; /* R_RL78_DIR32. */
12204 return reloc_type == 1; /* R_RX_DIR32. */
12206 return reloc_type == 1; /* R_I370_ADDR31. */
12209 return reloc_type == 4; /* R_S390_32. */
12211 return reloc_type == 8; /* R_SCORE_ABS32. */
12213 return reloc_type == 1; /* R_SH_DIR32. */
12214 case EM_SPARC32PLUS:
12217 return reloc_type == 3 /* R_SPARC_32. */
12218 || reloc_type == 23; /* R_SPARC_UA32. */
12220 return reloc_type == 6; /* R_SPU_ADDR32 */
12222 return reloc_type == 1; /* R_C6000_ABS32. */
12224 return reloc_type == 2; /* R_TILEGX_32. */
12226 return reloc_type == 1; /* R_TILEPRO_32. */
12227 case EM_CYGNUS_V850:
12229 return reloc_type == 6; /* R_V850_ABS32. */
12231 return reloc_type == 0x33; /* R_V810_WORD. */
12233 return reloc_type == 1; /* R_VAX_32. */
12235 return reloc_type == 3; /* R_VISIUM_32. */
12236 case EM_WEBASSEMBLY:
12237 return reloc_type == 1; /* R_WASM32_32. */
12241 return reloc_type == 10; /* R_X86_64_32. */
12244 return reloc_type == 3; /* R_XC16C_ABS_32. */
12246 return reloc_type == 4; /* R_XGATE_32. */
12248 return reloc_type == 1; /* R_XSTROMY16_32. */
12249 case EM_XTENSA_OLD:
12251 return reloc_type == 1; /* R_XTENSA_32. */
12254 static unsigned int prev_warn = 0;
12256 /* Avoid repeating the same warning multiple times. */
12257 if (prev_warn != elf_header.e_machine)
12258 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12259 elf_header.e_machine);
12260 prev_warn = elf_header.e_machine;
12266 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12267 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12270 is_32bit_pcrel_reloc (unsigned int reloc_type)
12272 switch (elf_header.e_machine)
12273 /* Please keep this table alpha-sorted for ease of visual lookup. */
12277 return reloc_type == 2; /* R_386_PC32. */
12279 return reloc_type == 4; /* R_68K_PC32. */
12281 return reloc_type == 261; /* R_AARCH64_PREL32 */
12282 case EM_ADAPTEVA_EPIPHANY:
12283 return reloc_type == 6;
12285 return reloc_type == 10; /* R_ALPHA_SREL32. */
12286 case EM_ARC_COMPACT:
12287 case EM_ARC_COMPACT2:
12288 return reloc_type == 49; /* R_ARC_32_PCREL. */
12290 return reloc_type == 3; /* R_ARM_REL32 */
12293 return reloc_type == 36; /* R_AVR_32_PCREL. */
12294 case EM_MICROBLAZE:
12295 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12297 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12299 return reloc_type == 9; /* R_PARISC_PCREL32. */
12301 return reloc_type == 26; /* R_PPC_REL32. */
12303 return reloc_type == 26; /* R_PPC64_REL32. */
12306 return reloc_type == 5; /* R_390_PC32. */
12308 return reloc_type == 2; /* R_SH_REL32. */
12309 case EM_SPARC32PLUS:
12312 return reloc_type == 6; /* R_SPARC_DISP32. */
12314 return reloc_type == 13; /* R_SPU_REL32. */
12316 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12318 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12320 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12324 return reloc_type == 2; /* R_X86_64_PC32. */
12325 case EM_XTENSA_OLD:
12327 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12329 /* Do not abort or issue an error message here. Not all targets use
12330 pc-relative 32-bit relocs in their DWARF debug information and we
12331 have already tested for target coverage in is_32bit_abs_reloc. A
12332 more helpful warning message will be generated by apply_relocations
12333 anyway, so just return. */
12338 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12339 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12342 is_64bit_abs_reloc (unsigned int reloc_type)
12344 switch (elf_header.e_machine)
12347 return reloc_type == 257; /* R_AARCH64_ABS64. */
12349 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12351 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12352 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12354 return reloc_type == 80; /* R_PARISC_DIR64. */
12356 return reloc_type == 38; /* R_PPC64_ADDR64. */
12358 return reloc_type == 2; /* R_RISCV_64. */
12359 case EM_SPARC32PLUS:
12362 return reloc_type == 32 /* R_SPARC_64. */
12363 || reloc_type == 54; /* R_SPARC_UA64. */
12367 return reloc_type == 1; /* R_X86_64_64. */
12370 return reloc_type == 22; /* R_S390_64. */
12372 return reloc_type == 1; /* R_TILEGX_64. */
12374 return reloc_type == 18; /* R_MIPS_64. */
12380 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12381 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12384 is_64bit_pcrel_reloc (unsigned int reloc_type)
12386 switch (elf_header.e_machine)
12389 return reloc_type == 260; /* R_AARCH64_PREL64. */
12391 return reloc_type == 11; /* R_ALPHA_SREL64. */
12393 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12394 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12396 return reloc_type == 72; /* R_PARISC_PCREL64. */
12398 return reloc_type == 44; /* R_PPC64_REL64. */
12399 case EM_SPARC32PLUS:
12402 return reloc_type == 46; /* R_SPARC_DISP64. */
12406 return reloc_type == 24; /* R_X86_64_PC64. */
12409 return reloc_type == 23; /* R_S390_PC64. */
12411 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12417 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12418 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12421 is_24bit_abs_reloc (unsigned int reloc_type)
12423 switch (elf_header.e_machine)
12425 case EM_CYGNUS_MN10200:
12427 return reloc_type == 4; /* R_MN10200_24. */
12429 return reloc_type == 5; /* R_FT32_20. */
12435 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12436 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12439 is_16bit_abs_reloc (unsigned int reloc_type)
12441 /* Please keep this table alpha-sorted for ease of visual lookup. */
12442 switch (elf_header.e_machine)
12445 case EM_ARC_COMPACT:
12446 case EM_ARC_COMPACT2:
12447 return reloc_type == 2; /* R_ARC_16. */
12448 case EM_ADAPTEVA_EPIPHANY:
12449 return reloc_type == 5;
12452 return reloc_type == 4; /* R_AVR_16. */
12453 case EM_CYGNUS_D10V:
12455 return reloc_type == 3; /* R_D10V_16. */
12457 return reloc_type == 2; /* R_FT32_16. */
12461 return reloc_type == R_H8_DIR16;
12464 return reloc_type == 1; /* R_IP2K_16. */
12467 return reloc_type == 1; /* R_M32C_16 */
12468 case EM_CYGNUS_MN10200:
12470 return reloc_type == 2; /* R_MN10200_16. */
12471 case EM_CYGNUS_MN10300:
12473 return reloc_type == 2; /* R_MN10300_16. */
12475 if (uses_msp430x_relocs ())
12476 return reloc_type == 2; /* R_MSP430_ABS16. */
12477 /* Fall through. */
12478 case EM_MSP430_OLD:
12479 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12481 return reloc_type == 19; /* R_NDS32_RELA. */
12482 case EM_ALTERA_NIOS2:
12483 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12485 return reloc_type == 9; /* R_NIOS_16. */
12487 return reloc_type == 2; /* R_OR1K_16. */
12489 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12491 return reloc_type == 2; /* R_C6000_ABS16. */
12493 return reloc_type == 2; /* R_VISIUM_16. */
12496 return reloc_type == 2; /* R_XC16C_ABS_16. */
12498 return reloc_type == 3; /* R_XGATE_16. */
12504 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12505 relocation entries (possibly formerly used for SHT_GROUP sections). */
12508 is_none_reloc (unsigned int reloc_type)
12510 switch (elf_header.e_machine)
12512 case EM_386: /* R_386_NONE. */
12513 case EM_68K: /* R_68K_NONE. */
12514 case EM_ADAPTEVA_EPIPHANY:
12515 case EM_ALPHA: /* R_ALPHA_NONE. */
12516 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12517 case EM_ARC: /* R_ARC_NONE. */
12518 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12519 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12520 case EM_ARM: /* R_ARM_NONE. */
12521 case EM_C166: /* R_XC16X_NONE. */
12522 case EM_CRIS: /* R_CRIS_NONE. */
12523 case EM_FT32: /* R_FT32_NONE. */
12524 case EM_IA_64: /* R_IA64_NONE. */
12525 case EM_K1OM: /* R_X86_64_NONE. */
12526 case EM_L1OM: /* R_X86_64_NONE. */
12527 case EM_M32R: /* R_M32R_NONE. */
12528 case EM_MIPS: /* R_MIPS_NONE. */
12529 case EM_MN10300: /* R_MN10300_NONE. */
12530 case EM_MOXIE: /* R_MOXIE_NONE. */
12531 case EM_NIOS32: /* R_NIOS_NONE. */
12532 case EM_OR1K: /* R_OR1K_NONE. */
12533 case EM_PARISC: /* R_PARISC_NONE. */
12534 case EM_PPC64: /* R_PPC64_NONE. */
12535 case EM_PPC: /* R_PPC_NONE. */
12536 case EM_RISCV: /* R_RISCV_NONE. */
12537 case EM_S390: /* R_390_NONE. */
12539 case EM_SH: /* R_SH_NONE. */
12540 case EM_SPARC32PLUS:
12541 case EM_SPARC: /* R_SPARC_NONE. */
12543 case EM_TILEGX: /* R_TILEGX_NONE. */
12544 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12545 case EM_TI_C6000:/* R_C6000_NONE. */
12546 case EM_X86_64: /* R_X86_64_NONE. */
12548 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12549 return reloc_type == 0;
12552 return reloc_type == 0 || reloc_type == 256;
12555 return (reloc_type == 0 /* R_AVR_NONE. */
12556 || reloc_type == 30 /* R_AVR_DIFF8. */
12557 || reloc_type == 31 /* R_AVR_DIFF16. */
12558 || reloc_type == 32 /* R_AVR_DIFF32. */);
12560 return reloc_type == 3; /* R_METAG_NONE. */
12562 return (reloc_type == 0 /* R_XTENSA_NONE. */
12563 || reloc_type == 204 /* R_NDS32_DIFF8. */
12564 || reloc_type == 205 /* R_NDS32_DIFF16. */
12565 || reloc_type == 206 /* R_NDS32_DIFF32. */
12566 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12568 return (reloc_type == 0 /* R_PRU_NONE. */
12569 || reloc_type == 65 /* R_PRU_DIFF8. */
12570 || reloc_type == 66 /* R_PRU_DIFF16. */
12571 || reloc_type == 67 /* R_PRU_DIFF32. */);
12572 case EM_XTENSA_OLD:
12574 return (reloc_type == 0 /* R_XTENSA_NONE. */
12575 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12576 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12577 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12582 /* Returns TRUE if there is a relocation against
12583 section NAME at OFFSET bytes. */
12586 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12588 Elf_Internal_Rela * relocs;
12589 Elf_Internal_Rela * rp;
12591 if (dsec == NULL || dsec->reloc_info == NULL)
12594 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12596 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12597 if (rp->r_offset == offset)
12603 /* Apply relocations to a section.
12604 Returns TRUE upon success, FALSE otherwise.
12605 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12606 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12607 will be set to the number of relocs loaded.
12609 Note: So far support has been added only for those relocations
12610 which can be found in debug sections. FIXME: Add support for
12611 more relocations ? */
12614 apply_relocations (void * file,
12615 const Elf_Internal_Shdr * section,
12616 unsigned char * start,
12617 bfd_size_type size,
12618 void ** relocs_return,
12619 unsigned long * num_relocs_return)
12621 Elf_Internal_Shdr * relsec;
12622 unsigned char * end = start + size;
12623 bfd_boolean res = TRUE;
12625 if (relocs_return != NULL)
12627 * (Elf_Internal_Rela **) relocs_return = NULL;
12628 * num_relocs_return = 0;
12631 if (elf_header.e_type != ET_REL)
12632 /* No relocs to apply. */
12635 /* Find the reloc section associated with the section. */
12636 for (relsec = section_headers;
12637 relsec < section_headers + elf_header.e_shnum;
12640 bfd_boolean is_rela;
12641 unsigned long num_relocs;
12642 Elf_Internal_Rela * relocs;
12643 Elf_Internal_Rela * rp;
12644 Elf_Internal_Shdr * symsec;
12645 Elf_Internal_Sym * symtab;
12646 unsigned long num_syms;
12647 Elf_Internal_Sym * sym;
12649 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12650 || relsec->sh_info >= elf_header.e_shnum
12651 || section_headers + relsec->sh_info != section
12652 || relsec->sh_size == 0
12653 || relsec->sh_link >= elf_header.e_shnum)
12656 is_rela = relsec->sh_type == SHT_RELA;
12660 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12661 relsec->sh_size, & relocs, & num_relocs))
12666 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12667 relsec->sh_size, & relocs, & num_relocs))
12671 /* SH uses RELA but uses in place value instead of the addend field. */
12672 if (elf_header.e_machine == EM_SH)
12675 symsec = section_headers + relsec->sh_link;
12676 if (symsec->sh_type != SHT_SYMTAB
12677 && symsec->sh_type != SHT_DYNSYM)
12679 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12681 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12684 unsigned int reloc_type;
12685 unsigned int reloc_size;
12686 unsigned char * rloc;
12687 unsigned long sym_index;
12689 reloc_type = get_reloc_type (rp->r_info);
12691 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12693 else if (is_none_reloc (reloc_type))
12695 else if (is_32bit_abs_reloc (reloc_type)
12696 || is_32bit_pcrel_reloc (reloc_type))
12698 else if (is_64bit_abs_reloc (reloc_type)
12699 || is_64bit_pcrel_reloc (reloc_type))
12701 else if (is_24bit_abs_reloc (reloc_type))
12703 else if (is_16bit_abs_reloc (reloc_type))
12707 static unsigned int prev_reloc = 0;
12708 if (reloc_type != prev_reloc)
12709 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12710 reloc_type, printable_section_name (section));
12711 prev_reloc = reloc_type;
12716 rloc = start + rp->r_offset;
12717 if ((rloc + reloc_size) > end || (rloc < start))
12719 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12720 (unsigned long) rp->r_offset,
12721 printable_section_name (section));
12726 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12727 if (sym_index >= num_syms)
12729 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12730 sym_index, printable_section_name (section));
12734 sym = symtab + sym_index;
12736 /* If the reloc has a symbol associated with it,
12737 make sure that it is of an appropriate type.
12739 Relocations against symbols without type can happen.
12740 Gcc -feliminate-dwarf2-dups may generate symbols
12741 without type for debug info.
12743 Icc generates relocations against function symbols
12744 instead of local labels.
12746 Relocations against object symbols can happen, eg when
12747 referencing a global array. For an example of this see
12748 the _clz.o binary in libgcc.a. */
12750 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12751 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12753 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12754 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12755 (long int)(rp - relocs),
12756 printable_section_name (relsec));
12763 addend += rp->r_addend;
12764 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12765 partial_inplace. */
12767 || (elf_header.e_machine == EM_XTENSA
12768 && reloc_type == 1)
12769 || ((elf_header.e_machine == EM_PJ
12770 || elf_header.e_machine == EM_PJ_OLD)
12771 && reloc_type == 1)
12772 || ((elf_header.e_machine == EM_D30V
12773 || elf_header.e_machine == EM_CYGNUS_D30V)
12774 && reloc_type == 12))
12775 addend += byte_get (rloc, reloc_size);
12777 if (is_32bit_pcrel_reloc (reloc_type)
12778 || is_64bit_pcrel_reloc (reloc_type))
12780 /* On HPPA, all pc-relative relocations are biased by 8. */
12781 if (elf_header.e_machine == EM_PARISC)
12783 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12787 byte_put (rloc, addend + sym->st_value, reloc_size);
12791 /* Let the target specific reloc processing code know that
12792 we have finished with these relocs. */
12793 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12797 * (Elf_Internal_Rela **) relocs_return = relocs;
12798 * num_relocs_return = num_relocs;
12809 #ifdef SUPPORT_DISASSEMBLY
12811 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12813 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12815 /* FIXME: XXX -- to be done --- XXX */
12821 /* Reads in the contents of SECTION from FILE, returning a pointer
12822 to a malloc'ed buffer or NULL if something went wrong. */
12825 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12827 bfd_size_type num_bytes;
12829 num_bytes = section->sh_size;
12831 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12833 printf (_("Section '%s' has no data to dump.\n"),
12834 printable_section_name (section));
12838 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12839 _("section contents"));
12842 /* Uncompresses a section that was compressed using zlib, in place. */
12845 uncompress_section_contents (unsigned char **buffer,
12846 dwarf_size_type uncompressed_size,
12847 dwarf_size_type *size)
12849 dwarf_size_type compressed_size = *size;
12850 unsigned char * compressed_buffer = *buffer;
12851 unsigned char * uncompressed_buffer;
12855 /* It is possible the section consists of several compressed
12856 buffers concatenated together, so we uncompress in a loop. */
12857 /* PR 18313: The state field in the z_stream structure is supposed
12858 to be invisible to the user (ie us), but some compilers will
12859 still complain about it being used without initialisation. So
12860 we first zero the entire z_stream structure and then set the fields
12862 memset (& strm, 0, sizeof strm);
12863 strm.avail_in = compressed_size;
12864 strm.next_in = (Bytef *) compressed_buffer;
12865 strm.avail_out = uncompressed_size;
12866 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12868 rc = inflateInit (& strm);
12869 while (strm.avail_in > 0)
12873 strm.next_out = ((Bytef *) uncompressed_buffer
12874 + (uncompressed_size - strm.avail_out));
12875 rc = inflate (&strm, Z_FINISH);
12876 if (rc != Z_STREAM_END)
12878 rc = inflateReset (& strm);
12880 rc = inflateEnd (& strm);
12882 || strm.avail_out != 0)
12885 *buffer = uncompressed_buffer;
12886 *size = uncompressed_size;
12890 free (uncompressed_buffer);
12891 /* Indicate decompression failure. */
12897 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12899 Elf_Internal_Shdr * relsec;
12900 bfd_size_type num_bytes;
12901 unsigned char * data;
12902 unsigned char * end;
12903 unsigned char * real_start;
12904 unsigned char * start;
12905 bfd_boolean some_strings_shown;
12907 real_start = start = (unsigned char *) get_section_contents (section, file);
12909 /* PR 21820: Do not fail if the section was empty. */
12910 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
12912 num_bytes = section->sh_size;
12914 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12916 if (decompress_dumps)
12918 dwarf_size_type new_size = num_bytes;
12919 dwarf_size_type uncompressed_size = 0;
12921 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12923 Elf_Internal_Chdr chdr;
12924 unsigned int compression_header_size
12925 = get_compression_header (& chdr, (unsigned char *) start,
12928 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12930 warn (_("section '%s' has unsupported compress type: %d\n"),
12931 printable_section_name (section), chdr.ch_type);
12934 else if (chdr.ch_addralign != section->sh_addralign)
12936 warn (_("compressed section '%s' is corrupted\n"),
12937 printable_section_name (section));
12940 uncompressed_size = chdr.ch_size;
12941 start += compression_header_size;
12942 new_size -= compression_header_size;
12944 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12946 /* Read the zlib header. In this case, it should be "ZLIB"
12947 followed by the uncompressed section size, 8 bytes in
12948 big-endian order. */
12949 uncompressed_size = start[4]; uncompressed_size <<= 8;
12950 uncompressed_size += start[5]; uncompressed_size <<= 8;
12951 uncompressed_size += start[6]; uncompressed_size <<= 8;
12952 uncompressed_size += start[7]; uncompressed_size <<= 8;
12953 uncompressed_size += start[8]; uncompressed_size <<= 8;
12954 uncompressed_size += start[9]; uncompressed_size <<= 8;
12955 uncompressed_size += start[10]; uncompressed_size <<= 8;
12956 uncompressed_size += start[11];
12961 if (uncompressed_size)
12963 if (uncompress_section_contents (& start,
12964 uncompressed_size, & new_size))
12965 num_bytes = new_size;
12968 error (_("Unable to decompress section %s\n"),
12969 printable_section_name (section));
12974 start = real_start;
12977 /* If the section being dumped has relocations against it the user might
12978 be expecting these relocations to have been applied. Check for this
12979 case and issue a warning message in order to avoid confusion.
12980 FIXME: Maybe we ought to have an option that dumps a section with
12981 relocs applied ? */
12982 for (relsec = section_headers;
12983 relsec < section_headers + elf_header.e_shnum;
12986 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12987 || relsec->sh_info >= elf_header.e_shnum
12988 || section_headers + relsec->sh_info != section
12989 || relsec->sh_size == 0
12990 || relsec->sh_link >= elf_header.e_shnum)
12993 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12998 end = start + num_bytes;
12999 some_strings_shown = FALSE;
13003 while (!ISPRINT (* data))
13004 if (++ data >= end)
13009 size_t maxlen = end - data;
13012 /* PR 11128: Use two separate invocations in order to work
13013 around bugs in the Solaris 8 implementation of printf. */
13014 printf (" [%6tx] ", data - start);
13016 printf (" [%6Ix] ", (size_t) (data - start));
13020 print_symbol ((int) maxlen, (const char *) data);
13022 data += strnlen ((const char *) data, maxlen);
13026 printf (_("<corrupt>\n"));
13029 some_strings_shown = TRUE;
13033 if (! some_strings_shown)
13034 printf (_(" No strings found in this section."));
13043 dump_section_as_bytes (Elf_Internal_Shdr * section,
13045 bfd_boolean relocate)
13047 Elf_Internal_Shdr * relsec;
13048 bfd_size_type bytes;
13049 bfd_size_type section_size;
13051 unsigned char * data;
13052 unsigned char * real_start;
13053 unsigned char * start;
13055 real_start = start = (unsigned char *) get_section_contents (section, file);
13057 /* PR 21820: Do not fail if the section was empty. */
13058 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13060 section_size = section->sh_size;
13062 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
13064 if (decompress_dumps)
13066 dwarf_size_type new_size = section_size;
13067 dwarf_size_type uncompressed_size = 0;
13069 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13071 Elf_Internal_Chdr chdr;
13072 unsigned int compression_header_size
13073 = get_compression_header (& chdr, start, section_size);
13075 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13077 warn (_("section '%s' has unsupported compress type: %d\n"),
13078 printable_section_name (section), chdr.ch_type);
13081 else if (chdr.ch_addralign != section->sh_addralign)
13083 warn (_("compressed section '%s' is corrupted\n"),
13084 printable_section_name (section));
13087 uncompressed_size = chdr.ch_size;
13088 start += compression_header_size;
13089 new_size -= compression_header_size;
13091 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13093 /* Read the zlib header. In this case, it should be "ZLIB"
13094 followed by the uncompressed section size, 8 bytes in
13095 big-endian order. */
13096 uncompressed_size = start[4]; uncompressed_size <<= 8;
13097 uncompressed_size += start[5]; uncompressed_size <<= 8;
13098 uncompressed_size += start[6]; uncompressed_size <<= 8;
13099 uncompressed_size += start[7]; uncompressed_size <<= 8;
13100 uncompressed_size += start[8]; uncompressed_size <<= 8;
13101 uncompressed_size += start[9]; uncompressed_size <<= 8;
13102 uncompressed_size += start[10]; uncompressed_size <<= 8;
13103 uncompressed_size += start[11];
13108 if (uncompressed_size)
13110 if (uncompress_section_contents (& start, uncompressed_size,
13113 section_size = new_size;
13117 error (_("Unable to decompress section %s\n"),
13118 printable_section_name (section));
13119 /* FIXME: Print the section anyway ? */
13124 start = real_start;
13129 if (! apply_relocations (file, section, start, section_size, NULL, NULL))
13134 /* If the section being dumped has relocations against it the user might
13135 be expecting these relocations to have been applied. Check for this
13136 case and issue a warning message in order to avoid confusion.
13137 FIXME: Maybe we ought to have an option that dumps a section with
13138 relocs applied ? */
13139 for (relsec = section_headers;
13140 relsec < section_headers + elf_header.e_shnum;
13143 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13144 || relsec->sh_info >= elf_header.e_shnum
13145 || section_headers + relsec->sh_info != section
13146 || relsec->sh_size == 0
13147 || relsec->sh_link >= elf_header.e_shnum)
13150 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13155 addr = section->sh_addr;
13156 bytes = section_size;
13165 lbytes = (bytes > 16 ? 16 : bytes);
13167 printf (" 0x%8.8lx ", (unsigned long) addr);
13169 for (j = 0; j < 16; j++)
13172 printf ("%2.2x", data[j]);
13180 for (j = 0; j < lbytes; j++)
13183 if (k >= ' ' && k < 0x7f)
13203 load_specific_debug_section (enum dwarf_section_display_enum debug,
13204 const Elf_Internal_Shdr * sec, void * file)
13206 struct dwarf_section * section = &debug_displays [debug].section;
13209 /* If it is already loaded, do nothing. */
13210 if (section->start != NULL)
13213 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13214 section->address = sec->sh_addr;
13215 section->user_data = NULL;
13216 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13218 sec->sh_size, buf);
13219 if (section->start == NULL)
13223 unsigned char *start = section->start;
13224 dwarf_size_type size = sec->sh_size;
13225 dwarf_size_type uncompressed_size = 0;
13227 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13229 Elf_Internal_Chdr chdr;
13230 unsigned int compression_header_size;
13232 if (size < (is_32bit_elf
13233 ? sizeof (Elf32_External_Chdr)
13234 : sizeof (Elf64_External_Chdr)))
13236 warn (_("compressed section %s is too small to contain a compression header"),
13241 compression_header_size = get_compression_header (&chdr, start, size);
13243 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13245 warn (_("section '%s' has unsupported compress type: %d\n"),
13246 section->name, chdr.ch_type);
13249 else if (chdr.ch_addralign != sec->sh_addralign)
13251 warn (_("compressed section '%s' is corrupted\n"),
13255 uncompressed_size = chdr.ch_size;
13256 start += compression_header_size;
13257 size -= compression_header_size;
13259 else if (size > 12 && streq ((char *) start, "ZLIB"))
13261 /* Read the zlib header. In this case, it should be "ZLIB"
13262 followed by the uncompressed section size, 8 bytes in
13263 big-endian order. */
13264 uncompressed_size = start[4]; uncompressed_size <<= 8;
13265 uncompressed_size += start[5]; uncompressed_size <<= 8;
13266 uncompressed_size += start[6]; uncompressed_size <<= 8;
13267 uncompressed_size += start[7]; uncompressed_size <<= 8;
13268 uncompressed_size += start[8]; uncompressed_size <<= 8;
13269 uncompressed_size += start[9]; uncompressed_size <<= 8;
13270 uncompressed_size += start[10]; uncompressed_size <<= 8;
13271 uncompressed_size += start[11];
13276 if (uncompressed_size)
13278 if (uncompress_section_contents (&start, uncompressed_size,
13281 /* Free the compressed buffer, update the section buffer
13282 and the section size if uncompress is successful. */
13283 free (section->start);
13284 section->start = start;
13288 error (_("Unable to decompress section %s\n"),
13289 printable_section_name (sec));
13294 section->size = size;
13297 if (section->start == NULL)
13300 if (debug_displays [debug].relocate)
13302 if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13303 & section->reloc_info, & section->num_relocs))
13308 section->reloc_info = NULL;
13309 section->num_relocs = 0;
13315 /* If this is not NULL, load_debug_section will only look for sections
13316 within the list of sections given here. */
13317 static unsigned int * section_subset = NULL;
13320 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13322 struct dwarf_section * section = &debug_displays [debug].section;
13323 Elf_Internal_Shdr * sec;
13325 /* Locate the debug section. */
13326 sec = find_section_in_set (section->uncompressed_name, section_subset);
13328 section->name = section->uncompressed_name;
13331 sec = find_section_in_set (section->compressed_name, section_subset);
13333 section->name = section->compressed_name;
13338 /* If we're loading from a subset of sections, and we've loaded
13339 a section matching this name before, it's likely that it's a
13341 if (section_subset != NULL)
13342 free_debug_section (debug);
13344 return load_specific_debug_section (debug, sec, (FILE *) file);
13348 free_debug_section (enum dwarf_section_display_enum debug)
13350 struct dwarf_section * section = &debug_displays [debug].section;
13352 if (section->start == NULL)
13355 free ((char *) section->start);
13356 section->start = NULL;
13357 section->address = 0;
13362 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13364 char * name = SECTION_NAME (section);
13365 const char * print_name = printable_section_name (section);
13366 bfd_size_type length;
13367 bfd_boolean result = TRUE;
13370 length = section->sh_size;
13373 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13376 if (section->sh_type == SHT_NOBITS)
13378 /* There is no point in dumping the contents of a debugging section
13379 which has the NOBITS type - the bits in the file will be random.
13380 This can happen when a file containing a .eh_frame section is
13381 stripped with the --only-keep-debug command line option. */
13382 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13387 if (const_strneq (name, ".gnu.linkonce.wi."))
13388 name = ".debug_info";
13390 /* See if we know how to display the contents of this section. */
13391 for (i = 0; i < max; i++)
13392 if (streq (debug_displays[i].section.uncompressed_name, name)
13393 || (i == line && const_strneq (name, ".debug_line."))
13394 || streq (debug_displays[i].section.compressed_name, name))
13396 struct dwarf_section * sec = &debug_displays [i].section;
13397 int secondary = (section != find_section (name));
13400 free_debug_section ((enum dwarf_section_display_enum) i);
13402 if (i == line && const_strneq (name, ".debug_line."))
13404 else if (streq (sec->uncompressed_name, name))
13405 sec->name = sec->uncompressed_name;
13407 sec->name = sec->compressed_name;
13408 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13411 /* If this debug section is part of a CU/TU set in a .dwp file,
13412 restrict load_debug_section to the sections in that set. */
13413 section_subset = find_cu_tu_set (file, shndx);
13415 result &= debug_displays[i].display (sec, file);
13417 section_subset = NULL;
13419 if (secondary || (i != info && i != abbrev))
13420 free_debug_section ((enum dwarf_section_display_enum) i);
13428 printf (_("Unrecognized debug section: %s\n"), print_name);
13435 /* Set DUMP_SECTS for all sections where dumps were requested
13436 based on section name. */
13439 initialise_dumps_byname (void)
13441 struct dump_list_entry * cur;
13443 for (cur = dump_sects_byname; cur; cur = cur->next)
13446 bfd_boolean any = FALSE;
13448 for (i = 0; i < elf_header.e_shnum; i++)
13449 if (streq (SECTION_NAME (section_headers + i), cur->name))
13451 request_dump_bynumber (i, cur->type);
13456 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13462 process_section_contents (FILE * file)
13464 Elf_Internal_Shdr * section;
13466 bfd_boolean res = TRUE;
13471 initialise_dumps_byname ();
13473 for (i = 0, section = section_headers;
13474 i < elf_header.e_shnum && i < num_dump_sects;
13477 #ifdef SUPPORT_DISASSEMBLY
13478 if (dump_sects[i] & DISASS_DUMP)
13479 disassemble_section (section, file);
13481 if (dump_sects[i] & HEX_DUMP)
13483 if (! dump_section_as_bytes (section, file, FALSE))
13487 if (dump_sects[i] & RELOC_DUMP)
13489 if (! dump_section_as_bytes (section, file, TRUE))
13493 if (dump_sects[i] & STRING_DUMP)
13495 if (! dump_section_as_strings (section, file))
13499 if (dump_sects[i] & DEBUG_DUMP)
13501 if (! display_debug_section (i, section, file))
13506 /* Check to see if the user requested a
13507 dump of a section that does not exist. */
13508 while (i < num_dump_sects)
13512 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13522 process_mips_fpe_exception (int mask)
13526 bfd_boolean first = TRUE;
13528 if (mask & OEX_FPU_INEX)
13529 fputs ("INEX", stdout), first = FALSE;
13530 if (mask & OEX_FPU_UFLO)
13531 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13532 if (mask & OEX_FPU_OFLO)
13533 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13534 if (mask & OEX_FPU_DIV0)
13535 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13536 if (mask & OEX_FPU_INVAL)
13537 printf ("%sINVAL", first ? "" : "|");
13540 fputs ("0", stdout);
13543 /* Display's the value of TAG at location P. If TAG is
13544 greater than 0 it is assumed to be an unknown tag, and
13545 a message is printed to this effect. Otherwise it is
13546 assumed that a message has already been printed.
13548 If the bottom bit of TAG is set it assumed to have a
13549 string value, otherwise it is assumed to have an integer
13552 Returns an updated P pointing to the first unread byte
13553 beyond the end of TAG's value.
13555 Reads at or beyond END will not be made. */
13557 static unsigned char *
13558 display_tag_value (signed int tag,
13560 const unsigned char * const end)
13565 printf (" Tag_unknown_%d: ", tag);
13569 warn (_("<corrupt tag>\n"));
13573 /* PR 17531 file: 027-19978-0.004. */
13574 size_t maxlen = (end - p) - 1;
13579 print_symbol ((int) maxlen, (const char *) p);
13580 p += strnlen ((char *) p, maxlen) + 1;
13584 printf (_("<corrupt string tag>"));
13585 p = (unsigned char *) end;
13593 val = read_uleb128 (p, &len, end);
13595 printf ("%ld (0x%lx)\n", val, val);
13602 /* ARC ABI attributes section. */
13604 static unsigned char *
13605 display_arc_attribute (unsigned char * p,
13606 const unsigned char * const end)
13612 tag = read_uleb128 (p, &len, end);
13617 case Tag_ARC_PCS_config:
13618 val = read_uleb128 (p, &len, end);
13620 printf (" Tag_ARC_PCS_config: ");
13624 printf (_("Absent/Non standard\n"));
13627 printf (_("Bare metal/mwdt\n"));
13630 printf (_("Bare metal/newlib\n"));
13633 printf (_("Linux/uclibc\n"));
13636 printf (_("Linux/glibc\n"));
13639 printf (_("Unknown\n"));
13644 case Tag_ARC_CPU_base:
13645 val = read_uleb128 (p, &len, end);
13647 printf (" Tag_ARC_CPU_base: ");
13652 printf (_("Absent\n"));
13654 case TAG_CPU_ARC6xx:
13655 printf ("ARC6xx\n");
13657 case TAG_CPU_ARC7xx:
13658 printf ("ARC7xx\n");
13660 case TAG_CPU_ARCEM:
13661 printf ("ARCEM\n");
13663 case TAG_CPU_ARCHS:
13664 printf ("ARCHS\n");
13669 case Tag_ARC_CPU_variation:
13670 val = read_uleb128 (p, &len, end);
13672 printf (" Tag_ARC_CPU_variation: ");
13676 if (val > 0 && val < 16)
13677 printf ("Core%d\n", val);
13679 printf ("Unknown\n");
13683 printf (_("Absent\n"));
13688 case Tag_ARC_CPU_name:
13689 printf (" Tag_ARC_CPU_name: ");
13690 p = display_tag_value (-1, p, end);
13693 case Tag_ARC_ABI_rf16:
13694 val = read_uleb128 (p, &len, end);
13696 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13699 case Tag_ARC_ABI_osver:
13700 val = read_uleb128 (p, &len, end);
13702 printf (" Tag_ARC_ABI_osver: v%d\n", val);
13705 case Tag_ARC_ABI_pic:
13706 case Tag_ARC_ABI_sda:
13707 val = read_uleb128 (p, &len, end);
13709 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
13710 : " Tag_ARC_ABI_pic: ");
13714 printf (_("Absent\n"));
13723 printf (_("Unknown\n"));
13728 case Tag_ARC_ABI_tls:
13729 val = read_uleb128 (p, &len, end);
13731 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
13734 case Tag_ARC_ABI_enumsize:
13735 val = read_uleb128 (p, &len, end);
13737 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
13741 case Tag_ARC_ABI_exceptions:
13742 val = read_uleb128 (p, &len, end);
13744 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
13748 case Tag_ARC_ABI_double_size:
13749 val = read_uleb128 (p, &len, end);
13751 printf (" Tag_ARC_ABI_double_size: %d\n", val);
13754 case Tag_ARC_ISA_config:
13755 printf (" Tag_ARC_ISA_config: ");
13756 p = display_tag_value (-1, p, end);
13759 case Tag_ARC_ISA_apex:
13760 printf (" Tag_ARC_ISA_apex: ");
13761 p = display_tag_value (-1, p, end);
13764 case Tag_ARC_ISA_mpy_option:
13765 val = read_uleb128 (p, &len, end);
13767 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
13771 return display_tag_value (tag & 1, p, end);
13777 /* ARM EABI attributes section. */
13782 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13784 const char ** table;
13785 } arm_attr_public_tag;
13787 static const char * arm_attr_tag_CPU_arch[] =
13788 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13789 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13791 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13792 static const char * arm_attr_tag_THUMB_ISA_use[] =
13793 {"No", "Thumb-1", "Thumb-2", "Yes"};
13794 static const char * arm_attr_tag_FP_arch[] =
13795 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13796 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13797 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13798 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13799 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13800 "NEON for ARMv8.1"};
13801 static const char * arm_attr_tag_PCS_config[] =
13802 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13803 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13804 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13805 {"V6", "SB", "TLS", "Unused"};
13806 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13807 {"Absolute", "PC-relative", "SB-relative", "None"};
13808 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13809 {"Absolute", "PC-relative", "None"};
13810 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13811 {"None", "direct", "GOT-indirect"};
13812 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13813 {"None", "??? 1", "2", "??? 3", "4"};
13814 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13815 static const char * arm_attr_tag_ABI_FP_denormal[] =
13816 {"Unused", "Needed", "Sign only"};
13817 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13818 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13819 static const char * arm_attr_tag_ABI_FP_number_model[] =
13820 {"Unused", "Finite", "RTABI", "IEEE 754"};
13821 static const char * arm_attr_tag_ABI_enum_size[] =
13822 {"Unused", "small", "int", "forced to int"};
13823 static const char * arm_attr_tag_ABI_HardFP_use[] =
13824 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13825 static const char * arm_attr_tag_ABI_VFP_args[] =
13826 {"AAPCS", "VFP registers", "custom", "compatible"};
13827 static const char * arm_attr_tag_ABI_WMMX_args[] =
13828 {"AAPCS", "WMMX registers", "custom"};
13829 static const char * arm_attr_tag_ABI_optimization_goals[] =
13830 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13831 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13832 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13833 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13834 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13835 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13836 static const char * arm_attr_tag_FP_HP_extension[] =
13837 {"Not Allowed", "Allowed"};
13838 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13839 {"None", "IEEE 754", "Alternative Format"};
13840 static const char * arm_attr_tag_DSP_extension[] =
13841 {"Follow architecture", "Allowed"};
13842 static const char * arm_attr_tag_MPextension_use[] =
13843 {"Not Allowed", "Allowed"};
13844 static const char * arm_attr_tag_DIV_use[] =
13845 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13846 "Allowed in v7-A with integer division extension"};
13847 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13848 static const char * arm_attr_tag_Virtualization_use[] =
13849 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13850 "TrustZone and Virtualization Extensions"};
13851 static const char * arm_attr_tag_MPextension_use_legacy[] =
13852 {"Not Allowed", "Allowed"};
13854 #define LOOKUP(id, name) \
13855 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13856 static arm_attr_public_tag arm_attr_public_tags[] =
13858 {4, "CPU_raw_name", 1, NULL},
13859 {5, "CPU_name", 1, NULL},
13860 LOOKUP(6, CPU_arch),
13861 {7, "CPU_arch_profile", 0, NULL},
13862 LOOKUP(8, ARM_ISA_use),
13863 LOOKUP(9, THUMB_ISA_use),
13864 LOOKUP(10, FP_arch),
13865 LOOKUP(11, WMMX_arch),
13866 LOOKUP(12, Advanced_SIMD_arch),
13867 LOOKUP(13, PCS_config),
13868 LOOKUP(14, ABI_PCS_R9_use),
13869 LOOKUP(15, ABI_PCS_RW_data),
13870 LOOKUP(16, ABI_PCS_RO_data),
13871 LOOKUP(17, ABI_PCS_GOT_use),
13872 LOOKUP(18, ABI_PCS_wchar_t),
13873 LOOKUP(19, ABI_FP_rounding),
13874 LOOKUP(20, ABI_FP_denormal),
13875 LOOKUP(21, ABI_FP_exceptions),
13876 LOOKUP(22, ABI_FP_user_exceptions),
13877 LOOKUP(23, ABI_FP_number_model),
13878 {24, "ABI_align_needed", 0, NULL},
13879 {25, "ABI_align_preserved", 0, NULL},
13880 LOOKUP(26, ABI_enum_size),
13881 LOOKUP(27, ABI_HardFP_use),
13882 LOOKUP(28, ABI_VFP_args),
13883 LOOKUP(29, ABI_WMMX_args),
13884 LOOKUP(30, ABI_optimization_goals),
13885 LOOKUP(31, ABI_FP_optimization_goals),
13886 {32, "compatibility", 0, NULL},
13887 LOOKUP(34, CPU_unaligned_access),
13888 LOOKUP(36, FP_HP_extension),
13889 LOOKUP(38, ABI_FP_16bit_format),
13890 LOOKUP(42, MPextension_use),
13891 LOOKUP(44, DIV_use),
13892 LOOKUP(46, DSP_extension),
13893 {64, "nodefaults", 0, NULL},
13894 {65, "also_compatible_with", 0, NULL},
13895 LOOKUP(66, T2EE_use),
13896 {67, "conformance", 1, NULL},
13897 LOOKUP(68, Virtualization_use),
13898 LOOKUP(70, MPextension_use_legacy)
13902 static unsigned char *
13903 display_arm_attribute (unsigned char * p,
13904 const unsigned char * const end)
13909 arm_attr_public_tag * attr;
13913 tag = read_uleb128 (p, &len, end);
13916 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13918 if (arm_attr_public_tags[i].tag == tag)
13920 attr = &arm_attr_public_tags[i];
13927 printf (" Tag_%s: ", attr->name);
13928 switch (attr->type)
13933 case 7: /* Tag_CPU_arch_profile. */
13934 val = read_uleb128 (p, &len, end);
13938 case 0: printf (_("None\n")); break;
13939 case 'A': printf (_("Application\n")); break;
13940 case 'R': printf (_("Realtime\n")); break;
13941 case 'M': printf (_("Microcontroller\n")); break;
13942 case 'S': printf (_("Application or Realtime\n")); break;
13943 default: printf ("??? (%d)\n", val); break;
13947 case 24: /* Tag_align_needed. */
13948 val = read_uleb128 (p, &len, end);
13952 case 0: printf (_("None\n")); break;
13953 case 1: printf (_("8-byte\n")); break;
13954 case 2: printf (_("4-byte\n")); break;
13955 case 3: printf ("??? 3\n"); break;
13958 printf (_("8-byte and up to %d-byte extended\n"),
13961 printf ("??? (%d)\n", val);
13966 case 25: /* Tag_align_preserved. */
13967 val = read_uleb128 (p, &len, end);
13971 case 0: printf (_("None\n")); break;
13972 case 1: printf (_("8-byte, except leaf SP\n")); break;
13973 case 2: printf (_("8-byte\n")); break;
13974 case 3: printf ("??? 3\n"); break;
13977 printf (_("8-byte and up to %d-byte extended\n"),
13980 printf ("??? (%d)\n", val);
13985 case 32: /* Tag_compatibility. */
13987 val = read_uleb128 (p, &len, end);
13989 printf (_("flag = %d, vendor = "), val);
13992 size_t maxlen = (end - p) - 1;
13994 print_symbol ((int) maxlen, (const char *) p);
13995 p += strnlen ((char *) p, maxlen) + 1;
13999 printf (_("<corrupt>"));
14000 p = (unsigned char *) end;
14006 case 64: /* Tag_nodefaults. */
14007 /* PR 17531: file: 001-505008-0.01. */
14010 printf (_("True\n"));
14013 case 65: /* Tag_also_compatible_with. */
14014 val = read_uleb128 (p, &len, end);
14016 if (val == 6 /* Tag_CPU_arch. */)
14018 val = read_uleb128 (p, &len, end);
14020 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14021 printf ("??? (%d)\n", val);
14023 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14027 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14032 printf (_("<unknown: %d>\n"), tag);
14038 return display_tag_value (-1, p, end);
14040 return display_tag_value (0, p, end);
14043 assert (attr->type & 0x80);
14044 val = read_uleb128 (p, &len, end);
14046 type = attr->type & 0x7f;
14048 printf ("??? (%d)\n", val);
14050 printf ("%s\n", attr->table[val]);
14055 return display_tag_value (tag, p, end);
14058 static unsigned char *
14059 display_gnu_attribute (unsigned char * p,
14060 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14061 const unsigned char * const end)
14067 tag = read_uleb128 (p, &len, end);
14070 /* Tag_compatibility is the only generic GNU attribute defined at
14074 val = read_uleb128 (p, &len, end);
14077 printf (_("flag = %d, vendor = "), val);
14080 printf (_("<corrupt>\n"));
14081 warn (_("corrupt vendor attribute\n"));
14087 size_t maxlen = (end - p) - 1;
14089 print_symbol ((int) maxlen, (const char *) p);
14090 p += strnlen ((char *) p, maxlen) + 1;
14094 printf (_("<corrupt>"));
14095 p = (unsigned char *) end;
14102 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14103 return display_proc_gnu_attribute (p, tag, end);
14105 return display_tag_value (tag, p, end);
14108 static unsigned char *
14109 display_power_gnu_attribute (unsigned char * p,
14111 const unsigned char * const end)
14116 if (tag == Tag_GNU_Power_ABI_FP)
14118 val = read_uleb128 (p, &len, end);
14120 printf (" Tag_GNU_Power_ABI_FP: ");
14123 printf (_("<corrupt>\n"));
14128 printf ("(%#x), ", val);
14133 printf (_("unspecified hard/soft float, "));
14136 printf (_("hard float, "));
14139 printf (_("soft float, "));
14142 printf (_("single-precision hard float, "));
14149 printf (_("unspecified long double\n"));
14152 printf (_("128-bit IBM long double\n"));
14155 printf (_("64-bit long double\n"));
14158 printf (_("128-bit IEEE long double\n"));
14164 if (tag == Tag_GNU_Power_ABI_Vector)
14166 val = read_uleb128 (p, &len, end);
14168 printf (" Tag_GNU_Power_ABI_Vector: ");
14171 printf (_("<corrupt>\n"));
14176 printf ("(%#x), ", val);
14181 printf (_("unspecified\n"));
14184 printf (_("generic\n"));
14187 printf ("AltiVec\n");
14196 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14198 val = read_uleb128 (p, &len, end);
14200 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14203 printf (_("<corrupt>\n"));
14208 printf ("(%#x), ", val);
14213 printf (_("unspecified\n"));
14216 printf ("r3/r4\n");
14219 printf (_("memory\n"));
14228 return display_tag_value (tag & 1, p, end);
14231 static unsigned char *
14232 display_s390_gnu_attribute (unsigned char * p,
14234 const unsigned char * const end)
14239 if (tag == Tag_GNU_S390_ABI_Vector)
14241 val = read_uleb128 (p, &len, end);
14243 printf (" Tag_GNU_S390_ABI_Vector: ");
14248 printf (_("any\n"));
14251 printf (_("software\n"));
14254 printf (_("hardware\n"));
14257 printf ("??? (%d)\n", val);
14263 return display_tag_value (tag & 1, p, end);
14267 display_sparc_hwcaps (unsigned int mask)
14271 bfd_boolean first = TRUE;
14273 if (mask & ELF_SPARC_HWCAP_MUL32)
14274 fputs ("mul32", stdout), first = FALSE;
14275 if (mask & ELF_SPARC_HWCAP_DIV32)
14276 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14277 if (mask & ELF_SPARC_HWCAP_FSMULD)
14278 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14279 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14280 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14281 if (mask & ELF_SPARC_HWCAP_POPC)
14282 printf ("%spopc", first ? "" : "|"), first = FALSE;
14283 if (mask & ELF_SPARC_HWCAP_VIS)
14284 printf ("%svis", first ? "" : "|"), first = FALSE;
14285 if (mask & ELF_SPARC_HWCAP_VIS2)
14286 printf ("%svis2", first ? "" : "|"), first = FALSE;
14287 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14288 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14289 if (mask & ELF_SPARC_HWCAP_FMAF)
14290 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14291 if (mask & ELF_SPARC_HWCAP_VIS3)
14292 printf ("%svis3", first ? "" : "|"), first = FALSE;
14293 if (mask & ELF_SPARC_HWCAP_HPC)
14294 printf ("%shpc", first ? "" : "|"), first = FALSE;
14295 if (mask & ELF_SPARC_HWCAP_RANDOM)
14296 printf ("%srandom", first ? "" : "|"), first = FALSE;
14297 if (mask & ELF_SPARC_HWCAP_TRANS)
14298 printf ("%strans", first ? "" : "|"), first = FALSE;
14299 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14300 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14301 if (mask & ELF_SPARC_HWCAP_IMA)
14302 printf ("%sima", first ? "" : "|"), first = FALSE;
14303 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14304 printf ("%scspare", first ? "" : "|"), first = FALSE;
14307 fputc ('0', stdout);
14308 fputc ('\n', stdout);
14312 display_sparc_hwcaps2 (unsigned int mask)
14316 bfd_boolean first = TRUE;
14318 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14319 fputs ("fjathplus", stdout), first = FALSE;
14320 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14321 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14322 if (mask & ELF_SPARC_HWCAP2_ADP)
14323 printf ("%sadp", first ? "" : "|"), first = FALSE;
14324 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14325 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14326 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14327 printf ("%smwait", first ? "" : "|"), first = FALSE;
14328 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14329 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14330 if (mask & ELF_SPARC_HWCAP2_XMONT)
14331 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14332 if (mask & ELF_SPARC_HWCAP2_NSEC)
14333 printf ("%snsec", first ? "" : "|"), first = FALSE;
14334 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14335 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14336 if (mask & ELF_SPARC_HWCAP2_FJDES)
14337 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14338 if (mask & ELF_SPARC_HWCAP2_FJAES)
14339 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14342 fputc ('0', stdout);
14343 fputc ('\n', stdout);
14346 static unsigned char *
14347 display_sparc_gnu_attribute (unsigned char * p,
14349 const unsigned char * const end)
14354 if (tag == Tag_GNU_Sparc_HWCAPS)
14356 val = read_uleb128 (p, &len, end);
14358 printf (" Tag_GNU_Sparc_HWCAPS: ");
14359 display_sparc_hwcaps (val);
14362 if (tag == Tag_GNU_Sparc_HWCAPS2)
14364 val = read_uleb128 (p, &len, end);
14366 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14367 display_sparc_hwcaps2 (val);
14371 return display_tag_value (tag, p, end);
14375 print_mips_fp_abi_value (unsigned int val)
14379 case Val_GNU_MIPS_ABI_FP_ANY:
14380 printf (_("Hard or soft float\n"));
14382 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14383 printf (_("Hard float (double precision)\n"));
14385 case Val_GNU_MIPS_ABI_FP_SINGLE:
14386 printf (_("Hard float (single precision)\n"));
14388 case Val_GNU_MIPS_ABI_FP_SOFT:
14389 printf (_("Soft float\n"));
14391 case Val_GNU_MIPS_ABI_FP_OLD_64:
14392 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14394 case Val_GNU_MIPS_ABI_FP_XX:
14395 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14397 case Val_GNU_MIPS_ABI_FP_64:
14398 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14400 case Val_GNU_MIPS_ABI_FP_64A:
14401 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14403 case Val_GNU_MIPS_ABI_FP_NAN2008:
14404 printf (_("NaN 2008 compatibility\n"));
14407 printf ("??? (%d)\n", val);
14412 static unsigned char *
14413 display_mips_gnu_attribute (unsigned char * p,
14415 const unsigned char * const end)
14417 if (tag == Tag_GNU_MIPS_ABI_FP)
14422 val = read_uleb128 (p, &len, end);
14424 printf (" Tag_GNU_MIPS_ABI_FP: ");
14426 print_mips_fp_abi_value (val);
14431 if (tag == Tag_GNU_MIPS_ABI_MSA)
14436 val = read_uleb128 (p, &len, end);
14438 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14442 case Val_GNU_MIPS_ABI_MSA_ANY:
14443 printf (_("Any MSA or not\n"));
14445 case Val_GNU_MIPS_ABI_MSA_128:
14446 printf (_("128-bit MSA\n"));
14449 printf ("??? (%d)\n", val);
14455 return display_tag_value (tag & 1, p, end);
14458 static unsigned char *
14459 display_tic6x_attribute (unsigned char * p,
14460 const unsigned char * const end)
14466 tag = read_uleb128 (p, &len, end);
14472 val = read_uleb128 (p, &len, end);
14474 printf (" Tag_ISA: ");
14478 case C6XABI_Tag_ISA_none:
14479 printf (_("None\n"));
14481 case C6XABI_Tag_ISA_C62X:
14484 case C6XABI_Tag_ISA_C67X:
14487 case C6XABI_Tag_ISA_C67XP:
14488 printf ("C67x+\n");
14490 case C6XABI_Tag_ISA_C64X:
14493 case C6XABI_Tag_ISA_C64XP:
14494 printf ("C64x+\n");
14496 case C6XABI_Tag_ISA_C674X:
14497 printf ("C674x\n");
14500 printf ("??? (%d)\n", val);
14505 case Tag_ABI_wchar_t:
14506 val = read_uleb128 (p, &len, end);
14508 printf (" Tag_ABI_wchar_t: ");
14512 printf (_("Not used\n"));
14515 printf (_("2 bytes\n"));
14518 printf (_("4 bytes\n"));
14521 printf ("??? (%d)\n", val);
14526 case Tag_ABI_stack_align_needed:
14527 val = read_uleb128 (p, &len, end);
14529 printf (" Tag_ABI_stack_align_needed: ");
14533 printf (_("8-byte\n"));
14536 printf (_("16-byte\n"));
14539 printf ("??? (%d)\n", val);
14544 case Tag_ABI_stack_align_preserved:
14545 val = read_uleb128 (p, &len, end);
14547 printf (" Tag_ABI_stack_align_preserved: ");
14551 printf (_("8-byte\n"));
14554 printf (_("16-byte\n"));
14557 printf ("??? (%d)\n", val);
14563 val = read_uleb128 (p, &len, end);
14565 printf (" Tag_ABI_DSBT: ");
14569 printf (_("DSBT addressing not used\n"));
14572 printf (_("DSBT addressing used\n"));
14575 printf ("??? (%d)\n", val);
14581 val = read_uleb128 (p, &len, end);
14583 printf (" Tag_ABI_PID: ");
14587 printf (_("Data addressing position-dependent\n"));
14590 printf (_("Data addressing position-independent, GOT near DP\n"));
14593 printf (_("Data addressing position-independent, GOT far from DP\n"));
14596 printf ("??? (%d)\n", val);
14602 val = read_uleb128 (p, &len, end);
14604 printf (" Tag_ABI_PIC: ");
14608 printf (_("Code addressing position-dependent\n"));
14611 printf (_("Code addressing position-independent\n"));
14614 printf ("??? (%d)\n", val);
14619 case Tag_ABI_array_object_alignment:
14620 val = read_uleb128 (p, &len, end);
14622 printf (" Tag_ABI_array_object_alignment: ");
14626 printf (_("8-byte\n"));
14629 printf (_("4-byte\n"));
14632 printf (_("16-byte\n"));
14635 printf ("??? (%d)\n", val);
14640 case Tag_ABI_array_object_align_expected:
14641 val = read_uleb128 (p, &len, end);
14643 printf (" Tag_ABI_array_object_align_expected: ");
14647 printf (_("8-byte\n"));
14650 printf (_("4-byte\n"));
14653 printf (_("16-byte\n"));
14656 printf ("??? (%d)\n", val);
14661 case Tag_ABI_compatibility:
14663 val = read_uleb128 (p, &len, end);
14665 printf (" Tag_ABI_compatibility: ");
14666 printf (_("flag = %d, vendor = "), val);
14669 size_t maxlen = (end - p) - 1;
14671 print_symbol ((int) maxlen, (const char *) p);
14672 p += strnlen ((char *) p, maxlen) + 1;
14676 printf (_("<corrupt>"));
14677 p = (unsigned char *) end;
14683 case Tag_ABI_conformance:
14685 printf (" Tag_ABI_conformance: \"");
14688 size_t maxlen = (end - p) - 1;
14690 print_symbol ((int) maxlen, (const char *) p);
14691 p += strnlen ((char *) p, maxlen) + 1;
14695 printf (_("<corrupt>"));
14696 p = (unsigned char *) end;
14703 return display_tag_value (tag, p, end);
14707 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14709 unsigned long addr = 0;
14710 size_t bytes = end - p;
14717 int lbytes = (bytes > 16 ? 16 : bytes);
14719 printf (" 0x%8.8lx ", addr);
14721 for (j = 0; j < 16; j++)
14724 printf ("%2.2x", p[j]);
14732 for (j = 0; j < lbytes; j++)
14735 if (k >= ' ' && k < 0x7f)
14751 static unsigned char *
14752 display_msp430x_attribute (unsigned char * p,
14753 const unsigned char * const end)
14759 tag = read_uleb128 (p, & len, end);
14764 case OFBA_MSPABI_Tag_ISA:
14765 val = read_uleb128 (p, &len, end);
14767 printf (" Tag_ISA: ");
14770 case 0: printf (_("None\n")); break;
14771 case 1: printf (_("MSP430\n")); break;
14772 case 2: printf (_("MSP430X\n")); break;
14773 default: printf ("??? (%d)\n", val); break;
14777 case OFBA_MSPABI_Tag_Code_Model:
14778 val = read_uleb128 (p, &len, end);
14780 printf (" Tag_Code_Model: ");
14783 case 0: printf (_("None\n")); break;
14784 case 1: printf (_("Small\n")); break;
14785 case 2: printf (_("Large\n")); break;
14786 default: printf ("??? (%d)\n", val); break;
14790 case OFBA_MSPABI_Tag_Data_Model:
14791 val = read_uleb128 (p, &len, end);
14793 printf (" Tag_Data_Model: ");
14796 case 0: printf (_("None\n")); break;
14797 case 1: printf (_("Small\n")); break;
14798 case 2: printf (_("Large\n")); break;
14799 case 3: printf (_("Restricted Large\n")); break;
14800 default: printf ("??? (%d)\n", val); break;
14805 printf (_(" <unknown tag %d>: "), tag);
14812 size_t maxlen = (end - p) - 1;
14814 print_symbol ((int) maxlen, (const char *) p);
14815 p += strnlen ((char *) p, maxlen) + 1;
14819 printf (_("<corrupt>"));
14820 p = (unsigned char *) end;
14826 val = read_uleb128 (p, &len, end);
14828 printf ("%d (0x%x)\n", val, val);
14838 process_attributes (FILE * file,
14839 const char * public_name,
14840 unsigned int proc_type,
14841 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14842 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14844 Elf_Internal_Shdr * sect;
14846 bfd_boolean res = TRUE;
14848 /* Find the section header so that we get the size. */
14849 for (i = 0, sect = section_headers;
14850 i < elf_header.e_shnum;
14853 unsigned char * contents;
14856 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14859 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14860 sect->sh_size, _("attributes"));
14861 if (contents == NULL)
14868 /* The first character is the version of the attributes.
14869 Currently only version 1, (aka 'A') is recognised here. */
14872 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14877 bfd_vma section_len;
14879 section_len = sect->sh_size - 1;
14882 while (section_len > 0)
14885 unsigned int namelen;
14886 bfd_boolean public_section;
14887 bfd_boolean gnu_section;
14889 if (section_len <= 4)
14891 error (_("Tag section ends prematurely\n"));
14895 attr_len = byte_get (p, 4);
14898 if (attr_len > section_len)
14900 error (_("Bad attribute length (%u > %u)\n"),
14901 (unsigned) attr_len, (unsigned) section_len);
14902 attr_len = section_len;
14905 /* PR 17531: file: 001-101425-0.004 */
14906 else if (attr_len < 5)
14908 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14913 section_len -= attr_len;
14916 namelen = strnlen ((char *) p, attr_len) + 1;
14917 if (namelen == 0 || namelen >= attr_len)
14919 error (_("Corrupt attribute section name\n"));
14924 printf (_("Attribute Section: "));
14925 print_symbol (INT_MAX, (const char *) p);
14928 if (public_name && streq ((char *) p, public_name))
14929 public_section = TRUE;
14931 public_section = FALSE;
14933 if (streq ((char *) p, "gnu"))
14934 gnu_section = TRUE;
14936 gnu_section = FALSE;
14939 attr_len -= namelen;
14941 while (attr_len > 0 && p < contents + sect->sh_size)
14946 unsigned char * end;
14948 /* PR binutils/17531: Safe handling of corrupt files. */
14951 error (_("Unused bytes at end of section\n"));
14958 size = byte_get (p, 4);
14959 if (size > attr_len)
14961 error (_("Bad subsection length (%u > %u)\n"),
14962 (unsigned) size, (unsigned) attr_len);
14966 /* PR binutils/17531: Safe handling of corrupt files. */
14969 error (_("Bad subsection length (%u < 6)\n"),
14977 end = p + size - 1;
14978 assert (end <= contents + sect->sh_size);
14984 printf (_("File Attributes\n"));
14987 printf (_("Section Attributes:"));
14990 printf (_("Symbol Attributes:"));
14991 /* Fall through. */
14997 val = read_uleb128 (p, &j, end);
15001 printf (" %d", val);
15006 printf (_("Unknown tag: %d\n"), tag);
15007 public_section = FALSE;
15011 if (public_section && display_pub_attribute != NULL)
15014 p = display_pub_attribute (p, end);
15017 else if (gnu_section && display_proc_gnu_attribute != NULL)
15020 p = display_gnu_attribute (p,
15021 display_proc_gnu_attribute,
15027 printf (_(" Unknown attribute:\n"));
15028 display_raw_attribute (p, end);
15043 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15044 Print the Address, Access and Initial fields of an entry at VMA ADDR
15045 and return the VMA of the next entry, or -1 if there was a problem.
15046 Does not read from DATA_END or beyond. */
15049 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15050 unsigned char * data_end)
15053 print_vma (addr, LONG_HEX);
15055 if (addr < pltgot + 0xfff0)
15056 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15058 printf ("%10s", "");
15061 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15065 unsigned char * from = data + addr - pltgot;
15067 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15069 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15070 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15071 return (bfd_vma) -1;
15075 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15076 print_vma (entry, LONG_HEX);
15079 return addr + (is_32bit_elf ? 4 : 8);
15082 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15083 PLTGOT. Print the Address and Initial fields of an entry at VMA
15084 ADDR and return the VMA of the next entry. */
15087 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15090 print_vma (addr, LONG_HEX);
15093 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15098 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15099 print_vma (entry, LONG_HEX);
15101 return addr + (is_32bit_elf ? 4 : 8);
15105 print_mips_ases (unsigned int mask)
15107 if (mask & AFL_ASE_DSP)
15108 fputs ("\n\tDSP ASE", stdout);
15109 if (mask & AFL_ASE_DSPR2)
15110 fputs ("\n\tDSP R2 ASE", stdout);
15111 if (mask & AFL_ASE_DSPR3)
15112 fputs ("\n\tDSP R3 ASE", stdout);
15113 if (mask & AFL_ASE_EVA)
15114 fputs ("\n\tEnhanced VA Scheme", stdout);
15115 if (mask & AFL_ASE_MCU)
15116 fputs ("\n\tMCU (MicroController) ASE", stdout);
15117 if (mask & AFL_ASE_MDMX)
15118 fputs ("\n\tMDMX ASE", stdout);
15119 if (mask & AFL_ASE_MIPS3D)
15120 fputs ("\n\tMIPS-3D ASE", stdout);
15121 if (mask & AFL_ASE_MT)
15122 fputs ("\n\tMT ASE", stdout);
15123 if (mask & AFL_ASE_SMARTMIPS)
15124 fputs ("\n\tSmartMIPS ASE", stdout);
15125 if (mask & AFL_ASE_VIRT)
15126 fputs ("\n\tVZ ASE", stdout);
15127 if (mask & AFL_ASE_MSA)
15128 fputs ("\n\tMSA ASE", stdout);
15129 if (mask & AFL_ASE_MIPS16)
15130 fputs ("\n\tMIPS16 ASE", stdout);
15131 if (mask & AFL_ASE_MICROMIPS)
15132 fputs ("\n\tMICROMIPS ASE", stdout);
15133 if (mask & AFL_ASE_XPA)
15134 fputs ("\n\tXPA ASE", stdout);
15135 if (mask & AFL_ASE_MIPS16E2)
15136 fputs ("\n\tMIPS16e2 ASE", stdout);
15138 fprintf (stdout, "\n\t%s", _("None"));
15139 else if ((mask & ~AFL_ASE_MASK) != 0)
15140 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15144 print_mips_isa_ext (unsigned int isa_ext)
15149 fputs (_("None"), stdout);
15152 fputs ("RMI XLR", stdout);
15154 case AFL_EXT_OCTEON3:
15155 fputs ("Cavium Networks Octeon3", stdout);
15157 case AFL_EXT_OCTEON2:
15158 fputs ("Cavium Networks Octeon2", stdout);
15160 case AFL_EXT_OCTEONP:
15161 fputs ("Cavium Networks OcteonP", stdout);
15163 case AFL_EXT_LOONGSON_3A:
15164 fputs ("Loongson 3A", stdout);
15166 case AFL_EXT_OCTEON:
15167 fputs ("Cavium Networks Octeon", stdout);
15170 fputs ("Toshiba R5900", stdout);
15173 fputs ("MIPS R4650", stdout);
15176 fputs ("LSI R4010", stdout);
15179 fputs ("NEC VR4100", stdout);
15182 fputs ("Toshiba R3900", stdout);
15184 case AFL_EXT_10000:
15185 fputs ("MIPS R10000", stdout);
15188 fputs ("Broadcom SB-1", stdout);
15191 fputs ("NEC VR4111/VR4181", stdout);
15194 fputs ("NEC VR4120", stdout);
15197 fputs ("NEC VR5400", stdout);
15200 fputs ("NEC VR5500", stdout);
15202 case AFL_EXT_LOONGSON_2E:
15203 fputs ("ST Microelectronics Loongson 2E", stdout);
15205 case AFL_EXT_LOONGSON_2F:
15206 fputs ("ST Microelectronics Loongson 2F", stdout);
15208 case AFL_EXT_INTERAPTIV_MR2:
15209 fputs ("Imagination interAptiv MR2", stdout);
15212 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15217 get_mips_reg_size (int reg_size)
15219 return (reg_size == AFL_REG_NONE) ? 0
15220 : (reg_size == AFL_REG_32) ? 32
15221 : (reg_size == AFL_REG_64) ? 64
15222 : (reg_size == AFL_REG_128) ? 128
15227 process_mips_specific (FILE * file)
15229 Elf_Internal_Dyn * entry;
15230 Elf_Internal_Shdr *sect = NULL;
15231 size_t liblist_offset = 0;
15232 size_t liblistno = 0;
15233 size_t conflictsno = 0;
15234 size_t options_offset = 0;
15235 size_t conflicts_offset = 0;
15236 size_t pltrelsz = 0;
15238 bfd_vma pltgot = 0;
15239 bfd_vma mips_pltgot = 0;
15240 bfd_vma jmprel = 0;
15241 bfd_vma local_gotno = 0;
15242 bfd_vma gotsym = 0;
15243 bfd_vma symtabno = 0;
15244 bfd_boolean res = TRUE;
15246 if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
15247 display_mips_gnu_attribute))
15250 sect = find_section (".MIPS.abiflags");
15254 Elf_External_ABIFlags_v0 *abiflags_ext;
15255 Elf_Internal_ABIFlags_v0 abiflags_in;
15257 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15259 error (_("Corrupt MIPS ABI Flags section.\n"));
15264 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
15265 sect->sh_size, _("MIPS ABI Flags section"));
15268 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15269 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15270 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15271 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15272 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15273 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15274 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15275 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15276 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15277 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15278 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15280 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15281 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15282 if (abiflags_in.isa_rev > 1)
15283 printf ("r%d", abiflags_in.isa_rev);
15284 printf ("\nGPR size: %d",
15285 get_mips_reg_size (abiflags_in.gpr_size));
15286 printf ("\nCPR1 size: %d",
15287 get_mips_reg_size (abiflags_in.cpr1_size));
15288 printf ("\nCPR2 size: %d",
15289 get_mips_reg_size (abiflags_in.cpr2_size));
15290 fputs ("\nFP ABI: ", stdout);
15291 print_mips_fp_abi_value (abiflags_in.fp_abi);
15292 fputs ("ISA Extension: ", stdout);
15293 print_mips_isa_ext (abiflags_in.isa_ext);
15294 fputs ("\nASEs:", stdout);
15295 print_mips_ases (abiflags_in.ases);
15296 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15297 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15298 fputc ('\n', stdout);
15299 free (abiflags_ext);
15304 /* We have a lot of special sections. Thanks SGI! */
15305 if (dynamic_section == NULL)
15307 /* No dynamic information available. See if there is static GOT. */
15308 sect = find_section (".got");
15311 unsigned char *data_end;
15312 unsigned char *data;
15316 pltgot = sect->sh_addr;
15319 addr_size = (is_32bit_elf ? 4 : 8);
15320 end = pltgot + sect->sh_size;
15322 data = (unsigned char *) get_data (NULL, file, sect->sh_offset,
15324 _("Global Offset Table data"));
15325 /* PR 12855: Null data is handled gracefully throughout. */
15326 data_end = data + (end - pltgot);
15328 printf (_("\nStatic GOT:\n"));
15329 printf (_(" Canonical gp value: "));
15330 print_vma (ent + 0x7ff0, LONG_HEX);
15333 /* In a dynamic binary GOT[0] is reserved for the dynamic
15334 loader to store the lazy resolver pointer, however in
15335 a static binary it may well have been omitted and GOT
15336 reduced to a table of addresses.
15337 PR 21344: Check for the entry being fully available
15338 before fetching it. */
15340 && data + ent - pltgot + addr_size <= data_end
15341 && byte_get (data + ent - pltgot, addr_size) == 0)
15343 printf (_(" Reserved entries:\n"));
15344 printf (_(" %*s %10s %*s\n"),
15345 addr_size * 2, _("Address"), _("Access"),
15346 addr_size * 2, _("Value"));
15347 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15349 if (ent == (bfd_vma) -1)
15350 goto sgot_print_fail;
15352 /* Check for the MSB of GOT[1] being set, identifying a
15353 GNU object. This entry will be used by some runtime
15354 loaders, to store the module pointer. Otherwise this
15355 is an ordinary local entry.
15356 PR 21344: Check for the entry being fully available
15357 before fetching it. */
15359 && data + ent - pltgot + addr_size <= data_end
15360 && (byte_get (data + ent - pltgot, addr_size)
15361 >> (addr_size * 8 - 1)) != 0)
15363 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15365 if (ent == (bfd_vma) -1)
15366 goto sgot_print_fail;
15371 if (data != NULL && ent < end)
15373 printf (_(" Local entries:\n"));
15374 printf (" %*s %10s %*s\n",
15375 addr_size * 2, _("Address"), _("Access"),
15376 addr_size * 2, _("Value"));
15379 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15381 if (ent == (bfd_vma) -1)
15382 goto sgot_print_fail;
15394 for (entry = dynamic_section;
15395 /* PR 17531 file: 012-50589-0.004. */
15396 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15398 switch (entry->d_tag)
15400 case DT_MIPS_LIBLIST:
15402 = offset_from_vma (file, entry->d_un.d_val,
15403 liblistno * sizeof (Elf32_External_Lib));
15405 case DT_MIPS_LIBLISTNO:
15406 liblistno = entry->d_un.d_val;
15408 case DT_MIPS_OPTIONS:
15409 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
15411 case DT_MIPS_CONFLICT:
15413 = offset_from_vma (file, entry->d_un.d_val,
15414 conflictsno * sizeof (Elf32_External_Conflict));
15416 case DT_MIPS_CONFLICTNO:
15417 conflictsno = entry->d_un.d_val;
15420 pltgot = entry->d_un.d_ptr;
15422 case DT_MIPS_LOCAL_GOTNO:
15423 local_gotno = entry->d_un.d_val;
15425 case DT_MIPS_GOTSYM:
15426 gotsym = entry->d_un.d_val;
15428 case DT_MIPS_SYMTABNO:
15429 symtabno = entry->d_un.d_val;
15431 case DT_MIPS_PLTGOT:
15432 mips_pltgot = entry->d_un.d_ptr;
15435 pltrel = entry->d_un.d_val;
15438 pltrelsz = entry->d_un.d_val;
15441 jmprel = entry->d_un.d_ptr;
15447 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15449 Elf32_External_Lib * elib;
15452 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15454 sizeof (Elf32_External_Lib),
15455 _("liblist section data"));
15458 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15459 (unsigned long) liblistno);
15460 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15463 for (cnt = 0; cnt < liblistno; ++cnt)
15470 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15471 atime = BYTE_GET (elib[cnt].l_time_stamp);
15472 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15473 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15474 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15476 tmp = gmtime (&atime);
15477 snprintf (timebuf, sizeof (timebuf),
15478 "%04u-%02u-%02uT%02u:%02u:%02u",
15479 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15480 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15482 printf ("%3lu: ", (unsigned long) cnt);
15483 if (VALID_DYNAMIC_NAME (liblist.l_name))
15484 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15486 printf (_("<corrupt: %9ld>"), liblist.l_name);
15487 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15488 liblist.l_version);
15490 if (liblist.l_flags == 0)
15494 static const struct
15501 { " EXACT_MATCH", LL_EXACT_MATCH },
15502 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15503 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15504 { " EXPORTS", LL_EXPORTS },
15505 { " DELAY_LOAD", LL_DELAY_LOAD },
15506 { " DELTA", LL_DELTA }
15508 int flags = liblist.l_flags;
15511 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15512 if ((flags & l_flags_vals[fcnt].bit) != 0)
15514 fputs (l_flags_vals[fcnt].name, stdout);
15515 flags ^= l_flags_vals[fcnt].bit;
15518 printf (" %#x", (unsigned int) flags);
15530 if (options_offset != 0)
15532 Elf_External_Options * eopt;
15533 Elf_Internal_Options * iopt;
15534 Elf_Internal_Options * option;
15537 sect = section_headers;
15539 /* Find the section header so that we get the size. */
15540 sect = find_section_by_type (SHT_MIPS_OPTIONS);
15541 /* PR 17533 file: 012-277276-0.004. */
15544 error (_("No MIPS_OPTIONS header found\n"));
15548 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15549 sect->sh_size, _("options"));
15552 iopt = (Elf_Internal_Options *)
15553 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15556 error (_("Out of memory allocating space for MIPS options\n"));
15563 while (offset <= sect->sh_size - sizeof (* eopt))
15565 Elf_External_Options * eoption;
15567 eoption = (Elf_External_Options *) ((char *) eopt + offset);
15569 option->kind = BYTE_GET (eoption->kind);
15570 option->size = BYTE_GET (eoption->size);
15571 option->section = BYTE_GET (eoption->section);
15572 option->info = BYTE_GET (eoption->info);
15574 /* PR 17531: file: ffa0fa3b. */
15575 if (option->size < sizeof (* eopt)
15576 || offset + option->size > sect->sh_size)
15578 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15581 offset += option->size;
15587 printf (_("\nSection '%s' contains %d entries:\n"),
15588 printable_section_name (sect), cnt);
15597 switch (option->kind)
15600 /* This shouldn't happen. */
15601 printf (" NULL %d %lx", option->section, option->info);
15604 printf (" REGINFO ");
15605 if (elf_header.e_machine == EM_MIPS)
15608 Elf32_External_RegInfo * ereg;
15609 Elf32_RegInfo reginfo;
15611 ereg = (Elf32_External_RegInfo *) (option + 1);
15612 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15613 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15614 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15615 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15616 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15617 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15619 printf ("GPR %08lx GP 0x%lx\n",
15620 reginfo.ri_gprmask,
15621 (unsigned long) reginfo.ri_gp_value);
15622 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15623 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15624 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15629 Elf64_External_RegInfo * ereg;
15630 Elf64_Internal_RegInfo reginfo;
15632 ereg = (Elf64_External_RegInfo *) (option + 1);
15633 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15634 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15635 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15636 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15637 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15638 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15640 printf ("GPR %08lx GP 0x",
15641 reginfo.ri_gprmask);
15642 printf_vma (reginfo.ri_gp_value);
15645 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15646 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15647 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15651 case ODK_EXCEPTIONS:
15652 fputs (" EXCEPTIONS fpe_min(", stdout);
15653 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15654 fputs (") fpe_max(", stdout);
15655 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15656 fputs (")", stdout);
15658 if (option->info & OEX_PAGE0)
15659 fputs (" PAGE0", stdout);
15660 if (option->info & OEX_SMM)
15661 fputs (" SMM", stdout);
15662 if (option->info & OEX_FPDBUG)
15663 fputs (" FPDBUG", stdout);
15664 if (option->info & OEX_DISMISS)
15665 fputs (" DISMISS", stdout);
15668 fputs (" PAD ", stdout);
15669 if (option->info & OPAD_PREFIX)
15670 fputs (" PREFIX", stdout);
15671 if (option->info & OPAD_POSTFIX)
15672 fputs (" POSTFIX", stdout);
15673 if (option->info & OPAD_SYMBOL)
15674 fputs (" SYMBOL", stdout);
15677 fputs (" HWPATCH ", stdout);
15678 if (option->info & OHW_R4KEOP)
15679 fputs (" R4KEOP", stdout);
15680 if (option->info & OHW_R8KPFETCH)
15681 fputs (" R8KPFETCH", stdout);
15682 if (option->info & OHW_R5KEOP)
15683 fputs (" R5KEOP", stdout);
15684 if (option->info & OHW_R5KCVTL)
15685 fputs (" R5KCVTL", stdout);
15688 fputs (" FILL ", stdout);
15689 /* XXX Print content of info word? */
15692 fputs (" TAGS ", stdout);
15693 /* XXX Print content of info word? */
15696 fputs (" HWAND ", stdout);
15697 if (option->info & OHWA0_R4KEOP_CHECKED)
15698 fputs (" R4KEOP_CHECKED", stdout);
15699 if (option->info & OHWA0_R4KEOP_CLEAN)
15700 fputs (" R4KEOP_CLEAN", stdout);
15703 fputs (" HWOR ", stdout);
15704 if (option->info & OHWA0_R4KEOP_CHECKED)
15705 fputs (" R4KEOP_CHECKED", stdout);
15706 if (option->info & OHWA0_R4KEOP_CLEAN)
15707 fputs (" R4KEOP_CLEAN", stdout);
15710 printf (" GP_GROUP %#06lx self-contained %#06lx",
15711 option->info & OGP_GROUP,
15712 (option->info & OGP_SELF) >> 16);
15715 printf (" IDENT %#06lx self-contained %#06lx",
15716 option->info & OGP_GROUP,
15717 (option->info & OGP_SELF) >> 16);
15720 /* This shouldn't happen. */
15721 printf (" %3d ??? %d %lx",
15722 option->kind, option->section, option->info);
15726 len = sizeof (* eopt);
15727 while (len < option->size)
15729 unsigned char datum = * ((unsigned char *) eopt + offset + len);
15731 if (ISPRINT (datum))
15732 printf ("%c", datum);
15734 printf ("\\%03o", datum);
15737 fputs ("\n", stdout);
15739 offset += option->size;
15749 if (conflicts_offset != 0 && conflictsno != 0)
15751 Elf32_Conflict * iconf;
15754 if (dynamic_symbols == NULL)
15756 error (_("conflict list found without a dynamic symbol table\n"));
15760 /* PR 21345 - print a slightly more helpful error message
15761 if we are sure that the cmalloc will fail. */
15762 if (conflictsno * sizeof (* iconf) > current_file_size)
15764 error (_("Overlarge number of conflicts detected: %lx\n"),
15765 (long) conflictsno);
15769 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15772 error (_("Out of memory allocating space for dynamic conflicts\n"));
15778 Elf32_External_Conflict * econf32;
15780 econf32 = (Elf32_External_Conflict *)
15781 get_data (NULL, file, conflicts_offset, conflictsno,
15782 sizeof (* econf32), _("conflict"));
15786 for (cnt = 0; cnt < conflictsno; ++cnt)
15787 iconf[cnt] = BYTE_GET (econf32[cnt]);
15793 Elf64_External_Conflict * econf64;
15795 econf64 = (Elf64_External_Conflict *)
15796 get_data (NULL, file, conflicts_offset, conflictsno,
15797 sizeof (* econf64), _("conflict"));
15801 for (cnt = 0; cnt < conflictsno; ++cnt)
15802 iconf[cnt] = BYTE_GET (econf64[cnt]);
15807 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15808 (unsigned long) conflictsno);
15809 puts (_(" Num: Index Value Name"));
15811 for (cnt = 0; cnt < conflictsno; ++cnt)
15813 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
15815 if (iconf[cnt] >= num_dynamic_syms)
15816 printf (_("<corrupt symbol index>"));
15819 Elf_Internal_Sym * psym;
15821 psym = & dynamic_symbols[iconf[cnt]];
15822 print_vma (psym->st_value, FULL_HEX);
15824 if (VALID_DYNAMIC_NAME (psym->st_name))
15825 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15827 printf (_("<corrupt: %14ld>"), psym->st_name);
15835 if (pltgot != 0 && local_gotno != 0)
15837 bfd_vma ent, local_end, global_end;
15839 unsigned char * data;
15840 unsigned char * data_end;
15844 addr_size = (is_32bit_elf ? 4 : 8);
15845 local_end = pltgot + local_gotno * addr_size;
15847 /* PR binutils/17533 file: 012-111227-0.004 */
15848 if (symtabno < gotsym)
15850 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15851 (unsigned long) gotsym, (unsigned long) symtabno);
15855 global_end = local_end + (symtabno - gotsym) * addr_size;
15856 /* PR 17531: file: 54c91a34. */
15857 if (global_end < local_end)
15859 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15863 offset = offset_from_vma (file, pltgot, global_end - pltgot);
15864 data = (unsigned char *) get_data (NULL, file, offset,
15865 global_end - pltgot, 1,
15866 _("Global Offset Table data"));
15867 /* PR 12855: Null data is handled gracefully throughout. */
15868 data_end = data + (global_end - pltgot);
15870 printf (_("\nPrimary GOT:\n"));
15871 printf (_(" Canonical gp value: "));
15872 print_vma (pltgot + 0x7ff0, LONG_HEX);
15875 printf (_(" Reserved entries:\n"));
15876 printf (_(" %*s %10s %*s Purpose\n"),
15877 addr_size * 2, _("Address"), _("Access"),
15878 addr_size * 2, _("Initial"));
15879 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15880 printf (_(" Lazy resolver\n"));
15881 if (ent == (bfd_vma) -1)
15882 goto got_print_fail;
15884 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15885 This entry will be used by some runtime loaders, to store the
15886 module pointer. Otherwise this is an ordinary local entry.
15887 PR 21344: Check for the entry being fully available before
15890 && data + ent - pltgot + addr_size <= data_end
15891 && (byte_get (data + ent - pltgot, addr_size)
15892 >> (addr_size * 8 - 1)) != 0)
15894 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15895 printf (_(" Module pointer (GNU extension)\n"));
15896 if (ent == (bfd_vma) -1)
15897 goto got_print_fail;
15901 if (data != NULL && ent < local_end)
15903 printf (_(" Local entries:\n"));
15904 printf (" %*s %10s %*s\n",
15905 addr_size * 2, _("Address"), _("Access"),
15906 addr_size * 2, _("Initial"));
15907 while (ent < local_end)
15909 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15911 if (ent == (bfd_vma) -1)
15912 goto got_print_fail;
15917 if (data != NULL && gotsym < symtabno)
15921 printf (_(" Global entries:\n"));
15922 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15923 addr_size * 2, _("Address"),
15925 addr_size * 2, _("Initial"),
15926 addr_size * 2, _("Sym.Val."),
15928 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15929 _("Ndx"), _("Name"));
15931 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15933 for (i = gotsym; i < symtabno; i++)
15935 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15938 if (dynamic_symbols == NULL)
15939 printf (_("<no dynamic symbols>"));
15940 else if (i < num_dynamic_syms)
15942 Elf_Internal_Sym * psym = dynamic_symbols + i;
15944 print_vma (psym->st_value, LONG_HEX);
15945 printf (" %-7s %3s ",
15946 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15947 get_symbol_index_type (psym->st_shndx));
15949 if (VALID_DYNAMIC_NAME (psym->st_name))
15950 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15952 printf (_("<corrupt: %14ld>"), psym->st_name);
15955 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15956 (unsigned long) i);
15959 if (ent == (bfd_vma) -1)
15970 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15973 size_t offset, rel_offset;
15974 unsigned long count, i;
15975 unsigned char * data;
15976 int addr_size, sym_width;
15977 Elf_Internal_Rela * rels;
15979 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15980 if (pltrel == DT_RELA)
15982 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15987 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15992 addr_size = (is_32bit_elf ? 4 : 8);
15993 end = mips_pltgot + (2 + count) * addr_size;
15995 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15996 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15997 1, _("Procedure Linkage Table data"));
16001 printf ("\nPLT GOT:\n\n");
16002 printf (_(" Reserved entries:\n"));
16003 printf (_(" %*s %*s Purpose\n"),
16004 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16005 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16006 printf (_(" PLT lazy resolver\n"));
16007 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16008 printf (_(" Module pointer\n"));
16011 printf (_(" Entries:\n"));
16012 printf (" %*s %*s %*s %-7s %3s %s\n",
16013 addr_size * 2, _("Address"),
16014 addr_size * 2, _("Initial"),
16015 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16016 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16017 for (i = 0; i < count; i++)
16019 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16021 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16024 if (idx >= num_dynamic_syms)
16025 printf (_("<corrupt symbol index: %lu>"), idx);
16028 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16030 print_vma (psym->st_value, LONG_HEX);
16031 printf (" %-7s %3s ",
16032 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
16033 get_symbol_index_type (psym->st_shndx));
16034 if (VALID_DYNAMIC_NAME (psym->st_name))
16035 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16037 printf (_("<corrupt: %14ld>"), psym->st_name);
16052 process_nds32_specific (FILE * file)
16054 Elf_Internal_Shdr *sect = NULL;
16056 sect = find_section (".nds32_e_flags");
16059 unsigned int *flag;
16061 printf ("\nNDS32 elf flags section:\n");
16062 flag = get_data (NULL, file, sect->sh_offset, 1,
16063 sect->sh_size, _("NDS32 elf flags section"));
16068 switch ((*flag) & 0x3)
16071 printf ("(VEC_SIZE):\tNo entry.\n");
16074 printf ("(VEC_SIZE):\t4 bytes\n");
16077 printf ("(VEC_SIZE):\t16 bytes\n");
16080 printf ("(VEC_SIZE):\treserved\n");
16089 process_gnu_liblist (FILE * file)
16091 Elf_Internal_Shdr * section;
16092 Elf_Internal_Shdr * string_sec;
16093 Elf32_External_Lib * elib;
16095 size_t strtab_size;
16098 bfd_boolean res = TRUE;
16103 for (i = 0, section = section_headers;
16104 i < elf_header.e_shnum;
16107 switch (section->sh_type)
16109 case SHT_GNU_LIBLIST:
16110 if (section->sh_link >= elf_header.e_shnum)
16113 elib = (Elf32_External_Lib *)
16114 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
16115 _("liblist section data"));
16123 string_sec = section_headers + section->sh_link;
16124 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
16125 string_sec->sh_size,
16126 _("liblist string table"));
16128 || section->sh_entsize != sizeof (Elf32_External_Lib))
16135 strtab_size = string_sec->sh_size;
16137 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16138 printable_section_name (section),
16139 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
16141 puts (_(" Library Time Stamp Checksum Version Flags"));
16143 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16151 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16152 atime = BYTE_GET (elib[cnt].l_time_stamp);
16153 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16154 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16155 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16157 tmp = gmtime (&atime);
16158 snprintf (timebuf, sizeof (timebuf),
16159 "%04u-%02u-%02uT%02u:%02u:%02u",
16160 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16161 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16163 printf ("%3lu: ", (unsigned long) cnt);
16165 printf ("%-20s", liblist.l_name < strtab_size
16166 ? strtab + liblist.l_name : _("<corrupt>"));
16168 printf ("%-20.20s", liblist.l_name < strtab_size
16169 ? strtab + liblist.l_name : _("<corrupt>"));
16170 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16171 liblist.l_version, liblist.l_flags);
16182 static const char *
16183 get_note_type (unsigned e_type)
16185 static char buff[64];
16187 if (elf_header.e_type == ET_CORE)
16191 return _("NT_AUXV (auxiliary vector)");
16193 return _("NT_PRSTATUS (prstatus structure)");
16195 return _("NT_FPREGSET (floating point registers)");
16197 return _("NT_PRPSINFO (prpsinfo structure)");
16198 case NT_TASKSTRUCT:
16199 return _("NT_TASKSTRUCT (task structure)");
16201 return _("NT_PRXFPREG (user_xfpregs structure)");
16203 return _("NT_PPC_VMX (ppc Altivec registers)");
16205 return _("NT_PPC_VSX (ppc VSX registers)");
16207 return _("NT_PPC_TAR (ppc TAR register)");
16209 return _("NT_PPC_PPR (ppc PPR register)");
16211 return _("NT_PPC_DSCR (ppc DSCR register)");
16213 return _("NT_PPC_EBB (ppc EBB registers)");
16215 return _("NT_PPC_PMU (ppc PMU registers)");
16216 case NT_PPC_TM_CGPR:
16217 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16218 case NT_PPC_TM_CFPR:
16219 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16220 case NT_PPC_TM_CVMX:
16221 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16222 case NT_PPC_TM_CVSX:
16223 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16224 case NT_PPC_TM_SPR:
16225 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16226 case NT_PPC_TM_CTAR:
16227 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16228 case NT_PPC_TM_CPPR:
16229 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16230 case NT_PPC_TM_CDSCR:
16231 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16233 return _("NT_386_TLS (x86 TLS information)");
16234 case NT_386_IOPERM:
16235 return _("NT_386_IOPERM (x86 I/O permissions)");
16236 case NT_X86_XSTATE:
16237 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16238 case NT_S390_HIGH_GPRS:
16239 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16240 case NT_S390_TIMER:
16241 return _("NT_S390_TIMER (s390 timer register)");
16242 case NT_S390_TODCMP:
16243 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16244 case NT_S390_TODPREG:
16245 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16247 return _("NT_S390_CTRS (s390 control registers)");
16248 case NT_S390_PREFIX:
16249 return _("NT_S390_PREFIX (s390 prefix register)");
16250 case NT_S390_LAST_BREAK:
16251 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16252 case NT_S390_SYSTEM_CALL:
16253 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16255 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16256 case NT_S390_VXRS_LOW:
16257 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16258 case NT_S390_VXRS_HIGH:
16259 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16260 case NT_S390_GS_CB:
16261 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16262 case NT_S390_GS_BC:
16263 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16265 return _("NT_ARM_VFP (arm VFP registers)");
16267 return _("NT_ARM_TLS (AArch TLS registers)");
16268 case NT_ARM_HW_BREAK:
16269 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16270 case NT_ARM_HW_WATCH:
16271 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16273 return _("NT_PSTATUS (pstatus structure)");
16275 return _("NT_FPREGS (floating point registers)");
16277 return _("NT_PSINFO (psinfo structure)");
16279 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16281 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16282 case NT_WIN32PSTATUS:
16283 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16285 return _("NT_SIGINFO (siginfo_t data)");
16287 return _("NT_FILE (mapped files)");
16295 return _("NT_VERSION (version)");
16297 return _("NT_ARCH (architecture)");
16298 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16299 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16300 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16301 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16306 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16311 print_core_note (Elf_Internal_Note *pnote)
16313 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16314 bfd_vma count, page_size;
16315 unsigned char *descdata, *filenames, *descend;
16317 if (pnote->type != NT_FILE)
16327 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16328 /* Still "successful". */
16333 if (pnote->descsz < 2 * addr_size)
16335 error (_(" Malformed note - too short for header\n"));
16339 descdata = (unsigned char *) pnote->descdata;
16340 descend = descdata + pnote->descsz;
16342 if (descdata[pnote->descsz - 1] != '\0')
16344 error (_(" Malformed note - does not end with \\0\n"));
16348 count = byte_get (descdata, addr_size);
16349 descdata += addr_size;
16351 page_size = byte_get (descdata, addr_size);
16352 descdata += addr_size;
16354 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16355 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16357 error (_(" Malformed note - too short for supplied file count\n"));
16361 printf (_(" Page size: "));
16362 print_vma (page_size, DEC);
16365 printf (_(" %*s%*s%*s\n"),
16366 (int) (2 + 2 * addr_size), _("Start"),
16367 (int) (4 + 2 * addr_size), _("End"),
16368 (int) (4 + 2 * addr_size), _("Page Offset"));
16369 filenames = descdata + count * 3 * addr_size;
16370 while (count-- > 0)
16372 bfd_vma start, end, file_ofs;
16374 if (filenames == descend)
16376 error (_(" Malformed note - filenames end too early\n"));
16380 start = byte_get (descdata, addr_size);
16381 descdata += addr_size;
16382 end = byte_get (descdata, addr_size);
16383 descdata += addr_size;
16384 file_ofs = byte_get (descdata, addr_size);
16385 descdata += addr_size;
16388 print_vma (start, FULL_HEX);
16390 print_vma (end, FULL_HEX);
16392 print_vma (file_ofs, FULL_HEX);
16393 printf ("\n %s\n", filenames);
16395 filenames += 1 + strlen ((char *) filenames);
16401 static const char *
16402 get_gnu_elf_note_type (unsigned e_type)
16404 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16407 case NT_GNU_ABI_TAG:
16408 return _("NT_GNU_ABI_TAG (ABI version tag)");
16410 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16411 case NT_GNU_BUILD_ID:
16412 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16413 case NT_GNU_GOLD_VERSION:
16414 return _("NT_GNU_GOLD_VERSION (gold version)");
16415 case NT_GNU_PROPERTY_TYPE_0:
16416 return _("NT_GNU_PROPERTY_TYPE_0");
16417 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16418 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16419 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16420 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16423 static char buff[64];
16425 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16432 decode_x86_isa (unsigned int bitmask)
16436 unsigned int bit = bitmask & (- bitmask);
16441 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16442 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16443 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16444 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16445 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16446 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16447 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16448 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16449 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16450 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16451 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16452 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16453 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16454 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16455 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16456 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16457 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16458 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16459 default: printf (_("<unknown: %x>"), bit); break;
16467 decode_x86_feature (unsigned int type, unsigned int bitmask)
16471 unsigned int bit = bitmask & (- bitmask);
16476 case GNU_PROPERTY_X86_FEATURE_1_IBT:
16479 case GNU_PROPERTY_X86_FEATURE_1_AND:
16483 /* This should never happen. */
16487 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16490 case GNU_PROPERTY_X86_FEATURE_1_AND:
16494 /* This should never happen. */
16499 printf (_("<unknown: %x>"), bit);
16508 print_gnu_property_note (Elf_Internal_Note * pnote)
16510 unsigned char * ptr = (unsigned char *) pnote->descdata;
16511 unsigned char * ptr_end = ptr + pnote->descsz;
16512 unsigned int size = is_32bit_elf ? 4 : 8;
16514 printf (_(" Properties: "));
16516 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16518 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16522 while (ptr < ptr_end)
16526 unsigned int datasz;
16528 if ((size_t) (ptr_end - ptr) < 8)
16530 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16534 type = byte_get (ptr, 4);
16535 datasz = byte_get (ptr + 4, 4);
16539 if (datasz > (size_t) (ptr_end - ptr))
16541 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16546 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16548 if (elf_header.e_machine == EM_X86_64
16549 || elf_header.e_machine == EM_IAMCU
16550 || elf_header.e_machine == EM_386)
16554 case GNU_PROPERTY_X86_ISA_1_USED:
16555 printf ("x86 ISA used: ");
16557 printf (_("<corrupt length: %#x> "), datasz);
16559 decode_x86_isa (byte_get (ptr, 4));
16562 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16563 printf ("x86 ISA needed: ");
16565 printf (_("<corrupt length: %#x> "), datasz);
16567 decode_x86_isa (byte_get (ptr, 4));
16570 case GNU_PROPERTY_X86_FEATURE_1_AND:
16571 printf ("x86 feature: ");
16573 printf (_("<corrupt length: %#x> "), datasz);
16575 decode_x86_feature (type, byte_get (ptr, 4));
16587 case GNU_PROPERTY_STACK_SIZE:
16588 printf (_("stack size: "));
16589 if (datasz != size)
16590 printf (_("<corrupt length: %#x> "), datasz);
16592 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16595 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16596 printf ("no copy on protected ");
16598 printf (_("<corrupt length: %#x> "), datasz);
16606 if (type < GNU_PROPERTY_LOPROC)
16607 printf (_("<unknown type %#x data: "), type);
16608 else if (type < GNU_PROPERTY_LOUSER)
16609 printf (_("<procesor-specific type %#x data: "), type);
16611 printf (_("<application-specific type %#x data: "), type);
16612 for (j = 0; j < datasz; ++j)
16613 printf ("%02x ", ptr[j] & 0xff);
16617 ptr += ((datasz + (size - 1)) & ~ (size - 1));
16618 if (ptr == ptr_end)
16631 print_gnu_note (Elf_Internal_Note *pnote)
16633 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16634 switch (pnote->type)
16636 case NT_GNU_BUILD_ID:
16640 printf (_(" Build ID: "));
16641 for (i = 0; i < pnote->descsz; ++i)
16642 printf ("%02x", pnote->descdata[i] & 0xff);
16647 case NT_GNU_ABI_TAG:
16649 unsigned long os, major, minor, subminor;
16650 const char *osname;
16652 /* PR 17531: file: 030-599401-0.004. */
16653 if (pnote->descsz < 16)
16655 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16659 os = byte_get ((unsigned char *) pnote->descdata, 4);
16660 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16661 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16662 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16666 case GNU_ABI_TAG_LINUX:
16669 case GNU_ABI_TAG_HURD:
16672 case GNU_ABI_TAG_SOLARIS:
16673 osname = "Solaris";
16675 case GNU_ABI_TAG_FREEBSD:
16676 osname = "FreeBSD";
16678 case GNU_ABI_TAG_NETBSD:
16681 case GNU_ABI_TAG_SYLLABLE:
16682 osname = "Syllable";
16684 case GNU_ABI_TAG_NACL:
16688 osname = "Unknown";
16692 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16693 major, minor, subminor);
16697 case NT_GNU_GOLD_VERSION:
16701 printf (_(" Version: "));
16702 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16703 printf ("%c", pnote->descdata[i]);
16710 unsigned long num_entries, mask;
16712 /* Hardware capabilities information. Word 0 is the number of entries.
16713 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16714 is a series of entries, where each entry is a single byte followed
16715 by a nul terminated string. The byte gives the bit number to test
16716 if enabled in the bitmask. */
16717 printf (_(" Hardware Capabilities: "));
16718 if (pnote->descsz < 8)
16720 error (_("<corrupt GNU_HWCAP>\n"));
16723 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16724 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16725 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16726 /* FIXME: Add code to display the entries... */
16730 case NT_GNU_PROPERTY_TYPE_0:
16731 print_gnu_property_note (pnote);
16735 /* Handle unrecognised types. An error message should have already been
16736 created by get_gnu_elf_note_type(), so all that we need to do is to
16737 display the data. */
16741 printf (_(" Description data: "));
16742 for (i = 0; i < pnote->descsz; ++i)
16743 printf ("%02x ", pnote->descdata[i] & 0xff);
16752 static const char *
16753 get_v850_elf_note_type (enum v850_notes n_type)
16755 static char buff[64];
16759 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
16760 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
16761 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
16762 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
16763 case V850_NOTE_CACHE_INFO: return _("Use of cache");
16764 case V850_NOTE_MMU_INFO: return _("Use of MMU");
16766 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16772 print_v850_note (Elf_Internal_Note * pnote)
16776 if (pnote->descsz != 4)
16779 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16783 printf (_("not set\n"));
16787 switch (pnote->type)
16789 case V850_NOTE_ALIGNMENT:
16792 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16793 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16797 case V850_NOTE_DATA_SIZE:
16800 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16801 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16805 case V850_NOTE_FPU_INFO:
16808 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16809 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16813 case V850_NOTE_MMU_INFO:
16814 case V850_NOTE_CACHE_INFO:
16815 case V850_NOTE_SIMD_INFO:
16816 if (val == EF_RH850_SIMD)
16818 printf (_("yes\n"));
16824 /* An 'unknown note type' message will already have been displayed. */
16828 printf (_("unknown value: %x\n"), val);
16833 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16835 unsigned int version;
16837 switch (pnote->type)
16839 case NT_NETBSD_IDENT:
16840 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16841 if ((version / 10000) % 100)
16842 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16843 version, version / 100000000, (version / 1000000) % 100,
16844 (version / 10000) % 100 > 26 ? "Z" : "",
16845 'A' + (version / 10000) % 26);
16847 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16848 version, version / 100000000, (version / 1000000) % 100,
16849 (version / 100) % 100);
16852 case NT_NETBSD_MARCH:
16853 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16858 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16864 static const char *
16865 get_freebsd_elfcore_note_type (unsigned e_type)
16869 case NT_FREEBSD_THRMISC:
16870 return _("NT_THRMISC (thrmisc structure)");
16871 case NT_FREEBSD_PROCSTAT_PROC:
16872 return _("NT_PROCSTAT_PROC (proc data)");
16873 case NT_FREEBSD_PROCSTAT_FILES:
16874 return _("NT_PROCSTAT_FILES (files data)");
16875 case NT_FREEBSD_PROCSTAT_VMMAP:
16876 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16877 case NT_FREEBSD_PROCSTAT_GROUPS:
16878 return _("NT_PROCSTAT_GROUPS (groups data)");
16879 case NT_FREEBSD_PROCSTAT_UMASK:
16880 return _("NT_PROCSTAT_UMASK (umask data)");
16881 case NT_FREEBSD_PROCSTAT_RLIMIT:
16882 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16883 case NT_FREEBSD_PROCSTAT_OSREL:
16884 return _("NT_PROCSTAT_OSREL (osreldate data)");
16885 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16886 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16887 case NT_FREEBSD_PROCSTAT_AUXV:
16888 return _("NT_PROCSTAT_AUXV (auxv data)");
16889 case NT_FREEBSD_PTLWPINFO:
16890 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16892 return get_note_type (e_type);
16895 static const char *
16896 get_netbsd_elfcore_note_type (unsigned e_type)
16898 static char buff[64];
16900 if (e_type == NT_NETBSDCORE_PROCINFO)
16902 /* NetBSD core "procinfo" structure. */
16903 return _("NetBSD procinfo structure");
16906 /* As of Jan 2002 there are no other machine-independent notes
16907 defined for NetBSD core files. If the note type is less
16908 than the start of the machine-dependent note types, we don't
16911 if (e_type < NT_NETBSDCORE_FIRSTMACH)
16913 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16917 switch (elf_header.e_machine)
16919 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16920 and PT_GETFPREGS == mach+2. */
16925 case EM_SPARC32PLUS:
16929 case NT_NETBSDCORE_FIRSTMACH + 0:
16930 return _("PT_GETREGS (reg structure)");
16931 case NT_NETBSDCORE_FIRSTMACH + 2:
16932 return _("PT_GETFPREGS (fpreg structure)");
16938 /* On all other arch's, PT_GETREGS == mach+1 and
16939 PT_GETFPREGS == mach+3. */
16943 case NT_NETBSDCORE_FIRSTMACH + 1:
16944 return _("PT_GETREGS (reg structure)");
16945 case NT_NETBSDCORE_FIRSTMACH + 3:
16946 return _("PT_GETFPREGS (fpreg structure)");
16952 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16953 e_type - NT_NETBSDCORE_FIRSTMACH);
16957 static const char *
16958 get_stapsdt_note_type (unsigned e_type)
16960 static char buff[64];
16965 return _("NT_STAPSDT (SystemTap probe descriptors)");
16971 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16976 print_stapsdt_note (Elf_Internal_Note *pnote)
16978 int addr_size = is_32bit_elf ? 4 : 8;
16979 char *data = pnote->descdata;
16980 char *data_end = pnote->descdata + pnote->descsz;
16981 bfd_vma pc, base_addr, semaphore;
16982 char *provider, *probe, *arg_fmt;
16984 pc = byte_get ((unsigned char *) data, addr_size);
16986 base_addr = byte_get ((unsigned char *) data, addr_size);
16988 semaphore = byte_get ((unsigned char *) data, addr_size);
16992 data += strlen (data) + 1;
16994 data += strlen (data) + 1;
16996 data += strlen (data) + 1;
16998 printf (_(" Provider: %s\n"), provider);
16999 printf (_(" Name: %s\n"), probe);
17000 printf (_(" Location: "));
17001 print_vma (pc, FULL_HEX);
17002 printf (_(", Base: "));
17003 print_vma (base_addr, FULL_HEX);
17004 printf (_(", Semaphore: "));
17005 print_vma (semaphore, FULL_HEX);
17007 printf (_(" Arguments: %s\n"), arg_fmt);
17009 return data == data_end;
17012 static const char *
17013 get_ia64_vms_note_type (unsigned e_type)
17015 static char buff[64];
17020 return _("NT_VMS_MHD (module header)");
17022 return _("NT_VMS_LNM (language name)");
17024 return _("NT_VMS_SRC (source files)");
17026 return "NT_VMS_TITLE";
17028 return _("NT_VMS_EIDC (consistency check)");
17029 case NT_VMS_FPMODE:
17030 return _("NT_VMS_FPMODE (FP mode)");
17031 case NT_VMS_LINKTIME:
17032 return "NT_VMS_LINKTIME";
17033 case NT_VMS_IMGNAM:
17034 return _("NT_VMS_IMGNAM (image name)");
17036 return _("NT_VMS_IMGID (image id)");
17037 case NT_VMS_LINKID:
17038 return _("NT_VMS_LINKID (link id)");
17039 case NT_VMS_IMGBID:
17040 return _("NT_VMS_IMGBID (build id)");
17041 case NT_VMS_GSTNAM:
17042 return _("NT_VMS_GSTNAM (sym table name)");
17043 case NT_VMS_ORIG_DYN:
17044 return "NT_VMS_ORIG_DYN";
17045 case NT_VMS_PATCHTIME:
17046 return "NT_VMS_PATCHTIME";
17048 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17054 print_ia64_vms_note (Elf_Internal_Note * pnote)
17056 switch (pnote->type)
17059 if (pnote->descsz > 36)
17061 size_t l = strlen (pnote->descdata + 34);
17062 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17063 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17064 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17065 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17068 printf (_(" Invalid size\n"));
17071 printf (_(" Language: %s\n"), pnote->descdata);
17074 case NT_VMS_FPMODE:
17075 printf (_(" Floating Point mode: "));
17076 printf ("0x%016" BFD_VMA_FMT "x\n",
17077 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17079 case NT_VMS_LINKTIME:
17080 printf (_(" Link time: "));
17082 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17085 case NT_VMS_PATCHTIME:
17086 printf (_(" Patch time: "));
17088 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17091 case NT_VMS_ORIG_DYN:
17092 printf (_(" Major id: %u, minor id: %u\n"),
17093 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17094 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17095 printf (_(" Last modified : "));
17097 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17098 printf (_("\n Link flags : "));
17099 printf ("0x%016" BFD_VMA_FMT "x\n",
17100 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17101 printf (_(" Header flags: 0x%08x\n"),
17102 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17103 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17106 case NT_VMS_IMGNAM:
17107 printf (_(" Image name: %s\n"), pnote->descdata);
17109 case NT_VMS_GSTNAM:
17110 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17113 printf (_(" Image id: %s\n"), pnote->descdata);
17115 case NT_VMS_LINKID:
17116 printf (_(" Linker id: %s\n"), pnote->descdata);
17124 /* Print the name of the symbol associated with a build attribute
17125 that is attached to address OFFSET. */
17128 print_symbol_for_build_attribute (FILE * file,
17129 unsigned long offset,
17130 bfd_boolean is_open_attr)
17132 static FILE * saved_file = NULL;
17133 static char * strtab;
17134 static unsigned long strtablen;
17135 static Elf_Internal_Sym * symtab;
17136 static unsigned long nsyms;
17137 Elf_Internal_Sym * saved_sym = NULL;
17138 Elf_Internal_Sym * sym;
17140 if (section_headers != NULL
17141 && (saved_file == NULL || file != saved_file))
17143 Elf_Internal_Shdr * symsec;
17145 /* Load the symbol and string sections. */
17146 for (symsec = section_headers;
17147 symsec < section_headers + elf_header.e_shnum;
17150 if (symsec->sh_type == SHT_SYMTAB)
17152 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
17154 if (symsec->sh_link < elf_header.e_shnum)
17156 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
17158 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
17159 1, strtab_sec->sh_size,
17160 _("string table"));
17161 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17168 if (symtab == NULL || strtab == NULL)
17174 /* Find a symbol whose value matches offset. */
17175 for (sym = symtab; sym < symtab + nsyms; sym ++)
17176 if (sym->st_value == offset)
17178 if (sym->st_name >= strtablen)
17179 /* Huh ? This should not happen. */
17182 if (strtab[sym->st_name] == 0)
17187 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17188 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17189 FUNC symbols entirely. */
17190 switch (ELF_ST_TYPE (sym->st_info))
17194 /* We can stop searching now. */
17195 sym = symtab + nsyms;
17203 /* Ignore function symbols. */
17210 switch (ELF_ST_BIND (sym->st_info))
17213 if (saved_sym == NULL
17214 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17219 if (saved_sym == NULL)
17229 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17237 printf (" (%s: %s)\n",
17238 is_open_attr ? _("file") : _("func"),
17239 saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17244 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17247 static unsigned long global_offset = 0;
17248 unsigned long offset;
17249 unsigned int desc_size = is_32bit_elf ? 4 : 8;
17250 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17252 if (pnote->descsz == 0)
17256 printf (_(" Applies from offset %#lx\n"), global_offset);
17261 printf (_(" Applies to func at %#lx"), global_offset);
17262 return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
17266 if (pnote->descsz != desc_size)
17268 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
17269 printf (_(" <invalid descsz>"));
17273 offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17277 printf (_(" Applies from offset %#lx"), offset);
17278 global_offset = offset;
17282 printf (_(" Applies to func at %#lx"), offset);
17285 return print_symbol_for_build_attribute (file, offset, is_open_attr);
17289 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17291 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17292 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17293 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17295 char name_attribute;
17296 const char * expected_types;
17297 const char * name = pnote->namedata;
17301 if (name == NULL || pnote->namesz < 2)
17303 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17304 print_symbol (-20, _(" <corrupt name>"));
17310 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17311 if (name[0] == 'G' && name[1] == 'A')
17318 switch ((name_type = * name))
17320 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17321 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17322 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17323 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17324 printf ("%c", * name);
17328 error (_("unrecognised attribute type in name field: %d\n"), name_type);
17329 print_symbol (-20, _("<unknown name type>"));
17336 switch ((name_attribute = * name))
17338 case GNU_BUILD_ATTRIBUTE_VERSION:
17339 text = _("<version>");
17340 expected_types = string_expected;
17343 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17344 text = _("<stack prot>");
17345 expected_types = "!+*";
17348 case GNU_BUILD_ATTRIBUTE_RELRO:
17349 text = _("<relro>");
17350 expected_types = bool_expected;
17353 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17354 text = _("<stack size>");
17355 expected_types = number_expected;
17358 case GNU_BUILD_ATTRIBUTE_TOOL:
17359 text = _("<tool>");
17360 expected_types = string_expected;
17363 case GNU_BUILD_ATTRIBUTE_ABI:
17365 expected_types = "$*";
17368 case GNU_BUILD_ATTRIBUTE_PIC:
17370 expected_types = number_expected;
17373 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17374 text = _("<short enum>");
17375 expected_types = bool_expected;
17379 if (ISPRINT (* name))
17381 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17383 if (len > left && ! do_wide)
17385 printf ("%.*s:", len, name);
17391 static char tmpbuf [128];
17393 error (_("unrecognised byte in name field: %d\n"), * name);
17394 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17398 expected_types = "*$!+";
17403 left -= printf ("%s", text);
17405 if (strchr (expected_types, name_type) == NULL)
17406 warn (_("attribute does not have an expected type (%c)\n"), name_type);
17408 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17410 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17411 (unsigned long) pnote->namesz,
17412 (long) (name - pnote->namedata));
17416 if (left < 1 && ! do_wide)
17421 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17423 unsigned int bytes;
17424 unsigned long long val = 0;
17425 unsigned int shift = 0;
17426 char * decoded = NULL;
17428 bytes = pnote->namesz - (name - pnote->namedata);
17430 /* The -1 is because the name field is always 0 terminated, and we
17431 want to be able to ensure that the shift in the while loop below
17432 will not overflow. */
17435 if (bytes > sizeof (val))
17437 fprintf (stderr, "namesz %lx name %p namedata %p\n",
17438 pnote->namesz, name, pnote->namedata);
17439 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17441 bytes = sizeof (val);
17443 /* We do not bother to warn if bytes == 0 as this can
17444 happen with some early versions of the gcc plugin. */
17448 unsigned long byte = (* name ++) & 0xff;
17450 val |= byte << shift;
17454 switch (name_attribute)
17456 case GNU_BUILD_ATTRIBUTE_PIC:
17459 case 0: decoded = "static"; break;
17460 case 1: decoded = "pic"; break;
17461 case 2: decoded = "PIC"; break;
17462 case 3: decoded = "pie"; break;
17463 case 4: decoded = "PIE"; break;
17467 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17470 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17471 case 0: decoded = "off"; break;
17472 case 1: decoded = "on"; break;
17473 case 2: decoded = "all"; break;
17474 case 3: decoded = "strong"; break;
17475 case 4: decoded = "explicit"; break;
17483 if (decoded != NULL)
17485 print_symbol (-left, decoded);
17496 left -= printf ("0x%llx", val);
17498 left -= printf ("0x%-.*llx", left, val);
17502 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17503 left -= print_symbol (- left, name);
17505 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17506 left -= print_symbol (- left, "true");
17508 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17509 left -= print_symbol (- left, "false");
17513 if (do_wide && left > 0)
17514 printf ("%-*s", left, " ");
17519 /* Note that by the ELF standard, the name field is already null byte
17520 terminated, and namesz includes the terminating null byte.
17521 I.E. the value of namesz for the name "FSF" is 4.
17523 If the value of namesz is zero, there is no name present. */
17526 process_note (Elf_Internal_Note * pnote,
17529 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17532 if (pnote->namesz == 0)
17533 /* If there is no note name, then use the default set of
17534 note type strings. */
17535 nt = get_note_type (pnote->type);
17537 else if (const_strneq (pnote->namedata, "GNU"))
17538 /* GNU-specific object file notes. */
17539 nt = get_gnu_elf_note_type (pnote->type);
17541 else if (const_strneq (pnote->namedata, "FreeBSD"))
17542 /* FreeBSD-specific core file notes. */
17543 nt = get_freebsd_elfcore_note_type (pnote->type);
17545 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17546 /* NetBSD-specific core file notes. */
17547 nt = get_netbsd_elfcore_note_type (pnote->type);
17549 else if (const_strneq (pnote->namedata, "NetBSD"))
17550 /* NetBSD-specific core file notes. */
17551 return process_netbsd_elf_note (pnote);
17553 else if (strneq (pnote->namedata, "SPU/", 4))
17555 /* SPU-specific core file notes. */
17556 nt = pnote->namedata + 4;
17560 else if (const_strneq (pnote->namedata, "IPF/VMS"))
17561 /* VMS/ia64-specific file notes. */
17562 nt = get_ia64_vms_note_type (pnote->type);
17564 else if (const_strneq (pnote->namedata, "stapsdt"))
17565 nt = get_stapsdt_note_type (pnote->type);
17568 /* Don't recognize this note name; just use the default set of
17569 note type strings. */
17570 nt = get_note_type (pnote->type);
17574 if (((const_strneq (pnote->namedata, "GA")
17575 && strchr ("*$!+", pnote->namedata[2]) != NULL)
17576 || strchr ("*$!+", pnote->namedata[0]) != NULL)
17577 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17578 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17579 print_gnu_build_attribute_name (pnote);
17581 print_symbol (-20, name);
17584 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17586 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17588 if (const_strneq (pnote->namedata, "IPF/VMS"))
17589 return print_ia64_vms_note (pnote);
17590 else if (const_strneq (pnote->namedata, "GNU"))
17591 return print_gnu_note (pnote);
17592 else if (const_strneq (pnote->namedata, "stapsdt"))
17593 return print_stapsdt_note (pnote);
17594 else if (const_strneq (pnote->namedata, "CORE"))
17595 return print_core_note (pnote);
17596 else if (((const_strneq (pnote->namedata, "GA")
17597 && strchr ("*$!+", pnote->namedata[2]) != NULL)
17598 || strchr ("*$!+", pnote->namedata[0]) != NULL)
17599 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17600 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17601 return print_gnu_build_attribute_description (pnote, file);
17607 printf (_(" description data: "));
17608 for (i = 0; i < pnote->descsz; i++)
17609 printf ("%02x ", pnote->descdata[i]);
17621 process_notes_at (FILE * file,
17622 Elf_Internal_Shdr * section,
17626 Elf_External_Note * pnotes;
17627 Elf_External_Note * external;
17629 bfd_boolean res = TRUE;
17636 pnotes = (Elf_External_Note *) get_section_contents (section, file);
17639 if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
17644 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17646 if (pnotes == NULL)
17652 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
17654 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17655 (unsigned long) offset, (unsigned long) length);
17657 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17659 end = (char *) pnotes + length;
17660 while ((char *) external < end)
17662 Elf_Internal_Note inote;
17665 char * temp = NULL;
17666 size_t data_remaining = end - (char *) external;
17668 if (!is_ia64_vms ())
17670 /* PR binutils/15191
17671 Make sure that there is enough data to read. */
17672 min_notesz = offsetof (Elf_External_Note, name);
17673 if (data_remaining < min_notesz)
17675 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17676 (int) data_remaining);
17679 data_remaining -= min_notesz;
17681 inote.type = BYTE_GET (external->type);
17682 inote.namesz = BYTE_GET (external->namesz);
17683 inote.namedata = external->name;
17684 inote.descsz = BYTE_GET (external->descsz);
17685 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17686 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17687 next = inote.descdata + align_power (inote.descsz, 2);
17691 Elf64_External_VMS_Note *vms_external;
17693 /* PR binutils/15191
17694 Make sure that there is enough data to read. */
17695 min_notesz = offsetof (Elf64_External_VMS_Note, name);
17696 if (data_remaining < min_notesz)
17698 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17699 (int) data_remaining);
17702 data_remaining -= min_notesz;
17704 vms_external = (Elf64_External_VMS_Note *) external;
17705 inote.type = BYTE_GET (vms_external->type);
17706 inote.namesz = BYTE_GET (vms_external->namesz);
17707 inote.namedata = vms_external->name;
17708 inote.descsz = BYTE_GET (vms_external->descsz);
17709 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
17710 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17711 next = inote.descdata + align_power (inote.descsz, 3);
17714 /* PR 17531: file: 3443835e. */
17715 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17716 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
17717 || (size_t) (inote.descdata - inote.namedata) > data_remaining
17718 || (size_t) (next - inote.descdata) < inote.descsz
17719 || ((size_t) (next - inote.descdata)
17720 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
17722 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17723 (unsigned long) ((char *) external - (char *) pnotes));
17724 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17725 inote.type, inote.namesz, inote.descsz);
17729 external = (Elf_External_Note *) next;
17731 /* Verify that name is null terminated. It appears that at least
17732 one version of Linux (RedHat 6.0) generates corefiles that don't
17733 comply with the ELF spec by failing to include the null byte in
17735 if (inote.namedata[inote.namesz - 1] != '\0')
17737 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
17739 temp = (char *) malloc (inote.namesz + 1);
17742 error (_("Out of memory allocating space for inote name\n"));
17747 memcpy (temp, inote.namedata, inote.namesz);
17748 inote.namedata = temp;
17750 inote.namedata[inote.namesz] = 0;
17753 if (! process_note (& inote, file))
17769 process_corefile_note_segments (FILE * file)
17771 Elf_Internal_Phdr * segment;
17773 bfd_boolean res = TRUE;
17775 if (! get_program_headers (file))
17778 for (i = 0, segment = program_headers;
17779 i < elf_header.e_phnum;
17782 if (segment->p_type == PT_NOTE)
17783 if (! process_notes_at (file, NULL,
17784 (bfd_vma) segment->p_offset,
17785 (bfd_vma) segment->p_filesz))
17793 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17795 Elf_External_Note * pnotes;
17796 Elf_External_Note * external;
17798 bfd_boolean res = TRUE;
17803 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17805 if (pnotes == NULL)
17809 end = (char*) pnotes + length;
17811 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17812 (unsigned long) offset, (unsigned long) length);
17814 while ((char *) external + sizeof (Elf_External_Note) < end)
17816 Elf_External_Note * next;
17817 Elf_Internal_Note inote;
17819 inote.type = BYTE_GET (external->type);
17820 inote.namesz = BYTE_GET (external->namesz);
17821 inote.namedata = external->name;
17822 inote.descsz = BYTE_GET (external->descsz);
17823 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17824 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17826 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17828 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17829 inote.descdata = inote.namedata;
17833 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17835 if ( ((char *) next > end)
17836 || ((char *) next < (char *) pnotes))
17838 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17839 (unsigned long) ((char *) external - (char *) pnotes));
17840 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17841 inote.type, inote.namesz, inote.descsz);
17847 /* Prevent out-of-bounds indexing. */
17848 if ( inote.namedata + inote.namesz > end
17849 || inote.namedata + inote.namesz < inote.namedata)
17851 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17852 (unsigned long) ((char *) external - (char *) pnotes));
17853 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17854 inote.type, inote.namesz, inote.descsz);
17858 printf (" %s: ", get_v850_elf_note_type (inote.type));
17860 if (! print_v850_note (& inote))
17863 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17864 inote.namesz, inote.descsz);
17874 process_note_sections (FILE * file)
17876 Elf_Internal_Shdr * section;
17878 unsigned int n = 0;
17879 bfd_boolean res = TRUE;
17881 for (i = 0, section = section_headers;
17882 i < elf_header.e_shnum && section != NULL;
17885 if (section->sh_type == SHT_NOTE)
17887 if (! process_notes_at (file, section,
17888 (bfd_vma) section->sh_offset,
17889 (bfd_vma) section->sh_size))
17894 if (( elf_header.e_machine == EM_V800
17895 || elf_header.e_machine == EM_V850
17896 || elf_header.e_machine == EM_CYGNUS_V850)
17897 && section->sh_type == SHT_RENESAS_INFO)
17899 if (! process_v850_notes (file,
17900 (bfd_vma) section->sh_offset,
17901 (bfd_vma) section->sh_size))
17908 /* Try processing NOTE segments instead. */
17909 return process_corefile_note_segments (file);
17915 process_notes (FILE * file)
17917 /* If we have not been asked to display the notes then do nothing. */
17921 if (elf_header.e_type != ET_CORE)
17922 return process_note_sections (file);
17924 /* No program headers means no NOTE segment. */
17925 if (elf_header.e_phnum > 0)
17926 return process_corefile_note_segments (file);
17928 printf (_("No note segments present in the core file.\n"));
17932 static unsigned char *
17933 display_public_gnu_attributes (unsigned char * start,
17934 const unsigned char * const end)
17936 printf (_(" Unknown GNU attribute: %s\n"), start);
17938 start += strnlen ((char *) start, end - start);
17939 display_raw_attribute (start, end);
17941 return (unsigned char *) end;
17944 static unsigned char *
17945 display_generic_attribute (unsigned char * start,
17947 const unsigned char * const end)
17950 return (unsigned char *) end;
17952 return display_tag_value (tag, start, end);
17956 process_arch_specific (FILE * file)
17961 switch (elf_header.e_machine)
17964 case EM_ARC_COMPACT:
17965 case EM_ARC_COMPACT2:
17966 return process_attributes (file, "ARC", SHT_ARC_ATTRIBUTES,
17967 display_arc_attribute,
17968 display_generic_attribute);
17970 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17971 display_arm_attribute,
17972 display_generic_attribute);
17975 case EM_MIPS_RS3_LE:
17976 return process_mips_specific (file);
17979 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17980 display_msp430x_attribute,
17981 display_generic_attribute);
17984 return process_nds32_specific (file);
17988 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17989 display_power_gnu_attribute);
17993 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17994 display_s390_gnu_attribute);
17997 case EM_SPARC32PLUS:
17999 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
18000 display_sparc_gnu_attribute);
18003 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
18004 display_tic6x_attribute,
18005 display_generic_attribute);
18008 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
18009 display_public_gnu_attributes,
18010 display_generic_attribute);
18015 get_file_header (FILE * file)
18017 /* Read in the identity array. */
18018 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
18021 /* Determine how to read the rest of the header. */
18022 switch (elf_header.e_ident[EI_DATA])
18027 byte_get = byte_get_little_endian;
18028 byte_put = byte_put_little_endian;
18031 byte_get = byte_get_big_endian;
18032 byte_put = byte_put_big_endian;
18036 /* For now we only support 32 bit and 64 bit ELF files. */
18037 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
18039 /* Read in the rest of the header. */
18042 Elf32_External_Ehdr ehdr32;
18044 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
18047 elf_header.e_type = BYTE_GET (ehdr32.e_type);
18048 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
18049 elf_header.e_version = BYTE_GET (ehdr32.e_version);
18050 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
18051 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18052 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18053 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
18054 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18055 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18056 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18057 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18058 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18059 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18063 Elf64_External_Ehdr ehdr64;
18065 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18066 we will not be able to cope with the 64bit data found in
18067 64 ELF files. Detect this now and abort before we start
18068 overwriting things. */
18069 if (sizeof (bfd_vma) < 8)
18071 error (_("This instance of readelf has been built without support for a\n\
18072 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18076 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
18079 elf_header.e_type = BYTE_GET (ehdr64.e_type);
18080 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
18081 elf_header.e_version = BYTE_GET (ehdr64.e_version);
18082 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
18083 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18084 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
18085 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
18086 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
18087 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18088 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
18089 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18090 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
18091 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
18094 if (elf_header.e_shoff)
18096 /* There may be some extensions in the first section header. Don't
18097 bomb if we can't read it. */
18099 get_32bit_section_headers (file, TRUE);
18101 get_64bit_section_headers (file, TRUE);
18107 /* Process one ELF object file according to the command line options.
18108 This file may actually be stored in an archive. The file is
18109 positioned at the start of the ELF object. Returns TRUE if no
18110 problems were encountered, FALSE otherwise. */
18113 process_object (char * file_name, FILE * file)
18116 bfd_boolean res = TRUE;
18118 if (! get_file_header (file))
18120 error (_("%s: Failed to read file header\n"), file_name);
18124 /* Initialise per file variables. */
18125 for (i = ARRAY_SIZE (version_info); i--;)
18126 version_info[i] = 0;
18128 for (i = ARRAY_SIZE (dynamic_info); i--;)
18129 dynamic_info[i] = 0;
18130 dynamic_info_DT_GNU_HASH = 0;
18132 /* Process the file. */
18134 printf (_("\nFile: %s\n"), file_name);
18136 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18137 Note we do this even if cmdline_dump_sects is empty because we
18138 must make sure that the dump_sets array is zeroed out before each
18139 object file is processed. */
18140 if (num_dump_sects > num_cmdline_dump_sects)
18141 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
18143 if (num_cmdline_dump_sects > 0)
18145 if (num_dump_sects == 0)
18146 /* A sneaky way of allocating the dump_sects array. */
18147 request_dump_bynumber (num_cmdline_dump_sects, 0);
18149 assert (num_dump_sects >= num_cmdline_dump_sects);
18150 memcpy (dump_sects, cmdline_dump_sects,
18151 num_cmdline_dump_sects * sizeof (* dump_sects));
18154 if (! process_file_header ())
18157 if (! process_section_headers (file))
18159 /* Without loaded section headers we cannot process lots of things. */
18160 do_unwind = do_version = do_dump = do_arch = FALSE;
18162 if (! do_using_dynamic)
18163 do_syms = do_dyn_syms = do_reloc = FALSE;
18166 if (! process_section_groups (file))
18167 /* Without loaded section groups we cannot process unwind. */
18170 if (process_program_headers (file))
18171 process_dynamic_section (file);
18175 if (! process_relocs (file))
18178 if (! process_unwind (file))
18181 if (! process_symbol_table (file))
18184 if (! process_syminfo (file))
18187 if (! process_version_sections (file))
18190 if (! process_section_contents (file))
18193 if (! process_notes (file))
18196 if (! process_gnu_liblist (file))
18199 if (! process_arch_specific (file))
18202 if (program_headers)
18204 free (program_headers);
18205 program_headers = NULL;
18208 if (section_headers)
18210 free (section_headers);
18211 section_headers = NULL;
18216 free (string_table);
18217 string_table = NULL;
18218 string_table_length = 0;
18221 if (dynamic_strings)
18223 free (dynamic_strings);
18224 dynamic_strings = NULL;
18225 dynamic_strings_length = 0;
18228 if (dynamic_symbols)
18230 free (dynamic_symbols);
18231 dynamic_symbols = NULL;
18232 num_dynamic_syms = 0;
18235 if (dynamic_syminfo)
18237 free (dynamic_syminfo);
18238 dynamic_syminfo = NULL;
18241 if (dynamic_section)
18243 free (dynamic_section);
18244 dynamic_section = NULL;
18247 if (section_headers_groups)
18249 free (section_headers_groups);
18250 section_headers_groups = NULL;
18253 if (section_groups)
18255 struct group_list * g;
18256 struct group_list * next;
18258 for (i = 0; i < group_count; i++)
18260 for (g = section_groups [i].root; g != NULL; g = next)
18267 free (section_groups);
18268 section_groups = NULL;
18271 free_debug_memory ();
18276 /* Process an ELF archive.
18277 On entry the file is positioned just after the ARMAG string.
18278 Returns TRUE upon success, FALSE otherwise. */
18281 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
18283 struct archive_info arch;
18284 struct archive_info nested_arch;
18286 bfd_boolean ret = TRUE;
18290 /* The ARCH structure is used to hold information about this archive. */
18291 arch.file_name = NULL;
18293 arch.index_array = NULL;
18294 arch.sym_table = NULL;
18295 arch.longnames = NULL;
18297 /* The NESTED_ARCH structure is used as a single-item cache of information
18298 about a nested archive (when members of a thin archive reside within
18299 another regular archive file). */
18300 nested_arch.file_name = NULL;
18301 nested_arch.file = NULL;
18302 nested_arch.index_array = NULL;
18303 nested_arch.sym_table = NULL;
18304 nested_arch.longnames = NULL;
18306 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
18312 if (do_archive_index)
18314 if (arch.sym_table == NULL)
18315 error (_("%s: unable to dump the index as none was found\n"), file_name);
18318 unsigned long i, l;
18319 unsigned long current_pos;
18321 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18322 file_name, (unsigned long) arch.index_num, arch.sym_size);
18323 current_pos = ftell (file);
18325 for (i = l = 0; i < arch.index_num; i++)
18327 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18329 char * member_name;
18331 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18333 if (member_name != NULL)
18335 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18337 if (qualified_name != NULL)
18339 printf (_("Contents of binary %s at offset "), qualified_name);
18340 (void) print_vma (arch.index_array[i], PREFIX_HEX);
18342 free (qualified_name);
18347 if (l >= arch.sym_size)
18349 error (_("%s: end of the symbol table reached before the end of the index\n"),
18354 /* PR 17531: file: 0b6630b2. */
18355 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18356 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18359 if (arch.uses_64bit_indicies)
18364 if (l < arch.sym_size)
18366 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18367 file_name, arch.sym_size - l);
18371 if (fseek (file, current_pos, SEEK_SET) != 0)
18373 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
18379 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18380 && !do_segments && !do_header && !do_dump && !do_version
18381 && !do_histogram && !do_debugging && !do_arch && !do_notes
18382 && !do_section_groups && !do_dyn_syms)
18384 ret = TRUE; /* Archive index only. */
18393 char * qualified_name;
18395 /* Read the next archive header. */
18396 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
18398 error (_("%s: failed to seek to next archive header\n"), file_name);
18401 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
18402 if (got != sizeof arch.arhdr)
18406 error (_("%s: failed to read archive header\n"), file_name);
18410 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18412 error (_("%s: did not find a valid archive header\n"), arch.file_name);
18417 arch.next_arhdr_offset += sizeof arch.arhdr;
18419 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18420 if (archive_file_size & 01)
18421 ++archive_file_size;
18423 name = get_archive_member_name (&arch, &nested_arch);
18426 error (_("%s: bad archive file name\n"), file_name);
18430 namelen = strlen (name);
18432 qualified_name = make_qualified_name (&arch, &nested_arch, name);
18433 if (qualified_name == NULL)
18435 error (_("%s: bad archive file name\n"), file_name);
18440 if (is_thin_archive && arch.nested_member_origin == 0)
18442 /* This is a proxy for an external member of a thin archive. */
18443 FILE * member_file;
18444 char * member_file_name = adjust_relative_path (file_name, name, namelen);
18446 if (member_file_name == NULL)
18452 member_file = fopen (member_file_name, "rb");
18453 if (member_file == NULL)
18455 error (_("Input file '%s' is not readable.\n"), member_file_name);
18456 free (member_file_name);
18461 archive_file_offset = arch.nested_member_origin;
18463 if (! process_object (qualified_name, member_file))
18466 fclose (member_file);
18467 free (member_file_name);
18469 else if (is_thin_archive)
18471 /* PR 15140: Allow for corrupt thin archives. */
18472 if (nested_arch.file == NULL)
18474 error (_("%s: contains corrupt thin archive: %s\n"),
18480 /* This is a proxy for a member of a nested archive. */
18481 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18483 /* The nested archive file will have been opened and setup by
18484 get_archive_member_name. */
18485 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18487 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18492 if (! process_object (qualified_name, nested_arch.file))
18497 archive_file_offset = arch.next_arhdr_offset;
18498 arch.next_arhdr_offset += archive_file_size;
18500 if (! process_object (qualified_name, file))
18504 if (dump_sects != NULL)
18508 num_dump_sects = 0;
18511 free (qualified_name);
18515 if (nested_arch.file != NULL)
18516 fclose (nested_arch.file);
18517 release_archive (&nested_arch);
18518 release_archive (&arch);
18524 process_file (char * file_name)
18527 struct stat statbuf;
18528 char armag[SARMAG];
18529 bfd_boolean ret = TRUE;
18531 if (stat (file_name, &statbuf) < 0)
18533 if (errno == ENOENT)
18534 error (_("'%s': No such file\n"), file_name);
18536 error (_("Could not locate '%s'. System error message: %s\n"),
18537 file_name, strerror (errno));
18541 if (! S_ISREG (statbuf.st_mode))
18543 error (_("'%s' is not an ordinary file\n"), file_name);
18547 file = fopen (file_name, "rb");
18550 error (_("Input file '%s' is not readable.\n"), file_name);
18554 if (fread (armag, SARMAG, 1, file) != 1)
18556 error (_("%s: Failed to read file's magic number\n"), file_name);
18561 current_file_size = (bfd_size_type) statbuf.st_size;
18563 if (memcmp (armag, ARMAG, SARMAG) == 0)
18565 if (! process_archive (file_name, file, FALSE))
18568 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18570 if ( ! process_archive (file_name, file, TRUE))
18575 if (do_archive_index)
18576 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18580 archive_file_size = archive_file_offset = 0;
18582 if (! process_object (file_name, file))
18587 current_file_size = 0;
18592 #ifdef SUPPORT_DISASSEMBLY
18593 /* Needed by the i386 disassembler. For extra credit, someone could
18594 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18598 print_address (unsigned int addr, FILE * outfile)
18600 fprintf (outfile,"0x%8.8x", addr);
18603 /* Needed by the i386 disassembler. */
18605 db_task_printsym (unsigned int addr)
18607 print_address (addr, stderr);
18612 main (int argc, char ** argv)
18616 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18617 setlocale (LC_MESSAGES, "");
18619 #if defined (HAVE_SETLOCALE)
18620 setlocale (LC_CTYPE, "");
18622 bindtextdomain (PACKAGE, LOCALEDIR);
18623 textdomain (PACKAGE);
18625 expandargv (&argc, &argv);
18627 parse_args (argc, argv);
18629 if (num_dump_sects > 0)
18631 /* Make a copy of the dump_sects array. */
18632 cmdline_dump_sects = (dump_type *)
18633 malloc (num_dump_sects * sizeof (* dump_sects));
18634 if (cmdline_dump_sects == NULL)
18635 error (_("Out of memory allocating dump request table.\n"));
18638 memcpy (cmdline_dump_sects, dump_sects,
18639 num_dump_sects * sizeof (* dump_sects));
18640 num_cmdline_dump_sects = num_dump_sects;
18644 if (optind < (argc - 1))
18646 else if (optind >= argc)
18648 warn (_("Nothing to do.\n"));
18653 while (optind < argc)
18654 if (! process_file (argv[optind++]))
18657 if (dump_sects != NULL)
18659 if (cmdline_dump_sects != NULL)
18660 free (cmdline_dump_sects);
18662 return err ? EXIT_FAILURE : EXIT_SUCCESS;