1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 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/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/riscv.h"
142 #include "elf/rl78.h"
144 #include "elf/s390.h"
145 #include "elf/score.h"
147 #include "elf/sparc.h"
149 #include "elf/tic6x.h"
150 #include "elf/tilegx.h"
151 #include "elf/tilepro.h"
152 #include "elf/v850.h"
154 #include "elf/visium.h"
155 #include "elf/wasm32.h"
156 #include "elf/x86-64.h"
157 #include "elf/xc16x.h"
158 #include "elf/xgate.h"
159 #include "elf/xstormy16.h"
160 #include "elf/xtensa.h"
163 #include "libiberty.h"
164 #include "safe-ctype.h"
165 #include "filenames.h"
168 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
171 typedef struct elf_section_list
173 Elf_Internal_Shdr * hdr;
174 struct elf_section_list * next;
177 /* Flag bits indicating particular types of dump. */
178 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
179 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
180 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
181 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
182 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
184 typedef unsigned char dump_type;
186 /* A linked list of the section names for which dumps were requested. */
187 struct dump_list_entry
191 struct dump_list_entry * next;
194 typedef struct filedata
196 const char * file_name;
198 bfd_size_type file_size;
199 Elf_Internal_Ehdr file_header;
200 Elf_Internal_Shdr * section_headers;
201 Elf_Internal_Phdr * program_headers;
203 unsigned long string_table_length;
204 /* A dynamic array of flags indicating for which sections a dump of
205 some kind has been requested. It is reset on a per-object file
206 basis and then initialised from the cmdline_dump_sects array,
207 the results of interpreting the -w switch, and the
208 dump_sects_byname list. */
209 dump_type * dump_sects;
210 unsigned int num_dump_sects;
213 char * program_name = "readelf";
215 static unsigned long archive_file_offset;
216 static unsigned long archive_file_size;
217 static unsigned long dynamic_addr;
218 static bfd_size_type dynamic_size;
219 static size_t dynamic_nent;
220 static char * dynamic_strings;
221 static unsigned long dynamic_strings_length;
222 static unsigned long num_dynamic_syms;
223 static Elf_Internal_Sym * dynamic_symbols;
224 static Elf_Internal_Syminfo * dynamic_syminfo;
225 static unsigned long dynamic_syminfo_offset;
226 static unsigned int dynamic_syminfo_nent;
227 static char program_interpreter[PATH_MAX];
228 static bfd_vma dynamic_info[DT_ENCODING];
229 static bfd_vma dynamic_info_DT_GNU_HASH;
230 static bfd_vma version_info[16];
231 static Elf_Internal_Dyn * dynamic_section;
232 static elf_section_list * symtab_shndx_list;
233 static bfd_boolean show_name = FALSE;
234 static bfd_boolean do_dynamic = FALSE;
235 static bfd_boolean do_syms = FALSE;
236 static bfd_boolean do_dyn_syms = FALSE;
237 static bfd_boolean do_reloc = FALSE;
238 static bfd_boolean do_sections = FALSE;
239 static bfd_boolean do_section_groups = FALSE;
240 static bfd_boolean do_section_details = FALSE;
241 static bfd_boolean do_segments = FALSE;
242 static bfd_boolean do_unwind = FALSE;
243 static bfd_boolean do_using_dynamic = FALSE;
244 static bfd_boolean do_header = FALSE;
245 static bfd_boolean do_dump = FALSE;
246 static bfd_boolean do_version = FALSE;
247 static bfd_boolean do_histogram = FALSE;
248 static bfd_boolean do_debugging = FALSE;
249 static bfd_boolean do_arch = FALSE;
250 static bfd_boolean do_notes = FALSE;
251 static bfd_boolean do_archive_index = FALSE;
252 static bfd_boolean is_32bit_elf = FALSE;
253 static bfd_boolean decompress_dumps = FALSE;
257 struct group_list * next;
258 unsigned int section_index;
263 struct group_list * root;
264 unsigned int group_index;
267 static size_t group_count;
268 static struct group * section_groups;
269 static struct group ** section_headers_groups;
271 /* A dynamic array of flags indicating for which sections a dump
272 has been requested via command line switches. */
273 static Filedata cmdline;
275 static struct dump_list_entry * dump_sects_byname;
277 /* How to print a vma value. */
278 typedef enum print_mode
290 /* Versioned symbol info. */
291 enum versioned_symbol_info
298 static const char * get_symbol_version_string
299 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
300 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
304 #define SECTION_NAME(X) \
305 ((X) == NULL ? _("<none>") \
306 : filedata->string_table == NULL ? _("<no-strings>") \
307 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
308 : filedata->string_table + (X)->sh_name))
310 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
312 #define GET_ELF_SYMBOLS(file, section, sym_count) \
313 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
314 : get_64bit_elf_symbols (file, section, sym_count))
316 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
317 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
318 already been called and verified that the string exists. */
319 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
321 #define REMOVE_ARCH_BITS(ADDR) \
324 if (filedata->file_header.e_machine == EM_ARM) \
329 /* Print a BFD_VMA to an internal buffer, for use in error messages.
330 BFD_FMA_FMT can't be used in translated strings. */
333 bfd_vmatoa (char *fmtch, bfd_vma value)
335 /* bfd_vmatoa is used more then once in a printf call for output.
336 Cycle through an array of buffers. */
337 static int buf_pos = 0;
338 static struct bfd_vmatoa_buf
345 ret = buf[buf_pos++].place;
346 buf_pos %= ARRAY_SIZE (buf);
348 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
349 snprintf (ret, sizeof (buf[0].place), fmt, value);
353 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
354 OFFSET + the offset of the current archive member, if we are examining an
355 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
356 allocate a buffer using malloc and fill that. In either case return the
357 pointer to the start of the retrieved data or NULL if something went wrong.
358 If something does go wrong and REASON is not NULL then emit an error
359 message using REASON as part of the context. */
362 get_data (void * var,
364 unsigned long offset,
370 bfd_size_type amt = size * nmemb;
372 if (size == 0 || nmemb == 0)
375 /* If the size_t type is smaller than the bfd_size_type, eg because
376 you are building a 32-bit tool on a 64-bit host, then make sure
377 that when the sizes are cast to (size_t) no information is lost. */
378 if (sizeof (size_t) < sizeof (bfd_size_type)
379 && ( (bfd_size_type) ((size_t) size) != size
380 || (bfd_size_type) ((size_t) nmemb) != nmemb))
383 error (_("Size truncation prevents reading %s"
384 " elements of size %s for %s\n"),
385 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
389 /* Check for size overflow. */
393 error (_("Size overflow prevents reading %s"
394 " elements of size %s for %s\n"),
395 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
399 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
400 attempting to allocate memory when the read is bound to fail. */
401 if (amt > filedata->file_size
402 || offset + archive_file_offset + amt > filedata->file_size)
405 error (_("Reading %s bytes extends past end of file for %s\n"),
406 bfd_vmatoa ("u", amt), reason);
410 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
413 error (_("Unable to seek to 0x%lx for %s\n"),
414 archive_file_offset + offset, reason);
421 /* Check for overflow. */
422 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
423 /* + 1 so that we can '\0' terminate invalid string table sections. */
424 mvar = malloc ((size_t) amt + 1);
429 error (_("Out of memory allocating %s bytes for %s\n"),
430 bfd_vmatoa ("u", amt), reason);
434 ((char *) mvar)[amt] = '\0';
437 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
440 error (_("Unable to read in %s bytes of %s\n"),
441 bfd_vmatoa ("u", amt), reason);
450 /* Print a VMA value in the MODE specified.
451 Returns the number of characters displayed. */
454 print_vma (bfd_vma vma, print_mode mode)
466 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
473 return printf ("%5" BFD_VMA_FMT "d", vma);
479 return nc + printf ("%" BFD_VMA_FMT "x", vma);
482 return printf ("%" BFD_VMA_FMT "d", vma);
485 return printf ("%" BFD_VMA_FMT "u", vma);
488 /* FIXME: Report unrecognised mode ? */
493 /* Display a symbol on stdout. Handles the display of control characters and
494 multibye characters (assuming the host environment supports them).
496 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
498 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
499 padding as necessary.
501 Returns the number of emitted characters. */
504 print_symbol (signed int width, const char *symbol)
506 bfd_boolean extra_padding = FALSE;
507 signed int num_printed = 0;
508 #ifdef HAVE_MBSTATE_T
511 unsigned int width_remaining;
515 /* Keep the width positive. This helps the code below. */
517 extra_padding = TRUE;
523 /* Set the remaining width to a very large value.
524 This simplifies the code below. */
525 width_remaining = INT_MAX;
527 width_remaining = width;
529 #ifdef HAVE_MBSTATE_T
530 /* Initialise the multibyte conversion state. */
531 memset (& state, 0, sizeof (state));
534 while (width_remaining)
537 const char c = *symbol++;
542 /* Do not print control characters directly as they can affect terminal
543 settings. Such characters usually appear in the names generated
544 by the assembler for local labels. */
547 if (width_remaining < 2)
550 printf ("^%c", c + 0x40);
551 width_remaining -= 2;
554 else if (ISPRINT (c))
562 #ifdef HAVE_MBSTATE_T
565 /* Let printf do the hard work of displaying multibyte characters. */
566 printf ("%.1s", symbol - 1);
570 #ifdef HAVE_MBSTATE_T
571 /* Try to find out how many bytes made up the character that was
572 just printed. Advance the symbol pointer past the bytes that
574 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
578 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
583 if (extra_padding && num_printed < width)
585 /* Fill in the remaining spaces. */
586 printf ("%-*s", width - num_printed, " ");
593 /* Returns a pointer to a static buffer containing a printable version of
594 the given section's name. Like print_symbol, except that it does not try
595 to print multibyte characters, it just interprets them as hex values. */
598 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
600 #define MAX_PRINT_SEC_NAME_LEN 128
601 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
602 const char * name = SECTION_NAME (sec);
603 char * buf = sec_name_buf;
605 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
607 while ((c = * name ++) != 0)
618 else if (ISPRINT (c))
625 static char hex[17] = "0123456789ABCDEF";
630 * buf ++ = hex[(c & 0xf0) >> 4];
631 * buf ++ = hex[c & 0x0f];
645 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
647 if (ndx >= filedata->file_header.e_shnum)
648 return _("<corrupt>");
650 return printable_section_name (filedata, filedata->section_headers + ndx);
653 /* Return a pointer to section NAME, or NULL if no such section exists. */
655 static Elf_Internal_Shdr *
656 find_section (Filedata * filedata, const char * name)
660 if (filedata->section_headers == NULL)
663 for (i = 0; i < filedata->file_header.e_shnum; i++)
664 if (streq (SECTION_NAME (filedata->section_headers + i), name))
665 return filedata->section_headers + i;
670 /* Return a pointer to a section containing ADDR, or NULL if no such
673 static Elf_Internal_Shdr *
674 find_section_by_address (Filedata * filedata, bfd_vma addr)
678 if (filedata->section_headers == NULL)
681 for (i = 0; i < filedata->file_header.e_shnum; i++)
683 Elf_Internal_Shdr *sec = filedata->section_headers + i;
685 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
692 static Elf_Internal_Shdr *
693 find_section_by_type (Filedata * filedata, unsigned int type)
697 if (filedata->section_headers == NULL)
700 for (i = 0; i < filedata->file_header.e_shnum; i++)
702 Elf_Internal_Shdr *sec = filedata->section_headers + i;
704 if (sec->sh_type == type)
711 /* Return a pointer to section NAME, or NULL if no such section exists,
712 restricted to the list of sections given in SET. */
714 static Elf_Internal_Shdr *
715 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
719 if (filedata->section_headers == NULL)
724 while ((i = *set++) > 0)
726 /* See PR 21156 for a reproducer. */
727 if (i >= filedata->file_header.e_shnum)
728 continue; /* FIXME: Should we issue an error message ? */
730 if (streq (SECTION_NAME (filedata->section_headers + i), name))
731 return filedata->section_headers + i;
735 return find_section (filedata, name);
738 /* Read an unsigned LEB128 encoded value from DATA.
739 Set *LENGTH_RETURN to the number of bytes read. */
741 static inline unsigned long
742 read_uleb128 (unsigned char * data,
743 unsigned int * length_return,
744 const unsigned char * const end)
746 return read_leb128 (data, length_return, FALSE, end);
749 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
750 This OS has so many departures from the ELF standard that we test it at
753 static inline bfd_boolean
754 is_ia64_vms (Filedata * filedata)
756 return filedata->file_header.e_machine == EM_IA_64
757 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
760 /* Guess the relocation size commonly used by the specific machines. */
763 guess_is_rela (unsigned int e_machine)
767 /* Targets that use REL relocations. */
783 /* Targets that use RELA relocations. */
787 case EM_ADAPTEVA_EPIPHANY:
789 case EM_ALTERA_NIOS2:
792 case EM_ARC_COMPACT2:
812 case EM_LATTICEMICO32:
821 case EM_CYGNUS_MN10200:
823 case EM_CYGNUS_MN10300:
859 case EM_MICROBLAZE_OLD:
881 warn (_("Don't know about relocations on this machine architecture\n"));
886 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
887 Returns TRUE upon success, FALSE otherwise. If successful then a
888 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
889 and the number of relocs loaded is placed in *NRELASP. It is the caller's
890 responsibility to free the allocated buffer. */
893 slurp_rela_relocs (Filedata * filedata,
894 unsigned long rel_offset,
895 unsigned long rel_size,
896 Elf_Internal_Rela ** relasp,
897 unsigned long * nrelasp)
899 Elf_Internal_Rela * relas;
905 Elf32_External_Rela * erelas;
907 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
908 rel_size, _("32-bit relocation data"));
912 nrelas = rel_size / sizeof (Elf32_External_Rela);
914 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
915 sizeof (Elf_Internal_Rela));
920 error (_("out of memory parsing relocs\n"));
924 for (i = 0; i < nrelas; i++)
926 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
927 relas[i].r_info = BYTE_GET (erelas[i].r_info);
928 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
935 Elf64_External_Rela * erelas;
937 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
938 rel_size, _("64-bit relocation data"));
942 nrelas = rel_size / sizeof (Elf64_External_Rela);
944 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
945 sizeof (Elf_Internal_Rela));
950 error (_("out of memory parsing relocs\n"));
954 for (i = 0; i < nrelas; i++)
956 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
957 relas[i].r_info = BYTE_GET (erelas[i].r_info);
958 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
960 /* The #ifdef BFD64 below is to prevent a compile time
961 warning. We know that if we do not have a 64 bit data
962 type that we will never execute this code anyway. */
964 if (filedata->file_header.e_machine == EM_MIPS
965 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
967 /* In little-endian objects, r_info isn't really a
968 64-bit little-endian value: it has a 32-bit
969 little-endian symbol index followed by four
970 individual byte fields. Reorder INFO
972 bfd_vma inf = relas[i].r_info;
973 inf = (((inf & 0xffffffff) << 32)
974 | ((inf >> 56) & 0xff)
975 | ((inf >> 40) & 0xff00)
976 | ((inf >> 24) & 0xff0000)
977 | ((inf >> 8) & 0xff000000));
978 relas[i].r_info = inf;
991 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
992 Returns TRUE upon success, FALSE otherwise. If successful then a
993 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
994 and the number of relocs loaded is placed in *NRELSP. It is the caller's
995 responsibility to free the allocated buffer. */
998 slurp_rel_relocs (Filedata * filedata,
999 unsigned long rel_offset,
1000 unsigned long rel_size,
1001 Elf_Internal_Rela ** relsp,
1002 unsigned long * nrelsp)
1004 Elf_Internal_Rela * rels;
1010 Elf32_External_Rel * erels;
1012 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1013 rel_size, _("32-bit relocation data"));
1017 nrels = rel_size / sizeof (Elf32_External_Rel);
1019 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1024 error (_("out of memory parsing relocs\n"));
1028 for (i = 0; i < nrels; i++)
1030 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1031 rels[i].r_info = BYTE_GET (erels[i].r_info);
1032 rels[i].r_addend = 0;
1039 Elf64_External_Rel * erels;
1041 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1042 rel_size, _("64-bit relocation data"));
1046 nrels = rel_size / sizeof (Elf64_External_Rel);
1048 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1053 error (_("out of memory parsing relocs\n"));
1057 for (i = 0; i < nrels; i++)
1059 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1060 rels[i].r_info = BYTE_GET (erels[i].r_info);
1061 rels[i].r_addend = 0;
1063 /* The #ifdef BFD64 below is to prevent a compile time
1064 warning. We know that if we do not have a 64 bit data
1065 type that we will never execute this code anyway. */
1067 if (filedata->file_header.e_machine == EM_MIPS
1068 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1070 /* In little-endian objects, r_info isn't really a
1071 64-bit little-endian value: it has a 32-bit
1072 little-endian symbol index followed by four
1073 individual byte fields. Reorder INFO
1075 bfd_vma inf = rels[i].r_info;
1076 inf = (((inf & 0xffffffff) << 32)
1077 | ((inf >> 56) & 0xff)
1078 | ((inf >> 40) & 0xff00)
1079 | ((inf >> 24) & 0xff0000)
1080 | ((inf >> 8) & 0xff000000));
1081 rels[i].r_info = inf;
1094 /* Returns the reloc type extracted from the reloc info field. */
1097 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1100 return ELF32_R_TYPE (reloc_info);
1102 switch (filedata->file_header.e_machine)
1105 /* Note: We assume that reloc_info has already been adjusted for us. */
1106 return ELF64_MIPS_R_TYPE (reloc_info);
1109 return ELF64_R_TYPE_ID (reloc_info);
1112 return ELF64_R_TYPE (reloc_info);
1116 /* Return the symbol index extracted from the reloc info field. */
1119 get_reloc_symindex (bfd_vma reloc_info)
1121 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1124 static inline bfd_boolean
1125 uses_msp430x_relocs (Filedata * filedata)
1128 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1129 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1130 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1131 /* TI compiler uses ELFOSABI_NONE. */
1132 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1135 /* Display the contents of the relocation data found at the specified
1139 dump_relocations (Filedata * filedata,
1140 unsigned long rel_offset,
1141 unsigned long rel_size,
1142 Elf_Internal_Sym * symtab,
1143 unsigned long nsyms,
1145 unsigned long strtablen,
1147 bfd_boolean is_dynsym)
1150 Elf_Internal_Rela * rels;
1151 bfd_boolean res = TRUE;
1153 if (is_rela == UNKNOWN)
1154 is_rela = guess_is_rela (filedata->file_header.e_machine);
1158 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1163 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1172 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1174 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1179 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1181 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1189 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1191 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1196 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1198 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1202 for (i = 0; i < rel_size; i++)
1207 bfd_vma symtab_index;
1210 offset = rels[i].r_offset;
1211 inf = rels[i].r_info;
1213 type = get_reloc_type (filedata, inf);
1214 symtab_index = get_reloc_symindex (inf);
1218 printf ("%8.8lx %8.8lx ",
1219 (unsigned long) offset & 0xffffffff,
1220 (unsigned long) inf & 0xffffffff);
1224 #if BFD_HOST_64BIT_LONG
1226 ? "%16.16lx %16.16lx "
1227 : "%12.12lx %12.12lx ",
1229 #elif BFD_HOST_64BIT_LONG_LONG
1232 ? "%16.16llx %16.16llx "
1233 : "%12.12llx %12.12llx ",
1237 ? "%16.16I64x %16.16I64x "
1238 : "%12.12I64x %12.12I64x ",
1243 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1244 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1245 _bfd_int64_high (offset),
1246 _bfd_int64_low (offset),
1247 _bfd_int64_high (inf),
1248 _bfd_int64_low (inf));
1252 switch (filedata->file_header.e_machine)
1259 rtype = elf_aarch64_reloc_type (type);
1263 case EM_CYGNUS_M32R:
1264 rtype = elf_m32r_reloc_type (type);
1269 rtype = elf_i386_reloc_type (type);
1274 rtype = elf_m68hc11_reloc_type (type);
1278 rtype = elf_m68k_reloc_type (type);
1282 rtype = elf_i960_reloc_type (type);
1287 rtype = elf_avr_reloc_type (type);
1290 case EM_OLD_SPARCV9:
1291 case EM_SPARC32PLUS:
1294 rtype = elf_sparc_reloc_type (type);
1298 rtype = elf_spu_reloc_type (type);
1302 rtype = v800_reloc_type (type);
1305 case EM_CYGNUS_V850:
1306 rtype = v850_reloc_type (type);
1310 case EM_CYGNUS_D10V:
1311 rtype = elf_d10v_reloc_type (type);
1315 case EM_CYGNUS_D30V:
1316 rtype = elf_d30v_reloc_type (type);
1320 rtype = elf_dlx_reloc_type (type);
1324 rtype = elf_sh_reloc_type (type);
1328 case EM_CYGNUS_MN10300:
1329 rtype = elf_mn10300_reloc_type (type);
1333 case EM_CYGNUS_MN10200:
1334 rtype = elf_mn10200_reloc_type (type);
1338 case EM_CYGNUS_FR30:
1339 rtype = elf_fr30_reloc_type (type);
1343 rtype = elf_frv_reloc_type (type);
1347 rtype = elf_ft32_reloc_type (type);
1351 rtype = elf_mcore_reloc_type (type);
1355 rtype = elf_mmix_reloc_type (type);
1359 rtype = elf_moxie_reloc_type (type);
1363 if (uses_msp430x_relocs (filedata))
1365 rtype = elf_msp430x_reloc_type (type);
1370 rtype = elf_msp430_reloc_type (type);
1374 rtype = elf_nds32_reloc_type (type);
1378 rtype = elf_ppc_reloc_type (type);
1382 rtype = elf_ppc64_reloc_type (type);
1386 case EM_MIPS_RS3_LE:
1387 rtype = elf_mips_reloc_type (type);
1391 rtype = elf_riscv_reloc_type (type);
1395 rtype = elf_alpha_reloc_type (type);
1399 rtype = elf_arm_reloc_type (type);
1403 case EM_ARC_COMPACT:
1404 case EM_ARC_COMPACT2:
1405 rtype = elf_arc_reloc_type (type);
1409 rtype = elf_hppa_reloc_type (type);
1415 rtype = elf_h8_reloc_type (type);
1419 rtype = elf_or1k_reloc_type (type);
1424 rtype = elf_pj_reloc_type (type);
1427 rtype = elf_ia64_reloc_type (type);
1431 rtype = elf_cris_reloc_type (type);
1435 rtype = elf_i860_reloc_type (type);
1441 rtype = elf_x86_64_reloc_type (type);
1445 rtype = i370_reloc_type (type);
1450 rtype = elf_s390_reloc_type (type);
1454 rtype = elf_score_reloc_type (type);
1458 rtype = elf_xstormy16_reloc_type (type);
1462 rtype = elf_crx_reloc_type (type);
1466 rtype = elf_vax_reloc_type (type);
1470 rtype = elf_visium_reloc_type (type);
1473 case EM_ADAPTEVA_EPIPHANY:
1474 rtype = elf_epiphany_reloc_type (type);
1479 rtype = elf_ip2k_reloc_type (type);
1483 rtype = elf_iq2000_reloc_type (type);
1488 rtype = elf_xtensa_reloc_type (type);
1491 case EM_LATTICEMICO32:
1492 rtype = elf_lm32_reloc_type (type);
1497 rtype = elf_m32c_reloc_type (type);
1501 rtype = elf_mt_reloc_type (type);
1505 rtype = elf_bfin_reloc_type (type);
1509 rtype = elf_mep_reloc_type (type);
1513 rtype = elf_cr16_reloc_type (type);
1517 case EM_MICROBLAZE_OLD:
1518 rtype = elf_microblaze_reloc_type (type);
1522 rtype = elf_rl78_reloc_type (type);
1526 rtype = elf_rx_reloc_type (type);
1530 rtype = elf_metag_reloc_type (type);
1535 rtype = elf_xc16x_reloc_type (type);
1539 rtype = elf_tic6x_reloc_type (type);
1543 rtype = elf_tilegx_reloc_type (type);
1547 rtype = elf_tilepro_reloc_type (type);
1550 case EM_WEBASSEMBLY:
1551 rtype = elf_wasm32_reloc_type (type);
1555 rtype = elf_xgate_reloc_type (type);
1558 case EM_ALTERA_NIOS2:
1559 rtype = elf_nios2_reloc_type (type);
1563 rtype = elf_pru_reloc_type (type);
1567 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1568 rtype = elf_nfp3200_reloc_type (type);
1570 rtype = elf_nfp_reloc_type (type);
1575 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1577 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1579 if (filedata->file_header.e_machine == EM_ALPHA
1581 && streq (rtype, "R_ALPHA_LITUSE")
1584 switch (rels[i].r_addend)
1586 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1587 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1588 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1589 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1590 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1591 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1592 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1593 default: rtype = NULL;
1597 printf (" (%s)", rtype);
1601 printf (_("<unknown addend: %lx>"),
1602 (unsigned long) rels[i].r_addend);
1606 else if (symtab_index)
1608 if (symtab == NULL || symtab_index >= nsyms)
1610 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1615 Elf_Internal_Sym * psym;
1616 const char * version_string;
1617 enum versioned_symbol_info sym_info;
1618 unsigned short vna_other;
1620 psym = symtab + symtab_index;
1623 = get_symbol_version_string (filedata, is_dynsym,
1632 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1636 unsigned int width = is_32bit_elf ? 8 : 14;
1638 /* Relocations against GNU_IFUNC symbols do not use the value
1639 of the symbol as the address to relocate against. Instead
1640 they invoke the function named by the symbol and use its
1641 result as the address for relocation.
1643 To indicate this to the user, do not display the value of
1644 the symbol in the "Symbols's Value" field. Instead show
1645 its name followed by () as a hint that the symbol is
1649 || psym->st_name == 0
1650 || psym->st_name >= strtablen)
1653 name = strtab + psym->st_name;
1655 len = print_symbol (width, name);
1657 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1659 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1663 print_vma (psym->st_value, LONG_HEX);
1665 printf (is_32bit_elf ? " " : " ");
1668 if (psym->st_name == 0)
1670 const char * sec_name = "<null>";
1673 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1675 if (psym->st_shndx < filedata->file_header.e_shnum)
1676 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1677 else if (psym->st_shndx == SHN_ABS)
1679 else if (psym->st_shndx == SHN_COMMON)
1680 sec_name = "COMMON";
1681 else if ((filedata->file_header.e_machine == EM_MIPS
1682 && psym->st_shndx == SHN_MIPS_SCOMMON)
1683 || (filedata->file_header.e_machine == EM_TI_C6000
1684 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1685 sec_name = "SCOMMON";
1686 else if (filedata->file_header.e_machine == EM_MIPS
1687 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1688 sec_name = "SUNDEF";
1689 else if ((filedata->file_header.e_machine == EM_X86_64
1690 || filedata->file_header.e_machine == EM_L1OM
1691 || filedata->file_header.e_machine == EM_K1OM)
1692 && psym->st_shndx == SHN_X86_64_LCOMMON)
1693 sec_name = "LARGE_COMMON";
1694 else if (filedata->file_header.e_machine == EM_IA_64
1695 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1696 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1697 sec_name = "ANSI_COM";
1698 else if (is_ia64_vms (filedata)
1699 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1700 sec_name = "VMS_SYMVEC";
1703 sprintf (name_buf, "<section 0x%x>",
1704 (unsigned int) psym->st_shndx);
1705 sec_name = name_buf;
1708 print_symbol (22, sec_name);
1710 else if (strtab == NULL)
1711 printf (_("<string table index: %3ld>"), psym->st_name);
1712 else if (psym->st_name >= strtablen)
1714 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1719 print_symbol (22, strtab + psym->st_name);
1721 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1727 bfd_vma off = rels[i].r_addend;
1729 if ((bfd_signed_vma) off < 0)
1730 printf (" - %" BFD_VMA_FMT "x", - off);
1732 printf (" + %" BFD_VMA_FMT "x", off);
1738 bfd_vma off = rels[i].r_addend;
1740 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1741 if ((bfd_signed_vma) off < 0)
1742 printf ("-%" BFD_VMA_FMT "x", - off);
1744 printf ("%" BFD_VMA_FMT "x", off);
1747 if (filedata->file_header.e_machine == EM_SPARCV9
1749 && streq (rtype, "R_SPARC_OLO10"))
1750 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1755 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1757 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1758 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1759 const char * rtype2 = elf_mips_reloc_type (type2);
1760 const char * rtype3 = elf_mips_reloc_type (type3);
1762 printf (" Type2: ");
1765 printf (_("unrecognized: %-7lx"),
1766 (unsigned long) type2 & 0xffffffff);
1768 printf ("%-17.17s", rtype2);
1770 printf ("\n Type3: ");
1773 printf (_("unrecognized: %-7lx"),
1774 (unsigned long) type3 & 0xffffffff);
1776 printf ("%-17.17s", rtype3);
1789 get_mips_dynamic_type (unsigned long type)
1793 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1794 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1795 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1796 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1797 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1798 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1799 case DT_MIPS_MSYM: return "MIPS_MSYM";
1800 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1801 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1802 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1803 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1804 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1805 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1806 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1807 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1808 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1809 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1810 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1811 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1812 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1813 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1814 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1815 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1816 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1817 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1818 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1819 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1820 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1821 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1822 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1823 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1824 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1825 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1826 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1827 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1828 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1829 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1830 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1831 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1832 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1833 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1834 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1835 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1836 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1837 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1838 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1845 get_sparc64_dynamic_type (unsigned long type)
1849 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1856 get_ppc_dynamic_type (unsigned long type)
1860 case DT_PPC_GOT: return "PPC_GOT";
1861 case DT_PPC_OPT: return "PPC_OPT";
1868 get_ppc64_dynamic_type (unsigned long type)
1872 case DT_PPC64_GLINK: return "PPC64_GLINK";
1873 case DT_PPC64_OPD: return "PPC64_OPD";
1874 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1875 case DT_PPC64_OPT: return "PPC64_OPT";
1882 get_parisc_dynamic_type (unsigned long type)
1886 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1887 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1888 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1889 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1890 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1891 case DT_HP_PREINIT: return "HP_PREINIT";
1892 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1893 case DT_HP_NEEDED: return "HP_NEEDED";
1894 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1895 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1896 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1897 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1898 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1899 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1900 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1901 case DT_HP_FILTERED: return "HP_FILTERED";
1902 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1903 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1904 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1905 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1906 case DT_PLT: return "PLT";
1907 case DT_PLT_SIZE: return "PLT_SIZE";
1908 case DT_DLT: return "DLT";
1909 case DT_DLT_SIZE: return "DLT_SIZE";
1916 get_ia64_dynamic_type (unsigned long type)
1920 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1921 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1922 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1923 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1924 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1925 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1926 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1927 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1928 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1929 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1930 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1931 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1932 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1933 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1934 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1935 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1936 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1937 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1938 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1939 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1940 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1941 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1942 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1943 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1944 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1945 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1946 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1947 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1948 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1949 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1950 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1957 get_solaris_section_type (unsigned long type)
1961 case 0x6fffffee: return "SUNW_ancillary";
1962 case 0x6fffffef: return "SUNW_capchain";
1963 case 0x6ffffff0: return "SUNW_capinfo";
1964 case 0x6ffffff1: return "SUNW_symsort";
1965 case 0x6ffffff2: return "SUNW_tlssort";
1966 case 0x6ffffff3: return "SUNW_LDYNSYM";
1967 case 0x6ffffff4: return "SUNW_dof";
1968 case 0x6ffffff5: return "SUNW_cap";
1969 case 0x6ffffff6: return "SUNW_SIGNATURE";
1970 case 0x6ffffff7: return "SUNW_ANNOTATE";
1971 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1972 case 0x6ffffff9: return "SUNW_DEBUG";
1973 case 0x6ffffffa: return "SUNW_move";
1974 case 0x6ffffffb: return "SUNW_COMDAT";
1975 case 0x6ffffffc: return "SUNW_syminfo";
1976 case 0x6ffffffd: return "SUNW_verdef";
1977 case 0x6ffffffe: return "SUNW_verneed";
1978 case 0x6fffffff: return "SUNW_versym";
1979 case 0x70000000: return "SPARC_GOTDATA";
1980 default: return NULL;
1985 get_alpha_dynamic_type (unsigned long type)
1989 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1990 default: return NULL;
1995 get_score_dynamic_type (unsigned long type)
1999 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2000 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2001 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2002 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2003 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2004 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2005 default: return NULL;
2010 get_tic6x_dynamic_type (unsigned long type)
2014 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2015 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2016 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2017 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2018 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2019 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2020 default: return NULL;
2025 get_nios2_dynamic_type (unsigned long type)
2029 case DT_NIOS2_GP: return "NIOS2_GP";
2030 default: return NULL;
2035 get_solaris_dynamic_type (unsigned long type)
2039 case 0x6000000d: return "SUNW_AUXILIARY";
2040 case 0x6000000e: return "SUNW_RTLDINF";
2041 case 0x6000000f: return "SUNW_FILTER";
2042 case 0x60000010: return "SUNW_CAP";
2043 case 0x60000011: return "SUNW_SYMTAB";
2044 case 0x60000012: return "SUNW_SYMSZ";
2045 case 0x60000013: return "SUNW_SORTENT";
2046 case 0x60000014: return "SUNW_SYMSORT";
2047 case 0x60000015: return "SUNW_SYMSORTSZ";
2048 case 0x60000016: return "SUNW_TLSSORT";
2049 case 0x60000017: return "SUNW_TLSSORTSZ";
2050 case 0x60000018: return "SUNW_CAPINFO";
2051 case 0x60000019: return "SUNW_STRPAD";
2052 case 0x6000001a: return "SUNW_CAPCHAIN";
2053 case 0x6000001b: return "SUNW_LDMACH";
2054 case 0x6000001d: return "SUNW_CAPCHAINENT";
2055 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2056 case 0x60000021: return "SUNW_PARENT";
2057 case 0x60000023: return "SUNW_ASLR";
2058 case 0x60000025: return "SUNW_RELAX";
2059 case 0x60000029: return "SUNW_NXHEAP";
2060 case 0x6000002b: return "SUNW_NXSTACK";
2062 case 0x70000001: return "SPARC_REGISTER";
2063 case 0x7ffffffd: return "AUXILIARY";
2064 case 0x7ffffffe: return "USED";
2065 case 0x7fffffff: return "FILTER";
2067 default: return NULL;
2072 get_dynamic_type (Filedata * filedata, unsigned long type)
2074 static char buff[64];
2078 case DT_NULL: return "NULL";
2079 case DT_NEEDED: return "NEEDED";
2080 case DT_PLTRELSZ: return "PLTRELSZ";
2081 case DT_PLTGOT: return "PLTGOT";
2082 case DT_HASH: return "HASH";
2083 case DT_STRTAB: return "STRTAB";
2084 case DT_SYMTAB: return "SYMTAB";
2085 case DT_RELA: return "RELA";
2086 case DT_RELASZ: return "RELASZ";
2087 case DT_RELAENT: return "RELAENT";
2088 case DT_STRSZ: return "STRSZ";
2089 case DT_SYMENT: return "SYMENT";
2090 case DT_INIT: return "INIT";
2091 case DT_FINI: return "FINI";
2092 case DT_SONAME: return "SONAME";
2093 case DT_RPATH: return "RPATH";
2094 case DT_SYMBOLIC: return "SYMBOLIC";
2095 case DT_REL: return "REL";
2096 case DT_RELSZ: return "RELSZ";
2097 case DT_RELENT: return "RELENT";
2098 case DT_PLTREL: return "PLTREL";
2099 case DT_DEBUG: return "DEBUG";
2100 case DT_TEXTREL: return "TEXTREL";
2101 case DT_JMPREL: return "JMPREL";
2102 case DT_BIND_NOW: return "BIND_NOW";
2103 case DT_INIT_ARRAY: return "INIT_ARRAY";
2104 case DT_FINI_ARRAY: return "FINI_ARRAY";
2105 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2106 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2107 case DT_RUNPATH: return "RUNPATH";
2108 case DT_FLAGS: return "FLAGS";
2110 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2111 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2112 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2114 case DT_CHECKSUM: return "CHECKSUM";
2115 case DT_PLTPADSZ: return "PLTPADSZ";
2116 case DT_MOVEENT: return "MOVEENT";
2117 case DT_MOVESZ: return "MOVESZ";
2118 case DT_FEATURE: return "FEATURE";
2119 case DT_POSFLAG_1: return "POSFLAG_1";
2120 case DT_SYMINSZ: return "SYMINSZ";
2121 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2123 case DT_ADDRRNGLO: return "ADDRRNGLO";
2124 case DT_CONFIG: return "CONFIG";
2125 case DT_DEPAUDIT: return "DEPAUDIT";
2126 case DT_AUDIT: return "AUDIT";
2127 case DT_PLTPAD: return "PLTPAD";
2128 case DT_MOVETAB: return "MOVETAB";
2129 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2131 case DT_VERSYM: return "VERSYM";
2133 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2134 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2135 case DT_RELACOUNT: return "RELACOUNT";
2136 case DT_RELCOUNT: return "RELCOUNT";
2137 case DT_FLAGS_1: return "FLAGS_1";
2138 case DT_VERDEF: return "VERDEF";
2139 case DT_VERDEFNUM: return "VERDEFNUM";
2140 case DT_VERNEED: return "VERNEED";
2141 case DT_VERNEEDNUM: return "VERNEEDNUM";
2143 case DT_AUXILIARY: return "AUXILIARY";
2144 case DT_USED: return "USED";
2145 case DT_FILTER: return "FILTER";
2147 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2148 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2149 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2150 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2151 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2152 case DT_GNU_HASH: return "GNU_HASH";
2155 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2157 const char * result;
2159 switch (filedata->file_header.e_machine)
2162 case EM_MIPS_RS3_LE:
2163 result = get_mips_dynamic_type (type);
2166 result = get_sparc64_dynamic_type (type);
2169 result = get_ppc_dynamic_type (type);
2172 result = get_ppc64_dynamic_type (type);
2175 result = get_ia64_dynamic_type (type);
2178 result = get_alpha_dynamic_type (type);
2181 result = get_score_dynamic_type (type);
2184 result = get_tic6x_dynamic_type (type);
2186 case EM_ALTERA_NIOS2:
2187 result = get_nios2_dynamic_type (type);
2190 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2191 result = get_solaris_dynamic_type (type);
2200 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2202 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2203 || (filedata->file_header.e_machine == EM_PARISC
2204 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2206 const char * result;
2208 switch (filedata->file_header.e_machine)
2211 result = get_parisc_dynamic_type (type);
2214 result = get_ia64_dynamic_type (type);
2217 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2218 result = get_solaris_dynamic_type (type);
2227 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2231 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2238 get_file_type (unsigned e_type)
2240 static char buff[32];
2244 case ET_NONE: return _("NONE (None)");
2245 case ET_REL: return _("REL (Relocatable file)");
2246 case ET_EXEC: return _("EXEC (Executable file)");
2247 case ET_DYN: return _("DYN (Shared object file)");
2248 case ET_CORE: return _("CORE (Core file)");
2251 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2252 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2253 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2254 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2256 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2262 get_machine_name (unsigned e_machine)
2264 static char buff[64]; /* XXX */
2268 /* Please keep this switch table sorted by increasing EM_ value. */
2270 case EM_NONE: return _("None");
2271 case EM_M32: return "WE32100";
2272 case EM_SPARC: return "Sparc";
2273 case EM_386: return "Intel 80386";
2274 case EM_68K: return "MC68000";
2275 case EM_88K: return "MC88000";
2276 case EM_IAMCU: return "Intel MCU";
2277 case EM_860: return "Intel 80860";
2278 case EM_MIPS: return "MIPS R3000";
2279 case EM_S370: return "IBM System/370";
2281 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2282 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2283 case EM_PARISC: return "HPPA";
2284 case EM_VPP550: return "Fujitsu VPP500";
2285 case EM_SPARC32PLUS: return "Sparc v8+" ;
2286 case EM_960: return "Intel 80960";
2287 case EM_PPC: return "PowerPC";
2289 case EM_PPC64: return "PowerPC64";
2291 case EM_S390: return "IBM S/390";
2292 case EM_SPU: return "SPU";
2294 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2295 case EM_FR20: return "Fujitsu FR20";
2296 case EM_RH32: return "TRW RH32";
2297 case EM_MCORE: return "MCORE";
2299 case EM_ARM: return "ARM";
2300 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2301 case EM_SH: return "Renesas / SuperH SH";
2302 case EM_SPARCV9: return "Sparc v9";
2303 case EM_TRICORE: return "Siemens Tricore";
2304 case EM_ARC: return "ARC";
2305 case EM_H8_300: return "Renesas H8/300";
2306 case EM_H8_300H: return "Renesas H8/300H";
2307 case EM_H8S: return "Renesas H8S";
2308 case EM_H8_500: return "Renesas H8/500";
2310 case EM_IA_64: return "Intel IA-64";
2311 case EM_MIPS_X: return "Stanford MIPS-X";
2312 case EM_COLDFIRE: return "Motorola Coldfire";
2313 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2314 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2315 case EM_PCP: return "Siemens PCP";
2316 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2317 case EM_NDR1: return "Denso NDR1 microprocesspr";
2318 case EM_STARCORE: return "Motorola Star*Core processor";
2319 case EM_ME16: return "Toyota ME16 processor";
2321 case EM_ST100: return "STMicroelectronics ST100 processor";
2322 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2323 case EM_X86_64: return "Advanced Micro Devices X86-64";
2324 case EM_PDSP: return "Sony DSP processor";
2325 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2326 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2327 case EM_FX66: return "Siemens FX66 microcontroller";
2328 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2329 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2330 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2332 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2333 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2334 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2335 case EM_SVX: return "Silicon Graphics SVx";
2336 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2337 case EM_VAX: return "Digital VAX";
2338 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2339 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2340 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2341 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2343 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2344 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2345 case EM_PRISM: return "Vitesse Prism";
2347 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2348 case EM_CYGNUS_FR30:
2349 case EM_FR30: return "Fujitsu FR30";
2350 case EM_CYGNUS_D10V:
2351 case EM_D10V: return "d10v";
2352 case EM_CYGNUS_D30V:
2353 case EM_D30V: return "d30v";
2354 case EM_CYGNUS_V850:
2355 case EM_V850: return "Renesas V850";
2356 case EM_CYGNUS_M32R:
2357 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2358 case EM_CYGNUS_MN10300:
2359 case EM_MN10300: return "mn10300";
2361 case EM_CYGNUS_MN10200:
2362 case EM_MN10200: return "mn10200";
2363 case EM_PJ: return "picoJava";
2364 case EM_OR1K: return "OpenRISC 1000";
2365 case EM_ARC_COMPACT: return "ARCompact";
2367 case EM_XTENSA: return "Tensilica Xtensa Processor";
2368 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2369 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2370 case EM_NS32K: return "National Semiconductor 32000 series";
2371 case EM_TPC: return "Tenor Network TPC processor";
2372 case EM_SNP1K: return "Trebia SNP 1000 processor";
2374 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2376 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2377 case EM_MAX: return "MAX Processor";
2378 case EM_CR: return "National Semiconductor CompactRISC";
2379 case EM_F2MC16: return "Fujitsu F2MC16";
2380 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2381 case EM_BLACKFIN: return "Analog Devices Blackfin";
2382 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2383 case EM_SEP: return "Sharp embedded microprocessor";
2384 case EM_ARCA: return "Arca RISC microprocessor";
2386 case EM_UNICORE: return "Unicore";
2387 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2388 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2389 case EM_ALTERA_NIOS2: return "Altera Nios II";
2390 case EM_CRX: return "National Semiconductor CRX microprocessor";
2391 case EM_XGATE: return "Motorola XGATE embedded processor";
2393 case EM_XC16X: return "Infineon Technologies xc16x";
2394 case EM_M16C: return "Renesas M16C series microprocessors";
2395 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2396 case EM_CE: return "Freescale Communication Engine RISC core";
2398 case EM_M32C: return "Renesas M32c";
2400 case EM_TSK3000: return "Altium TSK3000 core";
2401 case EM_RS08: return "Freescale RS08 embedded processor";
2402 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2403 case EM_SCORE: return "SUNPLUS S+Core";
2404 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2405 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2406 case EM_LATTICEMICO32: return "Lattice Mico32";
2407 case EM_SE_C17: return "Seiko Epson C17 family";
2409 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2410 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2411 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2412 case EM_TI_PRU: return "TI PRU I/O processor";
2414 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2415 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2416 case EM_R32C: return "Renesas R32C series microprocessors";
2417 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2418 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2419 case EM_8051: return "Intel 8051 and variants";
2420 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2421 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2422 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2423 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2425 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2426 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2427 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2428 case EM_RX: return "Renesas RX";
2429 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2430 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2431 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2434 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2435 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2436 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2438 case EM_L1OM: return "Intel L1OM";
2439 case EM_K1OM: return "Intel K1OM";
2440 case EM_INTEL182: return "Intel (reserved)";
2441 case EM_AARCH64: return "AArch64";
2442 case EM_ARM184: return "ARM (reserved)";
2443 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2444 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2445 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2446 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2448 case EM_CUDA: return "NVIDIA CUDA architecture";
2449 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2450 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2451 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2452 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2453 case EM_ARC_COMPACT2: return "ARCv2";
2454 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2455 case EM_RL78: return "Renesas RL78";
2456 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2457 case EM_78K0R: return "Renesas 78K0R";
2459 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2460 case EM_BA1: return "Beyond BA1 CPU architecture";
2461 case EM_BA2: return "Beyond BA2 CPU architecture";
2462 case EM_XCORE: return "XMOS xCORE processor family";
2463 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2465 case EM_KM32: return "KM211 KM32 32-bit processor";
2466 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2467 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2468 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2469 case EM_KVARC: return "KM211 KVARC processor";
2470 case EM_CDP: return "Paneve CDP architecture family";
2471 case EM_COGE: return "Cognitive Smart Memory Processor";
2472 case EM_COOL: return "Bluechip Systems CoolEngine";
2473 case EM_NORC: return "Nanoradio Optimized RISC";
2474 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2476 case EM_Z80: return "Zilog Z80";
2477 case EM_VISIUM: return "CDS VISIUMcore processor";
2478 case EM_FT32: return "FTDI Chip FT32";
2479 case EM_MOXIE: return "Moxie";
2480 case EM_AMDGPU: return "AMD GPU";
2481 case EM_RISCV: return "RISC-V";
2482 case EM_LANAI: return "Lanai 32-bit processor";
2483 case EM_BPF: return "Linux BPF";
2484 case EM_NFP: return "Netronome Flow Processor";
2486 /* Large numbers... */
2487 case EM_MT: return "Morpho Techologies MT processor";
2488 case EM_ALPHA: return "Alpha";
2489 case EM_WEBASSEMBLY: return "Web Assembly";
2490 case EM_DLX: return "OpenDLX";
2491 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2492 case EM_IQ2000: return "Vitesse IQ2000";
2494 case EM_NIOS32: return "Altera Nios";
2495 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2496 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2497 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2498 case EM_S12Z: return "Freescale S12Z";
2501 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2507 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2509 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2510 other compilers don't a specific architecture type in the e_flags, and
2511 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2512 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2515 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2516 but also sets a specific architecture type in the e_flags field.
2518 However, when decoding the flags we don't worry if we see an
2519 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2520 ARCEM architecture type. */
2522 switch (e_flags & EF_ARC_MACH_MSK)
2524 /* We only expect these to occur for EM_ARC_COMPACT2. */
2525 case EF_ARC_CPU_ARCV2EM:
2526 strcat (buf, ", ARC EM");
2528 case EF_ARC_CPU_ARCV2HS:
2529 strcat (buf, ", ARC HS");
2532 /* We only expect these to occur for EM_ARC_COMPACT. */
2533 case E_ARC_MACH_ARC600:
2534 strcat (buf, ", ARC600");
2536 case E_ARC_MACH_ARC601:
2537 strcat (buf, ", ARC601");
2539 case E_ARC_MACH_ARC700:
2540 strcat (buf, ", ARC700");
2543 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2544 new ELF with new architecture being read by an old version of
2545 readelf, or (c) An ELF built with non-GNU compiler that does not
2546 set the architecture in the e_flags. */
2548 if (e_machine == EM_ARC_COMPACT)
2549 strcat (buf, ", Unknown ARCompact");
2551 strcat (buf, ", Unknown ARC");
2555 switch (e_flags & EF_ARC_OSABI_MSK)
2557 case E_ARC_OSABI_ORIG:
2558 strcat (buf, ", (ABI:legacy)");
2560 case E_ARC_OSABI_V2:
2561 strcat (buf, ", (ABI:v2)");
2563 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2564 case E_ARC_OSABI_V3:
2565 strcat (buf, ", v3 no-legacy-syscalls ABI");
2567 case E_ARC_OSABI_V4:
2568 strcat (buf, ", v4 ABI");
2571 strcat (buf, ", unrecognised ARC OSABI flag");
2577 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2580 bfd_boolean unknown = FALSE;
2582 eabi = EF_ARM_EABI_VERSION (e_flags);
2583 e_flags &= ~ EF_ARM_EABIMASK;
2585 /* Handle "generic" ARM flags. */
2586 if (e_flags & EF_ARM_RELEXEC)
2588 strcat (buf, ", relocatable executable");
2589 e_flags &= ~ EF_ARM_RELEXEC;
2592 if (e_flags & EF_ARM_PIC)
2594 strcat (buf, ", position independent");
2595 e_flags &= ~ EF_ARM_PIC;
2598 /* Now handle EABI specific flags. */
2602 strcat (buf, ", <unrecognized EABI>");
2607 case EF_ARM_EABI_VER1:
2608 strcat (buf, ", Version1 EABI");
2613 /* Process flags one bit at a time. */
2614 flag = e_flags & - e_flags;
2619 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2620 strcat (buf, ", sorted symbol tables");
2630 case EF_ARM_EABI_VER2:
2631 strcat (buf, ", Version2 EABI");
2636 /* Process flags one bit at a time. */
2637 flag = e_flags & - e_flags;
2642 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2643 strcat (buf, ", sorted symbol tables");
2646 case EF_ARM_DYNSYMSUSESEGIDX:
2647 strcat (buf, ", dynamic symbols use segment index");
2650 case EF_ARM_MAPSYMSFIRST:
2651 strcat (buf, ", mapping symbols precede others");
2661 case EF_ARM_EABI_VER3:
2662 strcat (buf, ", Version3 EABI");
2665 case EF_ARM_EABI_VER4:
2666 strcat (buf, ", Version4 EABI");
2671 /* Process flags one bit at a time. */
2672 flag = e_flags & - e_flags;
2678 strcat (buf, ", BE8");
2682 strcat (buf, ", LE8");
2692 case EF_ARM_EABI_VER5:
2693 strcat (buf, ", Version5 EABI");
2698 /* Process flags one bit at a time. */
2699 flag = e_flags & - e_flags;
2705 strcat (buf, ", BE8");
2709 strcat (buf, ", LE8");
2712 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2713 strcat (buf, ", soft-float ABI");
2716 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2717 strcat (buf, ", hard-float ABI");
2727 case EF_ARM_EABI_UNKNOWN:
2728 strcat (buf, ", GNU EABI");
2733 /* Process flags one bit at a time. */
2734 flag = e_flags & - e_flags;
2739 case EF_ARM_INTERWORK:
2740 strcat (buf, ", interworking enabled");
2743 case EF_ARM_APCS_26:
2744 strcat (buf, ", uses APCS/26");
2747 case EF_ARM_APCS_FLOAT:
2748 strcat (buf, ", uses APCS/float");
2752 strcat (buf, ", position independent");
2756 strcat (buf, ", 8 bit structure alignment");
2759 case EF_ARM_NEW_ABI:
2760 strcat (buf, ", uses new ABI");
2763 case EF_ARM_OLD_ABI:
2764 strcat (buf, ", uses old ABI");
2767 case EF_ARM_SOFT_FLOAT:
2768 strcat (buf, ", software FP");
2771 case EF_ARM_VFP_FLOAT:
2772 strcat (buf, ", VFP");
2775 case EF_ARM_MAVERICK_FLOAT:
2776 strcat (buf, ", Maverick FP");
2787 strcat (buf,_(", <unknown>"));
2791 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2793 --size; /* Leave space for null terminator. */
2795 switch (e_flags & EF_AVR_MACH)
2797 case E_AVR_MACH_AVR1:
2798 strncat (buf, ", avr:1", size);
2800 case E_AVR_MACH_AVR2:
2801 strncat (buf, ", avr:2", size);
2803 case E_AVR_MACH_AVR25:
2804 strncat (buf, ", avr:25", size);
2806 case E_AVR_MACH_AVR3:
2807 strncat (buf, ", avr:3", size);
2809 case E_AVR_MACH_AVR31:
2810 strncat (buf, ", avr:31", size);
2812 case E_AVR_MACH_AVR35:
2813 strncat (buf, ", avr:35", size);
2815 case E_AVR_MACH_AVR4:
2816 strncat (buf, ", avr:4", size);
2818 case E_AVR_MACH_AVR5:
2819 strncat (buf, ", avr:5", size);
2821 case E_AVR_MACH_AVR51:
2822 strncat (buf, ", avr:51", size);
2824 case E_AVR_MACH_AVR6:
2825 strncat (buf, ", avr:6", size);
2827 case E_AVR_MACH_AVRTINY:
2828 strncat (buf, ", avr:100", size);
2830 case E_AVR_MACH_XMEGA1:
2831 strncat (buf, ", avr:101", size);
2833 case E_AVR_MACH_XMEGA2:
2834 strncat (buf, ", avr:102", size);
2836 case E_AVR_MACH_XMEGA3:
2837 strncat (buf, ", avr:103", size);
2839 case E_AVR_MACH_XMEGA4:
2840 strncat (buf, ", avr:104", size);
2842 case E_AVR_MACH_XMEGA5:
2843 strncat (buf, ", avr:105", size);
2845 case E_AVR_MACH_XMEGA6:
2846 strncat (buf, ", avr:106", size);
2848 case E_AVR_MACH_XMEGA7:
2849 strncat (buf, ", avr:107", size);
2852 strncat (buf, ", avr:<unknown>", size);
2856 size -= strlen (buf);
2857 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2858 strncat (buf, ", link-relax", size);
2862 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2868 bfd_boolean has_fpu = FALSE;
2871 static const char *ABI_STRINGS[] =
2873 "ABI v0", /* use r5 as return register; only used in N1213HC */
2874 "ABI v1", /* use r0 as return register */
2875 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2876 "ABI v2fp", /* for FPU */
2880 static const char *VER_STRINGS[] =
2882 "Andes ELF V1.3 or older",
2886 static const char *ARCH_STRINGS[] =
2895 abi = EF_NDS_ABI & e_flags;
2896 arch = EF_NDS_ARCH & e_flags;
2897 config = EF_NDS_INST & e_flags;
2898 version = EF_NDS32_ELF_VERSION & e_flags;
2900 memset (buf, 0, size);
2907 case E_NDS_ABI_V2FP:
2908 case E_NDS_ABI_AABI:
2909 case E_NDS_ABI_V2FP_PLUS:
2910 /* In case there are holes in the array. */
2911 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2915 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2921 case E_NDS32_ELF_VER_1_2:
2922 case E_NDS32_ELF_VER_1_3:
2923 case E_NDS32_ELF_VER_1_4:
2924 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2928 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2932 if (E_NDS_ABI_V0 == abi)
2934 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2935 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2936 if (arch == E_NDS_ARCH_STAR_V1_0)
2937 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2943 case E_NDS_ARCH_STAR_V1_0:
2944 case E_NDS_ARCH_STAR_V2_0:
2945 case E_NDS_ARCH_STAR_V3_0:
2946 case E_NDS_ARCH_STAR_V3_M:
2947 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2951 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2952 /* ARCH version determines how the e_flags are interpreted.
2953 If it is unknown, we cannot proceed. */
2957 /* Newer ABI; Now handle architecture specific flags. */
2958 if (arch == E_NDS_ARCH_STAR_V1_0)
2960 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2961 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2963 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2964 r += snprintf (buf + r, size -r, ", MAC");
2966 if (config & E_NDS32_HAS_DIV_INST)
2967 r += snprintf (buf + r, size -r, ", DIV");
2969 if (config & E_NDS32_HAS_16BIT_INST)
2970 r += snprintf (buf + r, size -r, ", 16b");
2974 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2976 if (version <= E_NDS32_ELF_VER_1_3)
2977 r += snprintf (buf + r, size -r, ", [B8]");
2979 r += snprintf (buf + r, size -r, ", EX9");
2982 if (config & E_NDS32_HAS_MAC_DX_INST)
2983 r += snprintf (buf + r, size -r, ", MAC_DX");
2985 if (config & E_NDS32_HAS_DIV_DX_INST)
2986 r += snprintf (buf + r, size -r, ", DIV_DX");
2988 if (config & E_NDS32_HAS_16BIT_INST)
2990 if (version <= E_NDS32_ELF_VER_1_3)
2991 r += snprintf (buf + r, size -r, ", 16b");
2993 r += snprintf (buf + r, size -r, ", IFC");
2997 if (config & E_NDS32_HAS_EXT_INST)
2998 r += snprintf (buf + r, size -r, ", PERF1");
3000 if (config & E_NDS32_HAS_EXT2_INST)
3001 r += snprintf (buf + r, size -r, ", PERF2");
3003 if (config & E_NDS32_HAS_FPU_INST)
3006 r += snprintf (buf + r, size -r, ", FPU_SP");
3009 if (config & E_NDS32_HAS_FPU_DP_INST)
3012 r += snprintf (buf + r, size -r, ", FPU_DP");
3015 if (config & E_NDS32_HAS_FPU_MAC_INST)
3018 r += snprintf (buf + r, size -r, ", FPU_MAC");
3023 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3025 case E_NDS32_FPU_REG_8SP_4DP:
3026 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3028 case E_NDS32_FPU_REG_16SP_8DP:
3029 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3031 case E_NDS32_FPU_REG_32SP_16DP:
3032 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3034 case E_NDS32_FPU_REG_32SP_32DP:
3035 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3040 if (config & E_NDS32_HAS_AUDIO_INST)
3041 r += snprintf (buf + r, size -r, ", AUDIO");
3043 if (config & E_NDS32_HAS_STRING_INST)
3044 r += snprintf (buf + r, size -r, ", STR");
3046 if (config & E_NDS32_HAS_REDUCED_REGS)
3047 r += snprintf (buf + r, size -r, ", 16REG");
3049 if (config & E_NDS32_HAS_VIDEO_INST)
3051 if (version <= E_NDS32_ELF_VER_1_3)
3052 r += snprintf (buf + r, size -r, ", VIDEO");
3054 r += snprintf (buf + r, size -r, ", SATURATION");
3057 if (config & E_NDS32_HAS_ENCRIPT_INST)
3058 r += snprintf (buf + r, size -r, ", ENCRP");
3060 if (config & E_NDS32_HAS_L2C_INST)
3061 r += snprintf (buf + r, size -r, ", L2C");
3065 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3067 static char buf[1024];
3078 case EM_ARC_COMPACT2:
3079 case EM_ARC_COMPACT:
3080 decode_ARC_machine_flags (e_flags, e_machine, buf);
3084 decode_ARM_machine_flags (e_flags, buf);
3088 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3092 if (e_flags & EF_BFIN_PIC)
3093 strcat (buf, ", PIC");
3095 if (e_flags & EF_BFIN_FDPIC)
3096 strcat (buf, ", FDPIC");
3098 if (e_flags & EF_BFIN_CODE_IN_L1)
3099 strcat (buf, ", code in L1");
3101 if (e_flags & EF_BFIN_DATA_IN_L1)
3102 strcat (buf, ", data in L1");
3107 switch (e_flags & EF_FRV_CPU_MASK)
3109 case EF_FRV_CPU_GENERIC:
3113 strcat (buf, ", fr???");
3116 case EF_FRV_CPU_FR300:
3117 strcat (buf, ", fr300");
3120 case EF_FRV_CPU_FR400:
3121 strcat (buf, ", fr400");
3123 case EF_FRV_CPU_FR405:
3124 strcat (buf, ", fr405");
3127 case EF_FRV_CPU_FR450:
3128 strcat (buf, ", fr450");
3131 case EF_FRV_CPU_FR500:
3132 strcat (buf, ", fr500");
3134 case EF_FRV_CPU_FR550:
3135 strcat (buf, ", fr550");
3138 case EF_FRV_CPU_SIMPLE:
3139 strcat (buf, ", simple");
3141 case EF_FRV_CPU_TOMCAT:
3142 strcat (buf, ", tomcat");
3148 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3149 strcat (buf, ", m68000");
3150 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3151 strcat (buf, ", cpu32");
3152 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3153 strcat (buf, ", fido_a");
3156 char const * isa = _("unknown");
3157 char const * mac = _("unknown mac");
3158 char const * additional = NULL;
3160 switch (e_flags & EF_M68K_CF_ISA_MASK)
3162 case EF_M68K_CF_ISA_A_NODIV:
3164 additional = ", nodiv";
3166 case EF_M68K_CF_ISA_A:
3169 case EF_M68K_CF_ISA_A_PLUS:
3172 case EF_M68K_CF_ISA_B_NOUSP:
3174 additional = ", nousp";
3176 case EF_M68K_CF_ISA_B:
3179 case EF_M68K_CF_ISA_C:
3182 case EF_M68K_CF_ISA_C_NODIV:
3184 additional = ", nodiv";
3187 strcat (buf, ", cf, isa ");
3190 strcat (buf, additional);
3191 if (e_flags & EF_M68K_CF_FLOAT)
3192 strcat (buf, ", float");
3193 switch (e_flags & EF_M68K_CF_MAC_MASK)
3198 case EF_M68K_CF_MAC:
3201 case EF_M68K_CF_EMAC:
3204 case EF_M68K_CF_EMAC_B:
3217 switch (e_flags & EF_MEP_CPU_MASK)
3219 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3220 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3221 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3222 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3223 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3224 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3225 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3228 switch (e_flags & EF_MEP_COP_MASK)
3230 case EF_MEP_COP_NONE: break;
3231 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3232 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3233 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3234 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3235 default: strcat (buf, _("<unknown MeP copro type>")); break;
3238 if (e_flags & EF_MEP_LIBRARY)
3239 strcat (buf, ", Built for Library");
3241 if (e_flags & EF_MEP_INDEX_MASK)
3242 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3243 e_flags & EF_MEP_INDEX_MASK);
3245 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3246 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3247 e_flags & ~ EF_MEP_ALL_FLAGS);
3251 if (e_flags & EF_PPC_EMB)
3252 strcat (buf, ", emb");
3254 if (e_flags & EF_PPC_RELOCATABLE)
3255 strcat (buf, _(", relocatable"));
3257 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3258 strcat (buf, _(", relocatable-lib"));
3262 if (e_flags & EF_PPC64_ABI)
3264 char abi[] = ", abiv0";
3266 abi[6] += e_flags & EF_PPC64_ABI;
3272 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3273 strcat (buf, ", RH850 ABI");
3275 if (e_flags & EF_V800_850E3)
3276 strcat (buf, ", V3 architecture");
3278 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3279 strcat (buf, ", FPU not used");
3281 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3282 strcat (buf, ", regmode: COMMON");
3284 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3285 strcat (buf, ", r4 not used");
3287 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3288 strcat (buf, ", r30 not used");
3290 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3291 strcat (buf, ", r5 not used");
3293 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3294 strcat (buf, ", r2 not used");
3296 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3298 switch (e_flags & - e_flags)
3300 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3301 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3302 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3303 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3304 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3305 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3306 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3307 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3308 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3309 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3310 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3311 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3318 case EM_CYGNUS_V850:
3319 switch (e_flags & EF_V850_ARCH)
3321 case E_V850E3V5_ARCH:
3322 strcat (buf, ", v850e3v5");
3324 case E_V850E2V3_ARCH:
3325 strcat (buf, ", v850e2v3");
3328 strcat (buf, ", v850e2");
3331 strcat (buf, ", v850e1");
3334 strcat (buf, ", v850e");
3337 strcat (buf, ", v850");
3340 strcat (buf, _(", unknown v850 architecture variant"));
3346 case EM_CYGNUS_M32R:
3347 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3348 strcat (buf, ", m32r");
3352 case EM_MIPS_RS3_LE:
3353 if (e_flags & EF_MIPS_NOREORDER)
3354 strcat (buf, ", noreorder");
3356 if (e_flags & EF_MIPS_PIC)
3357 strcat (buf, ", pic");
3359 if (e_flags & EF_MIPS_CPIC)
3360 strcat (buf, ", cpic");
3362 if (e_flags & EF_MIPS_UCODE)
3363 strcat (buf, ", ugen_reserved");
3365 if (e_flags & EF_MIPS_ABI2)
3366 strcat (buf, ", abi2");
3368 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3369 strcat (buf, ", odk first");
3371 if (e_flags & EF_MIPS_32BITMODE)
3372 strcat (buf, ", 32bitmode");
3374 if (e_flags & EF_MIPS_NAN2008)
3375 strcat (buf, ", nan2008");
3377 if (e_flags & EF_MIPS_FP64)
3378 strcat (buf, ", fp64");
3380 switch ((e_flags & EF_MIPS_MACH))
3382 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3383 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3384 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3385 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3386 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3387 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3388 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3389 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3390 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3391 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3392 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3393 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3394 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3395 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3396 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3397 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3398 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3399 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3400 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3402 /* We simply ignore the field in this case to avoid confusion:
3403 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3406 default: strcat (buf, _(", unknown CPU")); break;
3409 switch ((e_flags & EF_MIPS_ABI))
3411 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3412 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3413 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3414 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3416 /* We simply ignore the field in this case to avoid confusion:
3417 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3418 This means it is likely to be an o32 file, but not for
3421 default: strcat (buf, _(", unknown ABI")); break;
3424 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3425 strcat (buf, ", mdmx");
3427 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3428 strcat (buf, ", mips16");
3430 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3431 strcat (buf, ", micromips");
3433 switch ((e_flags & EF_MIPS_ARCH))
3435 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3436 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3437 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3438 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3439 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3440 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3441 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3442 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3443 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3444 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3445 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3446 default: strcat (buf, _(", unknown ISA")); break;
3451 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3455 switch (EF_NFP_MACH (e_flags))
3457 case E_NFP_MACH_3200:
3458 strcat (buf, ", NFP-32xx");
3460 case E_NFP_MACH_6000:
3461 strcat (buf, ", NFP-6xxx");
3467 if (e_flags & EF_RISCV_RVC)
3468 strcat (buf, ", RVC");
3470 switch (e_flags & EF_RISCV_FLOAT_ABI)
3472 case EF_RISCV_FLOAT_ABI_SOFT:
3473 strcat (buf, ", soft-float ABI");
3476 case EF_RISCV_FLOAT_ABI_SINGLE:
3477 strcat (buf, ", single-float ABI");
3480 case EF_RISCV_FLOAT_ABI_DOUBLE:
3481 strcat (buf, ", double-float ABI");
3484 case EF_RISCV_FLOAT_ABI_QUAD:
3485 strcat (buf, ", quad-float ABI");
3491 switch ((e_flags & EF_SH_MACH_MASK))
3493 case EF_SH1: strcat (buf, ", sh1"); break;
3494 case EF_SH2: strcat (buf, ", sh2"); break;
3495 case EF_SH3: strcat (buf, ", sh3"); break;
3496 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3497 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3498 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3499 case EF_SH3E: strcat (buf, ", sh3e"); break;
3500 case EF_SH4: strcat (buf, ", sh4"); break;
3501 case EF_SH5: strcat (buf, ", sh5"); break;
3502 case EF_SH2E: strcat (buf, ", sh2e"); break;
3503 case EF_SH4A: strcat (buf, ", sh4a"); break;
3504 case EF_SH2A: strcat (buf, ", sh2a"); break;
3505 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3506 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3507 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3508 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3509 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3510 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3511 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3512 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3513 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3514 default: strcat (buf, _(", unknown ISA")); break;
3517 if (e_flags & EF_SH_PIC)
3518 strcat (buf, ", pic");
3520 if (e_flags & EF_SH_FDPIC)
3521 strcat (buf, ", fdpic");
3525 if (e_flags & EF_OR1K_NODELAY)
3526 strcat (buf, ", no delay");
3530 if (e_flags & EF_SPARC_32PLUS)
3531 strcat (buf, ", v8+");
3533 if (e_flags & EF_SPARC_SUN_US1)
3534 strcat (buf, ", ultrasparcI");
3536 if (e_flags & EF_SPARC_SUN_US3)
3537 strcat (buf, ", ultrasparcIII");
3539 if (e_flags & EF_SPARC_HAL_R1)
3540 strcat (buf, ", halr1");
3542 if (e_flags & EF_SPARC_LEDATA)
3543 strcat (buf, ", ledata");
3545 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3546 strcat (buf, ", tso");
3548 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3549 strcat (buf, ", pso");
3551 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3552 strcat (buf, ", rmo");
3556 switch (e_flags & EF_PARISC_ARCH)
3558 case EFA_PARISC_1_0:
3559 strcpy (buf, ", PA-RISC 1.0");
3561 case EFA_PARISC_1_1:
3562 strcpy (buf, ", PA-RISC 1.1");
3564 case EFA_PARISC_2_0:
3565 strcpy (buf, ", PA-RISC 2.0");
3570 if (e_flags & EF_PARISC_TRAPNIL)
3571 strcat (buf, ", trapnil");
3572 if (e_flags & EF_PARISC_EXT)
3573 strcat (buf, ", ext");
3574 if (e_flags & EF_PARISC_LSB)
3575 strcat (buf, ", lsb");
3576 if (e_flags & EF_PARISC_WIDE)
3577 strcat (buf, ", wide");
3578 if (e_flags & EF_PARISC_NO_KABP)
3579 strcat (buf, ", no kabp");
3580 if (e_flags & EF_PARISC_LAZYSWAP)
3581 strcat (buf, ", lazyswap");
3586 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3587 strcat (buf, ", new calling convention");
3589 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3590 strcat (buf, ", gnu calling convention");
3594 if ((e_flags & EF_IA_64_ABI64))
3595 strcat (buf, ", 64-bit");
3597 strcat (buf, ", 32-bit");
3598 if ((e_flags & EF_IA_64_REDUCEDFP))
3599 strcat (buf, ", reduced fp model");
3600 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3601 strcat (buf, ", no function descriptors, constant gp");
3602 else if ((e_flags & EF_IA_64_CONS_GP))
3603 strcat (buf, ", constant gp");
3604 if ((e_flags & EF_IA_64_ABSOLUTE))
3605 strcat (buf, ", absolute");
3606 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3608 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3609 strcat (buf, ", vms_linkages");
3610 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3612 case EF_IA_64_VMS_COMCOD_SUCCESS:
3614 case EF_IA_64_VMS_COMCOD_WARNING:
3615 strcat (buf, ", warning");
3617 case EF_IA_64_VMS_COMCOD_ERROR:
3618 strcat (buf, ", error");
3620 case EF_IA_64_VMS_COMCOD_ABORT:
3621 strcat (buf, ", abort");
3624 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3625 e_flags & EF_IA_64_VMS_COMCOD);
3626 strcat (buf, ", <unknown>");
3632 if ((e_flags & EF_VAX_NONPIC))
3633 strcat (buf, ", non-PIC");
3634 if ((e_flags & EF_VAX_DFLOAT))
3635 strcat (buf, ", D-Float");
3636 if ((e_flags & EF_VAX_GFLOAT))
3637 strcat (buf, ", G-Float");
3641 if (e_flags & EF_VISIUM_ARCH_MCM)
3642 strcat (buf, ", mcm");
3643 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3644 strcat (buf, ", mcm24");
3645 if (e_flags & EF_VISIUM_ARCH_GR6)
3646 strcat (buf, ", gr6");
3650 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3652 case E_FLAG_RL78_ANY_CPU: break;
3653 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3654 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3655 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3657 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3658 strcat (buf, ", 64-bit doubles");
3662 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3663 strcat (buf, ", 64-bit doubles");
3664 if (e_flags & E_FLAG_RX_DSP)
3665 strcat (buf, ", dsp");
3666 if (e_flags & E_FLAG_RX_PID)
3667 strcat (buf, ", pid");
3668 if (e_flags & E_FLAG_RX_ABI)
3669 strcat (buf, ", RX ABI");
3670 if (e_flags & E_FLAG_RX_SINSNS_SET)
3671 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3672 ? ", uses String instructions" : ", bans String instructions");
3673 if (e_flags & E_FLAG_RX_V2)
3674 strcat (buf, ", V2");
3678 if (e_flags & EF_S390_HIGH_GPRS)
3679 strcat (buf, ", highgprs");
3683 if ((e_flags & EF_C6000_REL))
3684 strcat (buf, ", relocatable module");
3688 strcat (buf, _(": architecture variant: "));
3689 switch (e_flags & EF_MSP430_MACH)
3691 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3692 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3693 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3694 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3695 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3696 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3697 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3698 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3699 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3700 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3701 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3702 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3703 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3704 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3705 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3707 strcat (buf, _(": unknown")); break;
3710 if (e_flags & ~ EF_MSP430_MACH)
3711 strcat (buf, _(": unknown extra flag bits also present"));
3719 get_osabi_name (Filedata * filedata, unsigned int osabi)
3721 static char buff[32];
3725 case ELFOSABI_NONE: return "UNIX - System V";
3726 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3727 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3728 case ELFOSABI_GNU: return "UNIX - GNU";
3729 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3730 case ELFOSABI_AIX: return "UNIX - AIX";
3731 case ELFOSABI_IRIX: return "UNIX - IRIX";
3732 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3733 case ELFOSABI_TRU64: return "UNIX - TRU64";
3734 case ELFOSABI_MODESTO: return "Novell - Modesto";
3735 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3736 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3737 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3738 case ELFOSABI_AROS: return "AROS";
3739 case ELFOSABI_FENIXOS: return "FenixOS";
3740 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3741 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3744 switch (filedata->file_header.e_machine)
3749 case ELFOSABI_ARM: return "ARM";
3750 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3761 case ELFOSABI_STANDALONE: return _("Standalone App");
3770 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3771 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3780 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3786 get_aarch64_segment_type (unsigned long type)
3790 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3791 default: return NULL;
3796 get_arm_segment_type (unsigned long type)
3800 case PT_ARM_EXIDX: return "EXIDX";
3801 default: return NULL;
3806 get_s390_segment_type (unsigned long type)
3810 case PT_S390_PGSTE: return "S390_PGSTE";
3811 default: return NULL;
3816 get_mips_segment_type (unsigned long type)
3820 case PT_MIPS_REGINFO: return "REGINFO";
3821 case PT_MIPS_RTPROC: return "RTPROC";
3822 case PT_MIPS_OPTIONS: return "OPTIONS";
3823 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3824 default: return NULL;
3829 get_parisc_segment_type (unsigned long type)
3833 case PT_HP_TLS: return "HP_TLS";
3834 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3835 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3836 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3837 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3838 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3839 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3840 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3841 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3842 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3843 case PT_HP_PARALLEL: return "HP_PARALLEL";
3844 case PT_HP_FASTBIND: return "HP_FASTBIND";
3845 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3846 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3847 case PT_HP_STACK: return "HP_STACK";
3848 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3849 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3850 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3851 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3852 default: return NULL;
3857 get_ia64_segment_type (unsigned long type)
3861 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3862 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3863 case PT_HP_TLS: return "HP_TLS";
3864 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3865 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3866 case PT_IA_64_HP_STACK: return "HP_STACK";
3867 default: return NULL;
3872 get_tic6x_segment_type (unsigned long type)
3876 case PT_C6000_PHATTR: return "C6000_PHATTR";
3877 default: return NULL;
3882 get_solaris_segment_type (unsigned long type)
3886 case 0x6464e550: return "PT_SUNW_UNWIND";
3887 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3888 case 0x6ffffff7: return "PT_LOSUNW";
3889 case 0x6ffffffa: return "PT_SUNWBSS";
3890 case 0x6ffffffb: return "PT_SUNWSTACK";
3891 case 0x6ffffffc: return "PT_SUNWDTRACE";
3892 case 0x6ffffffd: return "PT_SUNWCAP";
3893 case 0x6fffffff: return "PT_HISUNW";
3894 default: return NULL;
3899 get_segment_type (Filedata * filedata, unsigned long p_type)
3901 static char buff[32];
3905 case PT_NULL: return "NULL";
3906 case PT_LOAD: return "LOAD";
3907 case PT_DYNAMIC: return "DYNAMIC";
3908 case PT_INTERP: return "INTERP";
3909 case PT_NOTE: return "NOTE";
3910 case PT_SHLIB: return "SHLIB";
3911 case PT_PHDR: return "PHDR";
3912 case PT_TLS: return "TLS";
3913 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3914 case PT_GNU_STACK: return "GNU_STACK";
3915 case PT_GNU_RELRO: return "GNU_RELRO";
3918 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3920 sprintf (buff, "GNU_MBIND+%#lx",
3921 p_type - PT_GNU_MBIND_LO);
3923 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3925 const char * result;
3927 switch (filedata->file_header.e_machine)
3930 result = get_aarch64_segment_type (p_type);
3933 result = get_arm_segment_type (p_type);
3936 case EM_MIPS_RS3_LE:
3937 result = get_mips_segment_type (p_type);
3940 result = get_parisc_segment_type (p_type);
3943 result = get_ia64_segment_type (p_type);
3946 result = get_tic6x_segment_type (p_type);
3950 result = get_s390_segment_type (p_type);
3960 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3962 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3964 const char * result;
3966 switch (filedata->file_header.e_machine)
3969 result = get_parisc_segment_type (p_type);
3972 result = get_ia64_segment_type (p_type);
3975 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3976 result = get_solaris_segment_type (p_type);
3985 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3988 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3995 get_arc_section_type_name (unsigned int sh_type)
3999 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4007 get_mips_section_type_name (unsigned int sh_type)
4011 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4012 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4013 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4014 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4015 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4016 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4017 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4018 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4019 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4020 case SHT_MIPS_RELD: return "MIPS_RELD";
4021 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4022 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4023 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4024 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4025 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4026 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4027 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4028 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4029 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4030 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4031 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4032 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4033 case SHT_MIPS_LINE: return "MIPS_LINE";
4034 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4035 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4036 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4037 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4038 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4039 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4040 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4041 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4042 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4043 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4044 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4045 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4046 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4047 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4048 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4049 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4050 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4058 get_parisc_section_type_name (unsigned int sh_type)
4062 case SHT_PARISC_EXT: return "PARISC_EXT";
4063 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4064 case SHT_PARISC_DOC: return "PARISC_DOC";
4065 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4066 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4067 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4068 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4069 default: return NULL;
4074 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4076 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4077 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4078 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4082 case SHT_IA_64_EXT: return "IA_64_EXT";
4083 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4084 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4085 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4086 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4087 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4088 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4089 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4090 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4091 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4099 get_x86_64_section_type_name (unsigned int sh_type)
4103 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4104 default: return NULL;
4109 get_aarch64_section_type_name (unsigned int sh_type)
4113 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4114 default: return NULL;
4119 get_arm_section_type_name (unsigned int sh_type)
4123 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4124 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4125 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4126 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4127 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4128 default: return NULL;
4133 get_tic6x_section_type_name (unsigned int sh_type)
4137 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4138 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4139 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4140 case SHT_TI_ICODE: return "TI_ICODE";
4141 case SHT_TI_XREF: return "TI_XREF";
4142 case SHT_TI_HANDLER: return "TI_HANDLER";
4143 case SHT_TI_INITINFO: return "TI_INITINFO";
4144 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4145 default: return NULL;
4150 get_msp430x_section_type_name (unsigned int sh_type)
4154 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4155 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4156 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4157 default: return NULL;
4162 get_nfp_section_type_name (unsigned int sh_type)
4166 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4167 case SHT_NFP_INITREG: return "NFP_INITREG";
4168 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4169 default: return NULL;
4174 get_v850_section_type_name (unsigned int sh_type)
4178 case SHT_V850_SCOMMON: return "V850 Small Common";
4179 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4180 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4181 case SHT_RENESAS_IOP: return "RENESAS IOP";
4182 case SHT_RENESAS_INFO: return "RENESAS INFO";
4183 default: return NULL;
4188 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4190 static char buff[32];
4191 const char * result;
4195 case SHT_NULL: return "NULL";
4196 case SHT_PROGBITS: return "PROGBITS";
4197 case SHT_SYMTAB: return "SYMTAB";
4198 case SHT_STRTAB: return "STRTAB";
4199 case SHT_RELA: return "RELA";
4200 case SHT_HASH: return "HASH";
4201 case SHT_DYNAMIC: return "DYNAMIC";
4202 case SHT_NOTE: return "NOTE";
4203 case SHT_NOBITS: return "NOBITS";
4204 case SHT_REL: return "REL";
4205 case SHT_SHLIB: return "SHLIB";
4206 case SHT_DYNSYM: return "DYNSYM";
4207 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4208 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4209 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4210 case SHT_GNU_HASH: return "GNU_HASH";
4211 case SHT_GROUP: return "GROUP";
4212 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
4213 case SHT_GNU_verdef: return "VERDEF";
4214 case SHT_GNU_verneed: return "VERNEED";
4215 case SHT_GNU_versym: return "VERSYM";
4216 case 0x6ffffff0: return "VERSYM";
4217 case 0x6ffffffc: return "VERDEF";
4218 case 0x7ffffffd: return "AUXILIARY";
4219 case 0x7fffffff: return "FILTER";
4220 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4223 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4225 switch (filedata->file_header.e_machine)
4228 case EM_ARC_COMPACT:
4229 case EM_ARC_COMPACT2:
4230 result = get_arc_section_type_name (sh_type);
4233 case EM_MIPS_RS3_LE:
4234 result = get_mips_section_type_name (sh_type);
4237 result = get_parisc_section_type_name (sh_type);
4240 result = get_ia64_section_type_name (filedata, sh_type);
4245 result = get_x86_64_section_type_name (sh_type);
4248 result = get_aarch64_section_type_name (sh_type);
4251 result = get_arm_section_type_name (sh_type);
4254 result = get_tic6x_section_type_name (sh_type);
4257 result = get_msp430x_section_type_name (sh_type);
4260 result = get_nfp_section_type_name (sh_type);
4264 case EM_CYGNUS_V850:
4265 result = get_v850_section_type_name (sh_type);
4275 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4277 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4279 switch (filedata->file_header.e_machine)
4282 result = get_ia64_section_type_name (filedata, sh_type);
4285 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4286 result = get_solaris_section_type (sh_type);
4291 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4292 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4293 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4294 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4306 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4308 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4310 switch (filedata->file_header.e_machine)
4314 case EM_CYGNUS_V850:
4315 result = get_v850_section_type_name (sh_type);
4325 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4328 /* This message is probably going to be displayed in a 15
4329 character wide field, so put the hex value first. */
4330 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4336 #define OPTION_DEBUG_DUMP 512
4337 #define OPTION_DYN_SYMS 513
4338 #define OPTION_DWARF_DEPTH 514
4339 #define OPTION_DWARF_START 515
4340 #define OPTION_DWARF_CHECK 516
4342 static struct option options[] =
4344 {"all", no_argument, 0, 'a'},
4345 {"file-header", no_argument, 0, 'h'},
4346 {"program-headers", no_argument, 0, 'l'},
4347 {"headers", no_argument, 0, 'e'},
4348 {"histogram", no_argument, 0, 'I'},
4349 {"segments", no_argument, 0, 'l'},
4350 {"sections", no_argument, 0, 'S'},
4351 {"section-headers", no_argument, 0, 'S'},
4352 {"section-groups", no_argument, 0, 'g'},
4353 {"section-details", no_argument, 0, 't'},
4354 {"full-section-name",no_argument, 0, 'N'},
4355 {"symbols", no_argument, 0, 's'},
4356 {"syms", no_argument, 0, 's'},
4357 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4358 {"relocs", no_argument, 0, 'r'},
4359 {"notes", no_argument, 0, 'n'},
4360 {"dynamic", no_argument, 0, 'd'},
4361 {"arch-specific", no_argument, 0, 'A'},
4362 {"version-info", no_argument, 0, 'V'},
4363 {"use-dynamic", no_argument, 0, 'D'},
4364 {"unwind", no_argument, 0, 'u'},
4365 {"archive-index", no_argument, 0, 'c'},
4366 {"hex-dump", required_argument, 0, 'x'},
4367 {"relocated-dump", required_argument, 0, 'R'},
4368 {"string-dump", required_argument, 0, 'p'},
4369 {"decompress", no_argument, 0, 'z'},
4370 #ifdef SUPPORT_DISASSEMBLY
4371 {"instruction-dump", required_argument, 0, 'i'},
4373 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4375 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4376 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4377 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4379 {"version", no_argument, 0, 'v'},
4380 {"wide", no_argument, 0, 'W'},
4381 {"help", no_argument, 0, 'H'},
4382 {0, no_argument, 0, 0}
4386 usage (FILE * stream)
4388 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4389 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4390 fprintf (stream, _(" Options are:\n\
4391 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4392 -h --file-header Display the ELF file header\n\
4393 -l --program-headers Display the program headers\n\
4394 --segments An alias for --program-headers\n\
4395 -S --section-headers Display the sections' header\n\
4396 --sections An alias for --section-headers\n\
4397 -g --section-groups Display the section groups\n\
4398 -t --section-details Display the section details\n\
4399 -e --headers Equivalent to: -h -l -S\n\
4400 -s --syms Display the symbol table\n\
4401 --symbols An alias for --syms\n\
4402 --dyn-syms Display the dynamic symbol table\n\
4403 -n --notes Display the core notes (if present)\n\
4404 -r --relocs Display the relocations (if present)\n\
4405 -u --unwind Display the unwind info (if present)\n\
4406 -d --dynamic Display the dynamic section (if present)\n\
4407 -V --version-info Display the version sections (if present)\n\
4408 -A --arch-specific Display architecture specific information (if any)\n\
4409 -c --archive-index Display the symbol/file index in an archive\n\
4410 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4411 -x --hex-dump=<number|name>\n\
4412 Dump the contents of section <number|name> as bytes\n\
4413 -p --string-dump=<number|name>\n\
4414 Dump the contents of section <number|name> as strings\n\
4415 -R --relocated-dump=<number|name>\n\
4416 Dump the contents of section <number|name> as relocated bytes\n\
4417 -z --decompress Decompress section before dumping it\n\
4418 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4419 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4420 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4421 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4422 =addr,=cu_index,=links,=follow-links]\n\
4423 Display the contents of DWARF debug sections\n"));
4424 fprintf (stream, _("\
4425 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4426 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4428 #ifdef SUPPORT_DISASSEMBLY
4429 fprintf (stream, _("\
4430 -i --instruction-dump=<number|name>\n\
4431 Disassemble the contents of section <number|name>\n"));
4433 fprintf (stream, _("\
4434 -I --histogram Display histogram of bucket list lengths\n\
4435 -W --wide Allow output width to exceed 80 characters\n\
4436 @<file> Read options from <file>\n\
4437 -H --help Display this information\n\
4438 -v --version Display the version number of readelf\n"));
4440 if (REPORT_BUGS_TO[0] && stream == stdout)
4441 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4443 exit (stream == stdout ? 0 : 1);
4446 /* Record the fact that the user wants the contents of section number
4447 SECTION to be displayed using the method(s) encoded as flags bits
4448 in TYPE. Note, TYPE can be zero if we are creating the array for
4452 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4454 if (section >= filedata->num_dump_sects)
4456 dump_type * new_dump_sects;
4458 new_dump_sects = (dump_type *) calloc (section + 1,
4459 sizeof (* new_dump_sects));
4461 if (new_dump_sects == NULL)
4462 error (_("Out of memory allocating dump request table.\n"));
4465 if (filedata->dump_sects)
4467 /* Copy current flag settings. */
4468 memcpy (new_dump_sects, filedata->dump_sects,
4469 filedata->num_dump_sects * sizeof (* new_dump_sects));
4471 free (filedata->dump_sects);
4474 filedata->dump_sects = new_dump_sects;
4475 filedata->num_dump_sects = section + 1;
4479 if (filedata->dump_sects)
4480 filedata->dump_sects[section] |= type;
4483 /* Request a dump by section name. */
4486 request_dump_byname (const char * section, dump_type type)
4488 struct dump_list_entry * new_request;
4490 new_request = (struct dump_list_entry *)
4491 malloc (sizeof (struct dump_list_entry));
4493 error (_("Out of memory allocating dump request table.\n"));
4495 new_request->name = strdup (section);
4496 if (!new_request->name)
4497 error (_("Out of memory allocating dump request table.\n"));
4499 new_request->type = type;
4501 new_request->next = dump_sects_byname;
4502 dump_sects_byname = new_request;
4506 request_dump (Filedata * filedata, dump_type type)
4512 section = strtoul (optarg, & cp, 0);
4514 if (! *cp && section >= 0)
4515 request_dump_bynumber (filedata, section, type);
4517 request_dump_byname (optarg, type);
4521 parse_args (Filedata * filedata, int argc, char ** argv)
4528 while ((c = getopt_long
4529 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4547 do_section_groups = TRUE;
4550 do_histogram = TRUE;
4555 do_section_groups = TRUE;
4560 do_section_details = TRUE;
4571 do_using_dynamic = TRUE;
4595 do_histogram = TRUE;
4601 do_archive_index = TRUE;
4604 request_dump (filedata, HEX_DUMP);
4607 request_dump (filedata, STRING_DUMP);
4610 request_dump (filedata, RELOC_DUMP);
4613 decompress_dumps = TRUE;
4619 do_debugging = TRUE;
4620 dwarf_select_sections_all ();
4624 do_debugging = FALSE;
4625 dwarf_select_sections_by_letters (optarg);
4628 case OPTION_DEBUG_DUMP:
4631 do_debugging = TRUE;
4634 do_debugging = FALSE;
4635 dwarf_select_sections_by_names (optarg);
4638 case OPTION_DWARF_DEPTH:
4642 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4645 case OPTION_DWARF_START:
4649 dwarf_start_die = strtoul (optarg, & cp, 0);
4652 case OPTION_DWARF_CHECK:
4655 case OPTION_DYN_SYMS:
4658 #ifdef SUPPORT_DISASSEMBLY
4660 request_dump (filedata, DISASS_DUMP);
4664 print_version (program_name);
4673 /* xgettext:c-format */
4674 error (_("Invalid option '-%c'\n"), c);
4681 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4682 && !do_segments && !do_header && !do_dump && !do_version
4683 && !do_histogram && !do_debugging && !do_arch && !do_notes
4684 && !do_section_groups && !do_archive_index
4690 get_elf_class (unsigned int elf_class)
4692 static char buff[32];
4696 case ELFCLASSNONE: return _("none");
4697 case ELFCLASS32: return "ELF32";
4698 case ELFCLASS64: return "ELF64";
4700 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4706 get_data_encoding (unsigned int encoding)
4708 static char buff[32];
4712 case ELFDATANONE: return _("none");
4713 case ELFDATA2LSB: return _("2's complement, little endian");
4714 case ELFDATA2MSB: return _("2's complement, big endian");
4716 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4721 /* Decode the data held in 'filedata->file_header'. */
4724 process_file_header (Filedata * filedata)
4726 Elf_Internal_Ehdr * header = & filedata->file_header;
4728 if ( header->e_ident[EI_MAG0] != ELFMAG0
4729 || header->e_ident[EI_MAG1] != ELFMAG1
4730 || header->e_ident[EI_MAG2] != ELFMAG2
4731 || header->e_ident[EI_MAG3] != ELFMAG3)
4734 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4738 init_dwarf_regnames (header->e_machine);
4744 printf (_("ELF Header:\n"));
4745 printf (_(" Magic: "));
4746 for (i = 0; i < EI_NIDENT; i++)
4747 printf ("%2.2x ", header->e_ident[i]);
4749 printf (_(" Class: %s\n"),
4750 get_elf_class (header->e_ident[EI_CLASS]));
4751 printf (_(" Data: %s\n"),
4752 get_data_encoding (header->e_ident[EI_DATA]));
4753 printf (_(" Version: %d %s\n"),
4754 header->e_ident[EI_VERSION],
4755 (header->e_ident[EI_VERSION] == EV_CURRENT
4757 : (header->e_ident[EI_VERSION] != EV_NONE
4758 ? _("<unknown: %lx>")
4760 printf (_(" OS/ABI: %s\n"),
4761 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4762 printf (_(" ABI Version: %d\n"),
4763 header->e_ident[EI_ABIVERSION]);
4764 printf (_(" Type: %s\n"),
4765 get_file_type (header->e_type));
4766 printf (_(" Machine: %s\n"),
4767 get_machine_name (header->e_machine));
4768 printf (_(" Version: 0x%lx\n"),
4769 (unsigned long) header->e_version);
4771 printf (_(" Entry point address: "));
4772 print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4773 printf (_("\n Start of program headers: "));
4774 print_vma ((bfd_vma) header->e_phoff, DEC);
4775 printf (_(" (bytes into file)\n Start of section headers: "));
4776 print_vma ((bfd_vma) header->e_shoff, DEC);
4777 printf (_(" (bytes into file)\n"));
4779 printf (_(" Flags: 0x%lx%s\n"),
4780 (unsigned long) header->e_flags,
4781 get_machine_flags (filedata, header->e_flags, header->e_machine));
4782 printf (_(" Size of this header: %ld (bytes)\n"),
4783 (long) header->e_ehsize);
4784 printf (_(" Size of program headers: %ld (bytes)\n"),
4785 (long) header->e_phentsize);
4786 printf (_(" Number of program headers: %ld"),
4787 (long) header->e_phnum);
4788 if (filedata->section_headers != NULL
4789 && header->e_phnum == PN_XNUM
4790 && filedata->section_headers[0].sh_info != 0)
4791 printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4792 putc ('\n', stdout);
4793 printf (_(" Size of section headers: %ld (bytes)\n"),
4794 (long) header->e_shentsize);
4795 printf (_(" Number of section headers: %ld"),
4796 (long) header->e_shnum);
4797 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4798 printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4799 putc ('\n', stdout);
4800 printf (_(" Section header string table index: %ld"),
4801 (long) header->e_shstrndx);
4802 if (filedata->section_headers != NULL
4803 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4804 printf (" (%u)", filedata->section_headers[0].sh_link);
4805 else if (header->e_shstrndx != SHN_UNDEF
4806 && header->e_shstrndx >= header->e_shnum)
4807 printf (_(" <corrupt: out of range>"));
4808 putc ('\n', stdout);
4811 if (filedata->section_headers != NULL)
4813 if (header->e_phnum == PN_XNUM
4814 && filedata->section_headers[0].sh_info != 0)
4815 header->e_phnum = filedata->section_headers[0].sh_info;
4816 if (header->e_shnum == SHN_UNDEF)
4817 header->e_shnum = filedata->section_headers[0].sh_size;
4818 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4819 header->e_shstrndx = filedata->section_headers[0].sh_link;
4820 if (header->e_shstrndx >= header->e_shnum)
4821 header->e_shstrndx = SHN_UNDEF;
4822 free (filedata->section_headers);
4823 filedata->section_headers = NULL;
4829 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4830 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4833 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4835 Elf32_External_Phdr * phdrs;
4836 Elf32_External_Phdr * external;
4837 Elf_Internal_Phdr * internal;
4839 unsigned int size = filedata->file_header.e_phentsize;
4840 unsigned int num = filedata->file_header.e_phnum;
4842 /* PR binutils/17531: Cope with unexpected section header sizes. */
4843 if (size == 0 || num == 0)
4845 if (size < sizeof * phdrs)
4847 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4850 if (size > sizeof * phdrs)
4851 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4853 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4854 size, num, _("program headers"));
4858 for (i = 0, internal = pheaders, external = phdrs;
4859 i < filedata->file_header.e_phnum;
4860 i++, internal++, external++)
4862 internal->p_type = BYTE_GET (external->p_type);
4863 internal->p_offset = BYTE_GET (external->p_offset);
4864 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4865 internal->p_paddr = BYTE_GET (external->p_paddr);
4866 internal->p_filesz = BYTE_GET (external->p_filesz);
4867 internal->p_memsz = BYTE_GET (external->p_memsz);
4868 internal->p_flags = BYTE_GET (external->p_flags);
4869 internal->p_align = BYTE_GET (external->p_align);
4876 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4877 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4880 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4882 Elf64_External_Phdr * phdrs;
4883 Elf64_External_Phdr * external;
4884 Elf_Internal_Phdr * internal;
4886 unsigned int size = filedata->file_header.e_phentsize;
4887 unsigned int num = filedata->file_header.e_phnum;
4889 /* PR binutils/17531: Cope with unexpected section header sizes. */
4890 if (size == 0 || num == 0)
4892 if (size < sizeof * phdrs)
4894 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4897 if (size > sizeof * phdrs)
4898 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4900 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4901 size, num, _("program headers"));
4905 for (i = 0, internal = pheaders, external = phdrs;
4906 i < filedata->file_header.e_phnum;
4907 i++, internal++, external++)
4909 internal->p_type = BYTE_GET (external->p_type);
4910 internal->p_flags = BYTE_GET (external->p_flags);
4911 internal->p_offset = BYTE_GET (external->p_offset);
4912 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4913 internal->p_paddr = BYTE_GET (external->p_paddr);
4914 internal->p_filesz = BYTE_GET (external->p_filesz);
4915 internal->p_memsz = BYTE_GET (external->p_memsz);
4916 internal->p_align = BYTE_GET (external->p_align);
4923 /* Returns TRUE if the program headers were read into `program_headers'. */
4926 get_program_headers (Filedata * filedata)
4928 Elf_Internal_Phdr * phdrs;
4930 /* Check cache of prior read. */
4931 if (filedata->program_headers != NULL)
4934 /* Be kind to memory checkers by looking for
4935 e_phnum values which we know must be invalid. */
4936 if (filedata->file_header.e_phnum
4937 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4938 >= filedata->file_size)
4940 error (_("Too many program headers - %#x - the file is not that big\n"),
4941 filedata->file_header.e_phnum);
4945 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4946 sizeof (Elf_Internal_Phdr));
4949 error (_("Out of memory reading %u program headers\n"),
4950 filedata->file_header.e_phnum);
4955 ? get_32bit_program_headers (filedata, phdrs)
4956 : get_64bit_program_headers (filedata, phdrs))
4958 filedata->program_headers = phdrs;
4966 /* Returns TRUE if the program headers were loaded. */
4969 process_program_headers (Filedata * filedata)
4971 Elf_Internal_Phdr * segment;
4973 Elf_Internal_Phdr * previous_load = NULL;
4975 if (filedata->file_header.e_phnum == 0)
4977 /* PR binutils/12467. */
4978 if (filedata->file_header.e_phoff != 0)
4980 warn (_("possibly corrupt ELF header - it has a non-zero program"
4981 " header offset, but no program headers\n"));
4984 else if (do_segments)
4985 printf (_("\nThere are no program headers in this file.\n"));
4989 if (do_segments && !do_header)
4991 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4992 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4993 printf (ngettext ("There is %d program header, starting at offset %s\n",
4994 "There are %d program headers, starting at offset %s\n",
4995 filedata->file_header.e_phnum),
4996 filedata->file_header.e_phnum,
4997 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5000 if (! get_program_headers (filedata))
5005 if (filedata->file_header.e_phnum > 1)
5006 printf (_("\nProgram Headers:\n"));
5008 printf (_("\nProgram Headers:\n"));
5012 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5015 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5019 (_(" Type Offset VirtAddr PhysAddr\n"));
5021 (_(" FileSiz MemSiz Flags Align\n"));
5028 for (i = 0, segment = filedata->program_headers;
5029 i < filedata->file_header.e_phnum;
5034 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5038 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5039 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5040 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5041 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5042 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5044 (segment->p_flags & PF_R ? 'R' : ' '),
5045 (segment->p_flags & PF_W ? 'W' : ' '),
5046 (segment->p_flags & PF_X ? 'E' : ' '));
5047 printf ("%#lx", (unsigned long) segment->p_align);
5051 if ((unsigned long) segment->p_offset == segment->p_offset)
5052 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5055 print_vma (segment->p_offset, FULL_HEX);
5059 print_vma (segment->p_vaddr, FULL_HEX);
5061 print_vma (segment->p_paddr, FULL_HEX);
5064 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5065 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5068 print_vma (segment->p_filesz, FULL_HEX);
5072 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5073 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5076 print_vma (segment->p_memsz, FULL_HEX);
5080 (segment->p_flags & PF_R ? 'R' : ' '),
5081 (segment->p_flags & PF_W ? 'W' : ' '),
5082 (segment->p_flags & PF_X ? 'E' : ' '));
5084 if ((unsigned long) segment->p_align == segment->p_align)
5085 printf ("%#lx", (unsigned long) segment->p_align);
5088 print_vma (segment->p_align, PREFIX_HEX);
5093 print_vma (segment->p_offset, FULL_HEX);
5095 print_vma (segment->p_vaddr, FULL_HEX);
5097 print_vma (segment->p_paddr, FULL_HEX);
5099 print_vma (segment->p_filesz, FULL_HEX);
5101 print_vma (segment->p_memsz, FULL_HEX);
5103 (segment->p_flags & PF_R ? 'R' : ' '),
5104 (segment->p_flags & PF_W ? 'W' : ' '),
5105 (segment->p_flags & PF_X ? 'E' : ' '));
5106 print_vma (segment->p_align, PREFIX_HEX);
5109 putc ('\n', stdout);
5112 switch (segment->p_type)
5115 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5116 required by the ELF standard, several programs, including the Linux
5117 kernel, make use of non-ordered segments. */
5119 && previous_load->p_vaddr > segment->p_vaddr)
5120 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5122 if (segment->p_memsz < segment->p_filesz)
5123 error (_("the segment's file size is larger than its memory size\n"));
5124 previous_load = segment;
5128 /* PR 20815 - Verify that the program header is loaded into memory. */
5129 if (i > 0 && previous_load != NULL)
5130 error (_("the PHDR segment must occur before any LOAD segment\n"));
5131 if (filedata->file_header.e_machine != EM_PARISC)
5135 for (j = 1; j < filedata->file_header.e_phnum; j++)
5136 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5137 && (filedata->program_headers[j].p_vaddr
5138 + filedata->program_headers[j].p_memsz)
5139 >= (segment->p_vaddr + segment->p_filesz))
5141 if (j == filedata->file_header.e_phnum)
5142 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5148 error (_("more than one dynamic segment\n"));
5150 /* By default, assume that the .dynamic section is the first
5151 section in the DYNAMIC segment. */
5152 dynamic_addr = segment->p_offset;
5153 dynamic_size = segment->p_filesz;
5155 /* Try to locate the .dynamic section. If there is
5156 a section header table, we can easily locate it. */
5157 if (filedata->section_headers != NULL)
5159 Elf_Internal_Shdr * sec;
5161 sec = find_section (filedata, ".dynamic");
5162 if (sec == NULL || sec->sh_size == 0)
5164 /* A corresponding .dynamic section is expected, but on
5165 IA-64/OpenVMS it is OK for it to be missing. */
5166 if (!is_ia64_vms (filedata))
5167 error (_("no .dynamic section in the dynamic segment\n"));
5171 if (sec->sh_type == SHT_NOBITS)
5177 dynamic_addr = sec->sh_offset;
5178 dynamic_size = sec->sh_size;
5180 if (dynamic_addr < segment->p_offset
5181 || dynamic_addr > segment->p_offset + segment->p_filesz)
5182 warn (_("the .dynamic section is not contained"
5183 " within the dynamic segment\n"));
5184 else if (dynamic_addr > segment->p_offset)
5185 warn (_("the .dynamic section is not the first section"
5186 " in the dynamic segment.\n"));
5189 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5190 segment. Check this after matching against the section headers
5191 so we don't warn on debuginfo file (which have NOBITS .dynamic
5193 if (dynamic_addr + dynamic_size >= filedata->file_size)
5195 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5196 dynamic_addr = dynamic_size = 0;
5201 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5203 error (_("Unable to find program interpreter name\n"));
5207 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5209 if (ret >= (int) sizeof (fmt) || ret < 0)
5210 error (_("Internal error: failed to create format string to display program interpreter\n"));
5212 program_interpreter[0] = 0;
5213 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5214 error (_("Unable to read program interpreter name\n"));
5217 printf (_(" [Requesting program interpreter: %s]\n"),
5218 program_interpreter);
5225 && filedata->section_headers != NULL
5226 && filedata->string_table != NULL)
5228 printf (_("\n Section to Segment mapping:\n"));
5229 printf (_(" Segment Sections...\n"));
5231 for (i = 0; i < filedata->file_header.e_phnum; i++)
5234 Elf_Internal_Shdr * section;
5236 segment = filedata->program_headers + i;
5237 section = filedata->section_headers + 1;
5239 printf (" %2.2d ", i);
5241 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5243 if (!ELF_TBSS_SPECIAL (section, segment)
5244 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5245 printf ("%s ", printable_section_name (filedata, section));
5256 /* Find the file offset corresponding to VMA by using the program headers. */
5259 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5261 Elf_Internal_Phdr * seg;
5263 if (! get_program_headers (filedata))
5265 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5269 for (seg = filedata->program_headers;
5270 seg < filedata->program_headers + filedata->file_header.e_phnum;
5273 if (seg->p_type != PT_LOAD)
5276 if (vma >= (seg->p_vaddr & -seg->p_align)
5277 && vma + size <= seg->p_vaddr + seg->p_filesz)
5278 return vma - seg->p_vaddr + seg->p_offset;
5281 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5282 (unsigned long) vma);
5287 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5288 If PROBE is true, this is just a probe and we do not generate any error
5289 messages if the load fails. */
5292 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5294 Elf32_External_Shdr * shdrs;
5295 Elf_Internal_Shdr * internal;
5297 unsigned int size = filedata->file_header.e_shentsize;
5298 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5300 /* PR binutils/17531: Cope with unexpected section header sizes. */
5301 if (size == 0 || num == 0)
5303 if (size < sizeof * shdrs)
5306 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5309 if (!probe && size > sizeof * shdrs)
5310 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5312 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5314 probe ? NULL : _("section headers"));
5318 free (filedata->section_headers);
5319 filedata->section_headers = (Elf_Internal_Shdr *)
5320 cmalloc (num, sizeof (Elf_Internal_Shdr));
5321 if (filedata->section_headers == NULL)
5324 error (_("Out of memory reading %u section headers\n"), num);
5328 for (i = 0, internal = filedata->section_headers;
5332 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5333 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5334 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5335 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5336 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5337 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5338 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5339 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5340 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5341 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5342 if (!probe && internal->sh_link > num)
5343 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5344 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5345 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5352 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5355 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5357 Elf64_External_Shdr * shdrs;
5358 Elf_Internal_Shdr * internal;
5360 unsigned int size = filedata->file_header.e_shentsize;
5361 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5363 /* PR binutils/17531: Cope with unexpected section header sizes. */
5364 if (size == 0 || num == 0)
5367 if (size < sizeof * shdrs)
5370 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5374 if (! probe && size > sizeof * shdrs)
5375 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5377 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5378 filedata->file_header.e_shoff,
5380 probe ? NULL : _("section headers"));
5384 free (filedata->section_headers);
5385 filedata->section_headers = (Elf_Internal_Shdr *)
5386 cmalloc (num, sizeof (Elf_Internal_Shdr));
5387 if (filedata->section_headers == NULL)
5390 error (_("Out of memory reading %u section headers\n"), num);
5394 for (i = 0, internal = filedata->section_headers;
5398 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5399 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5400 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5401 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5402 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5403 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5404 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5405 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5406 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5407 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5408 if (!probe && internal->sh_link > num)
5409 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5410 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5411 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5418 static Elf_Internal_Sym *
5419 get_32bit_elf_symbols (Filedata * filedata,
5420 Elf_Internal_Shdr * section,
5421 unsigned long * num_syms_return)
5423 unsigned long number = 0;
5424 Elf32_External_Sym * esyms = NULL;
5425 Elf_External_Sym_Shndx * shndx = NULL;
5426 Elf_Internal_Sym * isyms = NULL;
5427 Elf_Internal_Sym * psym;
5430 if (section->sh_size == 0)
5432 if (num_syms_return != NULL)
5433 * num_syms_return = 0;
5437 /* Run some sanity checks first. */
5438 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5440 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5441 printable_section_name (filedata, section),
5442 (unsigned long) section->sh_entsize);
5446 if (section->sh_size > filedata->file_size)
5448 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5449 printable_section_name (filedata, section),
5450 (unsigned long) section->sh_size);
5454 number = section->sh_size / section->sh_entsize;
5456 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5458 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5459 (unsigned long) section->sh_size,
5460 printable_section_name (filedata, section),
5461 (unsigned long) section->sh_entsize);
5465 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5466 section->sh_size, _("symbols"));
5471 elf_section_list * entry;
5474 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5475 if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5477 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5478 entry->hdr->sh_offset,
5479 1, entry->hdr->sh_size,
5480 _("symbol table section indicies"));
5483 /* PR17531: file: heap-buffer-overflow */
5484 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5486 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5487 printable_section_name (filedata, entry->hdr),
5488 (unsigned long) entry->hdr->sh_size,
5489 (unsigned long) section->sh_size);
5495 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5499 error (_("Out of memory reading %lu symbols\n"),
5500 (unsigned long) number);
5504 for (j = 0, psym = isyms; j < number; j++, psym++)
5506 psym->st_name = BYTE_GET (esyms[j].st_name);
5507 psym->st_value = BYTE_GET (esyms[j].st_value);
5508 psym->st_size = BYTE_GET (esyms[j].st_size);
5509 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5510 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5512 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5513 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5514 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5515 psym->st_info = BYTE_GET (esyms[j].st_info);
5516 psym->st_other = BYTE_GET (esyms[j].st_other);
5525 if (num_syms_return != NULL)
5526 * num_syms_return = isyms == NULL ? 0 : number;
5531 static Elf_Internal_Sym *
5532 get_64bit_elf_symbols (Filedata * filedata,
5533 Elf_Internal_Shdr * section,
5534 unsigned long * num_syms_return)
5536 unsigned long number = 0;
5537 Elf64_External_Sym * esyms = NULL;
5538 Elf_External_Sym_Shndx * shndx = NULL;
5539 Elf_Internal_Sym * isyms = NULL;
5540 Elf_Internal_Sym * psym;
5543 if (section->sh_size == 0)
5545 if (num_syms_return != NULL)
5546 * num_syms_return = 0;
5550 /* Run some sanity checks first. */
5551 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5553 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5554 printable_section_name (filedata, section),
5555 (unsigned long) section->sh_entsize);
5559 if (section->sh_size > filedata->file_size)
5561 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5562 printable_section_name (filedata, section),
5563 (unsigned long) section->sh_size);
5567 number = section->sh_size / section->sh_entsize;
5569 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5571 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5572 (unsigned long) section->sh_size,
5573 printable_section_name (filedata, section),
5574 (unsigned long) section->sh_entsize);
5578 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5579 section->sh_size, _("symbols"));
5584 elf_section_list * entry;
5587 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5588 if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5590 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5591 entry->hdr->sh_offset,
5592 1, entry->hdr->sh_size,
5593 _("symbol table section indicies"));
5596 /* PR17531: file: heap-buffer-overflow */
5597 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5599 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5600 printable_section_name (filedata, entry->hdr),
5601 (unsigned long) entry->hdr->sh_size,
5602 (unsigned long) section->sh_size);
5608 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5612 error (_("Out of memory reading %lu symbols\n"),
5613 (unsigned long) number);
5617 for (j = 0, psym = isyms; j < number; j++, psym++)
5619 psym->st_name = BYTE_GET (esyms[j].st_name);
5620 psym->st_info = BYTE_GET (esyms[j].st_info);
5621 psym->st_other = BYTE_GET (esyms[j].st_other);
5622 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5624 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5626 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5627 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5628 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5630 psym->st_value = BYTE_GET (esyms[j].st_value);
5631 psym->st_size = BYTE_GET (esyms[j].st_size);
5640 if (num_syms_return != NULL)
5641 * num_syms_return = isyms == NULL ? 0 : number;
5647 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5649 static char buff[1024];
5651 unsigned int field_size = is_32bit_elf ? 8 : 16;
5653 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5654 bfd_vma os_flags = 0;
5655 bfd_vma proc_flags = 0;
5656 bfd_vma unknown_flags = 0;
5664 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5665 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5666 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5667 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5668 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5669 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5670 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5671 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5672 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5673 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5674 /* IA-64 specific. */
5675 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5676 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5677 /* IA-64 OpenVMS specific. */
5678 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5679 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5680 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5681 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5682 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5683 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5685 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5686 /* SPARC specific. */
5687 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5688 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5690 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5691 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5692 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5694 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5696 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5699 if (do_section_details)
5701 sprintf (buff, "[%*.*lx]: ",
5702 field_size, field_size, (unsigned long) sh_flags);
5703 p += field_size + 4;
5710 flag = sh_flags & - sh_flags;
5713 if (do_section_details)
5717 case SHF_WRITE: sindex = 0; break;
5718 case SHF_ALLOC: sindex = 1; break;
5719 case SHF_EXECINSTR: sindex = 2; break;
5720 case SHF_MERGE: sindex = 3; break;
5721 case SHF_STRINGS: sindex = 4; break;
5722 case SHF_INFO_LINK: sindex = 5; break;
5723 case SHF_LINK_ORDER: sindex = 6; break;
5724 case SHF_OS_NONCONFORMING: sindex = 7; break;
5725 case SHF_GROUP: sindex = 8; break;
5726 case SHF_TLS: sindex = 9; break;
5727 case SHF_EXCLUDE: sindex = 18; break;
5728 case SHF_COMPRESSED: sindex = 20; break;
5729 case SHF_GNU_MBIND: sindex = 24; break;
5733 switch (filedata->file_header.e_machine)
5736 if (flag == SHF_IA_64_SHORT)
5738 else if (flag == SHF_IA_64_NORECOV)
5741 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5744 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5745 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5746 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5747 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5748 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5749 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5760 case EM_OLD_SPARCV9:
5761 case EM_SPARC32PLUS:
5764 if (flag == SHF_ORDERED)
5771 case SHF_ENTRYSECT: sindex = 21; break;
5772 case SHF_ARM_PURECODE: sindex = 22; break;
5773 case SHF_COMDEF: sindex = 23; break;
5778 if (flag == SHF_PPC_VLE)
5789 if (p != buff + field_size + 4)
5791 if (size < (10 + 2))
5793 warn (_("Internal error: not enough buffer room for section flag info"));
5794 return _("<unknown>");
5801 size -= flags [sindex].len;
5802 p = stpcpy (p, flags [sindex].str);
5804 else if (flag & SHF_MASKOS)
5806 else if (flag & SHF_MASKPROC)
5809 unknown_flags |= flag;
5815 case SHF_WRITE: *p = 'W'; break;
5816 case SHF_ALLOC: *p = 'A'; break;
5817 case SHF_EXECINSTR: *p = 'X'; break;
5818 case SHF_MERGE: *p = 'M'; break;
5819 case SHF_STRINGS: *p = 'S'; break;
5820 case SHF_INFO_LINK: *p = 'I'; break;
5821 case SHF_LINK_ORDER: *p = 'L'; break;
5822 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5823 case SHF_GROUP: *p = 'G'; break;
5824 case SHF_TLS: *p = 'T'; break;
5825 case SHF_EXCLUDE: *p = 'E'; break;
5826 case SHF_COMPRESSED: *p = 'C'; break;
5827 case SHF_GNU_MBIND: *p = 'D'; break;
5830 if ((filedata->file_header.e_machine == EM_X86_64
5831 || filedata->file_header.e_machine == EM_L1OM
5832 || filedata->file_header.e_machine == EM_K1OM)
5833 && flag == SHF_X86_64_LARGE)
5835 else if (filedata->file_header.e_machine == EM_ARM
5836 && flag == SHF_ARM_PURECODE)
5838 else if (filedata->file_header.e_machine == EM_PPC
5839 && flag == SHF_PPC_VLE)
5841 else if (flag & SHF_MASKOS)
5844 sh_flags &= ~ SHF_MASKOS;
5846 else if (flag & SHF_MASKPROC)
5849 sh_flags &= ~ SHF_MASKPROC;
5859 if (do_section_details)
5863 size -= 5 + field_size;
5864 if (p != buff + field_size + 4)
5868 warn (_("Internal error: not enough buffer room for section flag info"));
5869 return _("<unknown>");
5875 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5876 (unsigned long) os_flags);
5877 p += 5 + field_size;
5881 size -= 7 + field_size;
5882 if (p != buff + field_size + 4)
5886 warn (_("Internal error: not enough buffer room for section flag info"));
5887 return _("<unknown>");
5893 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5894 (unsigned long) proc_flags);
5895 p += 7 + field_size;
5899 size -= 10 + field_size;
5900 if (p != buff + field_size + 4)
5904 warn (_("Internal error: not enough buffer room for section flag info"));
5905 return _("<unknown>");
5911 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5912 (unsigned long) unknown_flags);
5913 p += 10 + field_size;
5922 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5926 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5928 if (size < sizeof (* echdr))
5930 error (_("Compressed section is too small even for a compression header\n"));
5934 chdr->ch_type = BYTE_GET (echdr->ch_type);
5935 chdr->ch_size = BYTE_GET (echdr->ch_size);
5936 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5937 return sizeof (*echdr);
5941 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5943 if (size < sizeof (* echdr))
5945 error (_("Compressed section is too small even for a compression header\n"));
5949 chdr->ch_type = BYTE_GET (echdr->ch_type);
5950 chdr->ch_size = BYTE_GET (echdr->ch_size);
5951 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5952 return sizeof (*echdr);
5957 process_section_headers (Filedata * filedata)
5959 Elf_Internal_Shdr * section;
5962 filedata->section_headers = NULL;
5964 if (filedata->file_header.e_shnum == 0)
5966 /* PR binutils/12467. */
5967 if (filedata->file_header.e_shoff != 0)
5969 warn (_("possibly corrupt ELF file header - it has a non-zero"
5970 " section header offset, but no section headers\n"));
5973 else if (do_sections)
5974 printf (_("\nThere are no sections in this file.\n"));
5979 if (do_sections && !do_header)
5980 printf (ngettext ("There is %d section header, "
5981 "starting at offset 0x%lx:\n",
5982 "There are %d section headers, "
5983 "starting at offset 0x%lx:\n",
5984 filedata->file_header.e_shnum),
5985 filedata->file_header.e_shnum,
5986 (unsigned long) filedata->file_header.e_shoff);
5990 if (! get_32bit_section_headers (filedata, FALSE))
5995 if (! get_64bit_section_headers (filedata, FALSE))
5999 /* Read in the string table, so that we have names to display. */
6000 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6001 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6003 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6005 if (section->sh_size != 0)
6007 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6008 1, section->sh_size,
6011 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6015 /* Scan the sections for the dynamic symbol table
6016 and dynamic string table and debug sections. */
6017 dynamic_symbols = NULL;
6018 dynamic_strings = NULL;
6019 dynamic_syminfo = NULL;
6020 symtab_shndx_list = NULL;
6022 eh_addr_size = is_32bit_elf ? 4 : 8;
6023 switch (filedata->file_header.e_machine)
6026 case EM_MIPS_RS3_LE:
6027 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6028 FDE addresses. However, the ABI also has a semi-official ILP32
6029 variant for which the normal FDE address size rules apply.
6031 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6032 section, where XX is the size of longs in bits. Unfortunately,
6033 earlier compilers provided no way of distinguishing ILP32 objects
6034 from LP64 objects, so if there's any doubt, we should assume that
6035 the official LP64 form is being used. */
6036 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6037 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6043 switch (filedata->file_header.e_flags & EF_H8_MACH)
6045 case E_H8_MACH_H8300:
6046 case E_H8_MACH_H8300HN:
6047 case E_H8_MACH_H8300SN:
6048 case E_H8_MACH_H8300SXN:
6051 case E_H8_MACH_H8300H:
6052 case E_H8_MACH_H8300S:
6053 case E_H8_MACH_H8300SX:
6061 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6063 case EF_M32C_CPU_M16C:
6070 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6073 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6074 if (section->sh_entsize != expected_entsize) \
6077 sprintf_vma (buf, section->sh_entsize); \
6078 /* Note: coded this way so that there is a single string for \
6080 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6081 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6082 (unsigned) expected_entsize); \
6083 section->sh_entsize = expected_entsize; \
6088 #define CHECK_ENTSIZE(section, i, type) \
6089 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6090 sizeof (Elf64_External_##type))
6092 for (i = 0, section = filedata->section_headers;
6093 i < filedata->file_header.e_shnum;
6096 char * name = SECTION_NAME (section);
6098 if (section->sh_type == SHT_DYNSYM)
6100 if (dynamic_symbols != NULL)
6102 error (_("File contains multiple dynamic symbol tables\n"));
6106 CHECK_ENTSIZE (section, i, Sym);
6107 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6109 else if (section->sh_type == SHT_STRTAB
6110 && streq (name, ".dynstr"))
6112 if (dynamic_strings != NULL)
6114 error (_("File contains multiple dynamic string tables\n"));
6118 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6119 1, section->sh_size,
6120 _("dynamic strings"));
6121 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6123 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6125 elf_section_list * entry = xmalloc (sizeof * entry);
6127 entry->hdr = section;
6128 entry->next = symtab_shndx_list;
6129 symtab_shndx_list = entry;
6131 else if (section->sh_type == SHT_SYMTAB)
6132 CHECK_ENTSIZE (section, i, Sym);
6133 else if (section->sh_type == SHT_GROUP)
6134 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6135 else if (section->sh_type == SHT_REL)
6136 CHECK_ENTSIZE (section, i, Rel);
6137 else if (section->sh_type == SHT_RELA)
6138 CHECK_ENTSIZE (section, i, Rela);
6139 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6140 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6141 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6142 || do_debug_str || do_debug_loc || do_debug_ranges
6143 || do_debug_addr || do_debug_cu_index || do_debug_links)
6144 && (const_strneq (name, ".debug_")
6145 || const_strneq (name, ".zdebug_")))
6148 name += sizeof (".zdebug_") - 1;
6150 name += sizeof (".debug_") - 1;
6153 || (do_debug_info && const_strneq (name, "info"))
6154 || (do_debug_info && const_strneq (name, "types"))
6155 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6156 || (do_debug_lines && strcmp (name, "line") == 0)
6157 || (do_debug_lines && const_strneq (name, "line."))
6158 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6159 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6160 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6161 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6162 || (do_debug_aranges && const_strneq (name, "aranges"))
6163 || (do_debug_ranges && const_strneq (name, "ranges"))
6164 || (do_debug_ranges && const_strneq (name, "rnglists"))
6165 || (do_debug_frames && const_strneq (name, "frame"))
6166 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6167 || (do_debug_macinfo && const_strneq (name, "macro"))
6168 || (do_debug_str && const_strneq (name, "str"))
6169 || (do_debug_loc && const_strneq (name, "loc"))
6170 || (do_debug_loc && const_strneq (name, "loclists"))
6171 || (do_debug_addr && const_strneq (name, "addr"))
6172 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6173 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6175 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6177 /* Linkonce section to be combined with .debug_info at link time. */
6178 else if ((do_debugging || do_debug_info)
6179 && const_strneq (name, ".gnu.linkonce.wi."))
6180 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6181 else if (do_debug_frames && streq (name, ".eh_frame"))
6182 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6183 else if (do_gdb_index && (streq (name, ".gdb_index")
6184 || streq (name, ".debug_names")))
6185 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6186 /* Trace sections for Itanium VMS. */
6187 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6188 || do_trace_aranges)
6189 && const_strneq (name, ".trace_"))
6191 name += sizeof (".trace_") - 1;
6194 || (do_trace_info && streq (name, "info"))
6195 || (do_trace_abbrevs && streq (name, "abbrev"))
6196 || (do_trace_aranges && streq (name, "aranges"))
6198 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6200 else if ((do_debugging || do_debug_links)
6201 && (const_strneq (name, ".gnu_debuglink")
6202 || const_strneq (name, ".gnu_debugaltlink")))
6203 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6209 if (filedata->file_header.e_shnum > 1)
6210 printf (_("\nSection Headers:\n"));
6212 printf (_("\nSection Header:\n"));
6216 if (do_section_details)
6218 printf (_(" [Nr] Name\n"));
6219 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6223 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6227 if (do_section_details)
6229 printf (_(" [Nr] Name\n"));
6230 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6234 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6238 if (do_section_details)
6240 printf (_(" [Nr] Name\n"));
6241 printf (_(" Type Address Offset Link\n"));
6242 printf (_(" Size EntSize Info Align\n"));
6246 printf (_(" [Nr] Name Type Address Offset\n"));
6247 printf (_(" Size EntSize Flags Link Info Align\n"));
6251 if (do_section_details)
6252 printf (_(" Flags\n"));
6254 for (i = 0, section = filedata->section_headers;
6255 i < filedata->file_header.e_shnum;
6258 /* Run some sanity checks on the section header. */
6260 /* Check the sh_link field. */
6261 switch (section->sh_type)
6263 case SHT_SYMTAB_SHNDX:
6267 case SHT_GNU_versym:
6270 if (section->sh_link < 1
6271 || section->sh_link >= filedata->file_header.e_shnum
6272 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6273 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6274 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6275 i, section->sh_link);
6281 case SHT_GNU_verneed:
6282 case SHT_GNU_verdef:
6283 case SHT_GNU_LIBLIST:
6284 if (section->sh_link < 1
6285 || section->sh_link >= filedata->file_header.e_shnum
6286 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6287 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6288 i, section->sh_link);
6291 case SHT_INIT_ARRAY:
6292 case SHT_FINI_ARRAY:
6293 case SHT_PREINIT_ARRAY:
6294 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6295 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6296 i, section->sh_link);
6300 /* FIXME: Add support for target specific section types. */
6301 #if 0 /* Currently we do not check other section types as there are too
6302 many special cases. Stab sections for example have a type
6303 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6305 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6306 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6307 i, section->sh_link);
6312 /* Check the sh_info field. */
6313 switch (section->sh_type)
6317 if (section->sh_info < 1
6318 || section->sh_info >= filedata->file_header.e_shnum
6319 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6320 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6321 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6322 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6323 /* FIXME: Are other section types valid ? */
6324 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6326 if (section->sh_info == 0
6327 && (filedata->file_header.e_type == ET_EXEC
6328 || filedata->file_header.e_type == ET_DYN
6329 /* These next two tests may be redundant, but
6330 they have been left in for paranoia's sake. */
6331 || streq (SECTION_NAME (section), ".rel.dyn")
6332 || streq (SECTION_NAME (section), ".rela.dyn")))
6333 /* Dynamic relocations apply to segments, not sections, so
6334 they do not need an sh_info value. */
6337 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6338 i, section->sh_info);
6344 case SHT_SYMTAB_SHNDX:
6345 case SHT_INIT_ARRAY:
6346 case SHT_FINI_ARRAY:
6347 case SHT_PREINIT_ARRAY:
6348 if (section->sh_info != 0)
6349 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6350 i, section->sh_info);
6356 /* A symbol index - we assume that it is valid. */
6360 /* FIXME: Add support for target specific section types. */
6361 if (section->sh_type == SHT_NOBITS)
6362 /* NOBITS section headers with non-zero sh_info fields can be
6363 created when a binary is stripped of everything but its debug
6364 information. The stripped sections have their headers
6365 preserved but their types set to SHT_NOBITS. So do not check
6366 this type of section. */
6368 else if (section->sh_flags & SHF_INFO_LINK)
6370 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6371 warn (_("[%2u]: Expected link to another section in info field"), i);
6373 else if (section->sh_type < SHT_LOOS
6374 && (section->sh_flags & SHF_GNU_MBIND) == 0
6375 && section->sh_info != 0)
6376 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6377 i, section->sh_info);
6381 /* Check the sh_size field. */
6382 if (section->sh_size > filedata->file_size
6383 && section->sh_type != SHT_NOBITS
6384 && section->sh_type != SHT_NULL
6385 && section->sh_type < SHT_LOOS)
6386 warn (_("Size of section %u is larger than the entire file!\n"), i);
6388 printf (" [%2u] ", i);
6389 if (do_section_details)
6390 printf ("%s\n ", printable_section_name (filedata, section));
6392 print_symbol (-17, SECTION_NAME (section));
6394 printf (do_wide ? " %-15s " : " %-15.15s ",
6395 get_section_type_name (filedata, section->sh_type));
6399 const char * link_too_big = NULL;
6401 print_vma (section->sh_addr, LONG_HEX);
6403 printf ( " %6.6lx %6.6lx %2.2lx",
6404 (unsigned long) section->sh_offset,
6405 (unsigned long) section->sh_size,
6406 (unsigned long) section->sh_entsize);
6408 if (do_section_details)
6409 fputs (" ", stdout);
6411 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6413 if (section->sh_link >= filedata->file_header.e_shnum)
6416 /* The sh_link value is out of range. Normally this indicates
6417 an error but it can have special values in Solaris binaries. */
6418 switch (filedata->file_header.e_machine)
6425 case EM_OLD_SPARCV9:
6426 case EM_SPARC32PLUS:
6429 if (section->sh_link == (SHN_BEFORE & 0xffff))
6430 link_too_big = "BEFORE";
6431 else if (section->sh_link == (SHN_AFTER & 0xffff))
6432 link_too_big = "AFTER";
6439 if (do_section_details)
6441 if (link_too_big != NULL && * link_too_big)
6442 printf ("<%s> ", link_too_big);
6444 printf ("%2u ", section->sh_link);
6445 printf ("%3u %2lu\n", section->sh_info,
6446 (unsigned long) section->sh_addralign);
6449 printf ("%2u %3u %2lu\n",
6452 (unsigned long) section->sh_addralign);
6454 if (link_too_big && ! * link_too_big)
6455 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6456 i, section->sh_link);
6460 print_vma (section->sh_addr, LONG_HEX);
6462 if ((long) section->sh_offset == section->sh_offset)
6463 printf (" %6.6lx", (unsigned long) section->sh_offset);
6467 print_vma (section->sh_offset, LONG_HEX);
6470 if ((unsigned long) section->sh_size == section->sh_size)
6471 printf (" %6.6lx", (unsigned long) section->sh_size);
6475 print_vma (section->sh_size, LONG_HEX);
6478 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6479 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6483 print_vma (section->sh_entsize, LONG_HEX);
6486 if (do_section_details)
6487 fputs (" ", stdout);
6489 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6491 printf ("%2u %3u ", section->sh_link, section->sh_info);
6493 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6494 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6497 print_vma (section->sh_addralign, DEC);
6501 else if (do_section_details)
6503 printf (" %-15.15s ",
6504 get_section_type_name (filedata, section->sh_type));
6505 print_vma (section->sh_addr, LONG_HEX);
6506 if ((long) section->sh_offset == section->sh_offset)
6507 printf (" %16.16lx", (unsigned long) section->sh_offset);
6511 print_vma (section->sh_offset, LONG_HEX);
6513 printf (" %u\n ", section->sh_link);
6514 print_vma (section->sh_size, LONG_HEX);
6516 print_vma (section->sh_entsize, LONG_HEX);
6518 printf (" %-16u %lu\n",
6520 (unsigned long) section->sh_addralign);
6525 print_vma (section->sh_addr, LONG_HEX);
6526 if ((long) section->sh_offset == section->sh_offset)
6527 printf (" %8.8lx", (unsigned long) section->sh_offset);
6531 print_vma (section->sh_offset, LONG_HEX);
6534 print_vma (section->sh_size, LONG_HEX);
6536 print_vma (section->sh_entsize, LONG_HEX);
6538 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6540 printf (" %2u %3u %lu\n",
6543 (unsigned long) section->sh_addralign);
6546 if (do_section_details)
6548 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6549 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6551 /* Minimum section size is 12 bytes for 32-bit compression
6552 header + 12 bytes for compressed data header. */
6553 unsigned char buf[24];
6555 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6556 if (get_data (&buf, filedata, section->sh_offset, 1,
6557 sizeof (buf), _("compression header")))
6559 Elf_Internal_Chdr chdr;
6561 (void) get_compression_header (&chdr, buf, sizeof (buf));
6563 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6566 printf (_(" [<unknown>: 0x%x], "),
6568 print_vma (chdr.ch_size, LONG_HEX);
6569 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6575 if (!do_section_details)
6577 /* The ordering of the letters shown here matches the ordering of the
6578 corresponding SHF_xxx values, and hence the order in which these
6579 letters will be displayed to the user. */
6580 printf (_("Key to Flags:\n\
6581 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6582 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6583 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6584 if (filedata->file_header.e_machine == EM_X86_64
6585 || filedata->file_header.e_machine == EM_L1OM
6586 || filedata->file_header.e_machine == EM_K1OM)
6587 printf (_("l (large), "));
6588 else if (filedata->file_header.e_machine == EM_ARM)
6589 printf (_("y (purecode), "));
6590 else if (filedata->file_header.e_machine == EM_PPC)
6591 printf (_("v (VLE), "));
6592 printf ("p (processor specific)\n");
6599 get_group_flags (unsigned int flags)
6601 static char buff[128];
6605 else if (flags == GRP_COMDAT)
6608 snprintf (buff, 14, _("[0x%x: "), flags);
6610 flags &= ~ GRP_COMDAT;
6611 if (flags & GRP_MASKOS)
6613 strcat (buff, "<OS specific>");
6614 flags &= ~ GRP_MASKOS;
6617 if (flags & GRP_MASKPROC)
6619 strcat (buff, "<PROC specific>");
6620 flags &= ~ GRP_MASKPROC;
6624 strcat (buff, "<unknown>");
6631 process_section_groups (Filedata * filedata)
6633 Elf_Internal_Shdr * section;
6635 struct group * group;
6636 Elf_Internal_Shdr * symtab_sec;
6637 Elf_Internal_Shdr * strtab_sec;
6638 Elf_Internal_Sym * symtab;
6639 unsigned long num_syms;
6643 /* Don't process section groups unless needed. */
6644 if (!do_unwind && !do_section_groups)
6647 if (filedata->file_header.e_shnum == 0)
6649 if (do_section_groups)
6650 printf (_("\nThere are no sections to group in this file.\n"));
6655 if (filedata->section_headers == NULL)
6657 error (_("Section headers are not available!\n"));
6658 /* PR 13622: This can happen with a corrupt ELF header. */
6662 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6663 sizeof (struct group *));
6665 if (section_headers_groups == NULL)
6667 error (_("Out of memory reading %u section group headers\n"),
6668 filedata->file_header.e_shnum);
6672 /* Scan the sections for the group section. */
6674 for (i = 0, section = filedata->section_headers;
6675 i < filedata->file_header.e_shnum;
6677 if (section->sh_type == SHT_GROUP)
6680 if (group_count == 0)
6682 if (do_section_groups)
6683 printf (_("\nThere are no section groups in this file.\n"));
6688 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6690 if (section_groups == NULL)
6692 error (_("Out of memory reading %lu groups\n"),
6693 (unsigned long) group_count);
6703 for (i = 0, section = filedata->section_headers, group = section_groups;
6704 i < filedata->file_header.e_shnum;
6707 if (section->sh_type == SHT_GROUP)
6709 const char * name = printable_section_name (filedata, section);
6710 const char * group_name;
6711 unsigned char * start;
6712 unsigned char * indices;
6713 unsigned int entry, j, size;
6714 Elf_Internal_Shdr * sec;
6715 Elf_Internal_Sym * sym;
6717 /* Get the symbol table. */
6718 if (section->sh_link >= filedata->file_header.e_shnum
6719 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6722 error (_("Bad sh_link in group section `%s'\n"), name);
6726 if (symtab_sec != sec)
6731 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6736 error (_("Corrupt header in group section `%s'\n"), name);
6740 if (section->sh_info >= num_syms)
6742 error (_("Bad sh_info in group section `%s'\n"), name);
6746 sym = symtab + section->sh_info;
6748 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6750 if (sym->st_shndx == 0
6751 || sym->st_shndx >= filedata->file_header.e_shnum)
6753 error (_("Bad sh_info in group section `%s'\n"), name);
6757 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6766 /* Get the string table. */
6767 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6776 != (sec = filedata->section_headers + symtab_sec->sh_link))
6782 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6783 1, strtab_sec->sh_size,
6785 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6787 group_name = sym->st_name < strtab_size
6788 ? strtab + sym->st_name : _("<corrupt>");
6791 /* PR 17531: file: loop. */
6792 if (section->sh_entsize > section->sh_size)
6794 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6795 printable_section_name (filedata, section),
6796 (unsigned long) section->sh_entsize,
6797 (unsigned long) section->sh_size);
6801 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6802 1, section->sh_size,
6808 size = (section->sh_size / section->sh_entsize) - 1;
6809 entry = byte_get (indices, 4);
6812 if (do_section_groups)
6814 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6815 get_group_flags (entry), i, name, group_name, size);
6817 printf (_(" [Index] Name\n"));
6820 group->group_index = i;
6822 for (j = 0; j < size; j++)
6824 struct group_list * g;
6826 entry = byte_get (indices, 4);
6829 if (entry >= filedata->file_header.e_shnum)
6831 static unsigned num_group_errors = 0;
6833 if (num_group_errors ++ < 10)
6835 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6836 entry, i, filedata->file_header.e_shnum - 1);
6837 if (num_group_errors == 10)
6838 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6843 if (section_headers_groups [entry] != NULL)
6847 static unsigned num_errs = 0;
6849 if (num_errs ++ < 10)
6851 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6853 section_headers_groups [entry]->group_index);
6855 warn (_("Further error messages about already contained group sections suppressed\n"));
6861 /* Intel C/C++ compiler may put section 0 in a
6862 section group. We just warn it the first time
6863 and ignore it afterwards. */
6864 static bfd_boolean warned = FALSE;
6867 error (_("section 0 in group section [%5u]\n"),
6868 section_headers_groups [entry]->group_index);
6874 section_headers_groups [entry] = group;
6876 if (do_section_groups)
6878 sec = filedata->section_headers + entry;
6879 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6882 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6883 g->section_index = entry;
6884 g->next = group->root;
6902 /* Data used to display dynamic fixups. */
6904 struct ia64_vms_dynfixup
6906 bfd_vma needed_ident; /* Library ident number. */
6907 bfd_vma needed; /* Index in the dstrtab of the library name. */
6908 bfd_vma fixup_needed; /* Index of the library. */
6909 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6910 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6913 /* Data used to display dynamic relocations. */
6915 struct ia64_vms_dynimgrela
6917 bfd_vma img_rela_cnt; /* Number of relocations. */
6918 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6921 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6925 dump_ia64_vms_dynamic_fixups (Filedata * filedata,
6926 struct ia64_vms_dynfixup * fixup,
6927 const char * strtab,
6928 unsigned int strtab_sz)
6930 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6932 const char * lib_name;
6934 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6935 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6936 _("dynamic section image fixups"));
6940 if (fixup->needed < strtab_sz)
6941 lib_name = strtab + fixup->needed;
6944 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6945 (unsigned long) fixup->needed);
6948 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6949 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6951 (_("Seg Offset Type SymVec DataType\n"));
6953 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6958 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6959 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6960 type = BYTE_GET (imfs [i].type);
6961 rtype = elf_ia64_reloc_type (type);
6963 printf (" 0x%08x ", type);
6965 printf (" %-32s ", rtype);
6966 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6967 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6974 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6977 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6979 Elf64_External_VMS_IMAGE_RELA *imrs;
6982 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6983 1, imgrela->img_rela_cnt * sizeof (*imrs),
6984 _("dynamic section image relocations"));
6988 printf (_("\nImage relocs\n"));
6990 (_("Seg Offset Type Addend Seg Sym Off\n"));
6992 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6997 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6998 printf ("%08" BFD_VMA_FMT "x ",
6999 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7000 type = BYTE_GET (imrs [i].type);
7001 rtype = elf_ia64_reloc_type (type);
7003 printf ("0x%08x ", type);
7005 printf ("%-31s ", rtype);
7006 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7007 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7008 printf ("%08" BFD_VMA_FMT "x\n",
7009 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7016 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7019 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7021 struct ia64_vms_dynfixup fixup;
7022 struct ia64_vms_dynimgrela imgrela;
7023 Elf_Internal_Dyn *entry;
7024 bfd_vma strtab_off = 0;
7025 bfd_vma strtab_sz = 0;
7026 char *strtab = NULL;
7027 bfd_boolean res = TRUE;
7029 memset (&fixup, 0, sizeof (fixup));
7030 memset (&imgrela, 0, sizeof (imgrela));
7032 /* Note: the order of the entries is specified by the OpenVMS specs. */
7033 for (entry = dynamic_section;
7034 entry < dynamic_section + dynamic_nent;
7037 switch (entry->d_tag)
7039 case DT_IA_64_VMS_STRTAB_OFFSET:
7040 strtab_off = entry->d_un.d_val;
7043 strtab_sz = entry->d_un.d_val;
7045 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7046 1, strtab_sz, _("dynamic string section"));
7049 case DT_IA_64_VMS_NEEDED_IDENT:
7050 fixup.needed_ident = entry->d_un.d_val;
7053 fixup.needed = entry->d_un.d_val;
7055 case DT_IA_64_VMS_FIXUP_NEEDED:
7056 fixup.fixup_needed = entry->d_un.d_val;
7058 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7059 fixup.fixup_rela_cnt = entry->d_un.d_val;
7061 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7062 fixup.fixup_rela_off = entry->d_un.d_val;
7063 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7066 case DT_IA_64_VMS_IMG_RELA_CNT:
7067 imgrela.img_rela_cnt = entry->d_un.d_val;
7069 case DT_IA_64_VMS_IMG_RELA_OFF:
7070 imgrela.img_rela_off = entry->d_un.d_val;
7071 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7093 dynamic_relocations [] =
7095 { "REL", DT_REL, DT_RELSZ, FALSE },
7096 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7097 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7100 /* Process the reloc section. */
7103 process_relocs (Filedata * filedata)
7105 unsigned long rel_size;
7106 unsigned long rel_offset;
7111 if (do_using_dynamic)
7115 bfd_boolean has_dynamic_reloc;
7118 has_dynamic_reloc = FALSE;
7120 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7122 is_rela = dynamic_relocations [i].rela;
7123 name = dynamic_relocations [i].name;
7124 rel_size = dynamic_info [dynamic_relocations [i].size];
7125 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7128 has_dynamic_reloc = TRUE;
7130 if (is_rela == UNKNOWN)
7132 if (dynamic_relocations [i].reloc == DT_JMPREL)
7133 switch (dynamic_info[DT_PLTREL])
7147 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7148 name, rel_offset, rel_size);
7150 dump_relocations (filedata,
7151 offset_from_vma (filedata, rel_offset, rel_size),
7153 dynamic_symbols, num_dynamic_syms,
7154 dynamic_strings, dynamic_strings_length,
7155 is_rela, TRUE /* is_dynamic */);
7159 if (is_ia64_vms (filedata))
7160 if (process_ia64_vms_dynamic_relocs (filedata))
7161 has_dynamic_reloc = TRUE;
7163 if (! has_dynamic_reloc)
7164 printf (_("\nThere are no dynamic relocations in this file.\n"));
7168 Elf_Internal_Shdr * section;
7170 bfd_boolean found = FALSE;
7172 for (i = 0, section = filedata->section_headers;
7173 i < filedata->file_header.e_shnum;
7176 if ( section->sh_type != SHT_RELA
7177 && section->sh_type != SHT_REL)
7180 rel_offset = section->sh_offset;
7181 rel_size = section->sh_size;
7185 Elf_Internal_Shdr * strsec;
7187 unsigned long num_rela;
7189 printf (_("\nRelocation section "));
7191 if (filedata->string_table == NULL)
7192 printf ("%d", section->sh_name);
7194 printf ("'%s'", printable_section_name (filedata, section));
7196 num_rela = rel_size / section->sh_entsize;
7197 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7198 " at offset 0x%lx contains %lu entries:\n",
7200 rel_offset, num_rela);
7202 is_rela = section->sh_type == SHT_RELA;
7204 if (section->sh_link != 0
7205 && section->sh_link < filedata->file_header.e_shnum)
7207 Elf_Internal_Shdr * symsec;
7208 Elf_Internal_Sym * symtab;
7209 unsigned long nsyms;
7210 unsigned long strtablen = 0;
7211 char * strtab = NULL;
7213 symsec = filedata->section_headers + section->sh_link;
7214 if (symsec->sh_type != SHT_SYMTAB
7215 && symsec->sh_type != SHT_DYNSYM)
7218 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7223 if (symsec->sh_link != 0
7224 && symsec->sh_link < filedata->file_header.e_shnum)
7226 strsec = filedata->section_headers + symsec->sh_link;
7228 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7231 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7234 dump_relocations (filedata, rel_offset, rel_size,
7235 symtab, nsyms, strtab, strtablen,
7237 symsec->sh_type == SHT_DYNSYM);
7243 dump_relocations (filedata, rel_offset, rel_size,
7244 NULL, 0, NULL, 0, is_rela,
7245 FALSE /* is_dynamic */);
7253 /* Users sometimes forget the -D option, so try to be helpful. */
7254 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7256 if (dynamic_info [dynamic_relocations [i].size])
7258 printf (_("\nThere are no static relocations in this file."));
7259 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7264 if (i == ARRAY_SIZE (dynamic_relocations))
7265 printf (_("\nThere are no relocations in this file.\n"));
7272 /* An absolute address consists of a section and an offset. If the
7273 section is NULL, the offset itself is the address, otherwise, the
7274 address equals to LOAD_ADDRESS(section) + offset. */
7278 unsigned short section;
7282 #define ABSADDR(a) \
7284 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7287 /* Find the nearest symbol at or below ADDR. Returns the symbol
7288 name, if found, and the offset from the symbol to ADDR. */
7291 find_symbol_for_address (Filedata * filedata,
7292 Elf_Internal_Sym * symtab,
7293 unsigned long nsyms,
7294 const char * strtab,
7295 unsigned long strtab_size,
7296 struct absaddr addr,
7297 const char ** symname,
7300 bfd_vma dist = 0x100000;
7301 Elf_Internal_Sym * sym;
7302 Elf_Internal_Sym * beg;
7303 Elf_Internal_Sym * end;
7304 Elf_Internal_Sym * best = NULL;
7306 REMOVE_ARCH_BITS (addr.offset);
7308 end = symtab + nsyms;
7314 sym = beg + (end - beg) / 2;
7316 value = sym->st_value;
7317 REMOVE_ARCH_BITS (value);
7319 if (sym->st_name != 0
7320 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7321 && addr.offset >= value
7322 && addr.offset - value < dist)
7325 dist = addr.offset - value;
7330 if (addr.offset < value)
7338 *symname = (best->st_name >= strtab_size
7339 ? _("<corrupt>") : strtab + best->st_name);
7345 *offset = addr.offset;
7348 static /* signed */ int
7349 symcmp (const void *p, const void *q)
7351 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7352 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7354 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7357 /* Process the unwind section. */
7359 #include "unwind-ia64.h"
7361 struct ia64_unw_table_entry
7363 struct absaddr start;
7365 struct absaddr info;
7368 struct ia64_unw_aux_info
7370 struct ia64_unw_table_entry * table; /* Unwind table. */
7371 unsigned long table_len; /* Length of unwind table. */
7372 unsigned char * info; /* Unwind info. */
7373 unsigned long info_size; /* Size of unwind info. */
7374 bfd_vma info_addr; /* Starting address of unwind info. */
7375 bfd_vma seg_base; /* Starting address of segment. */
7376 Elf_Internal_Sym * symtab; /* The symbol table. */
7377 unsigned long nsyms; /* Number of symbols. */
7378 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7379 unsigned long nfuns; /* Number of entries in funtab. */
7380 char * strtab; /* The string table. */
7381 unsigned long strtab_size; /* Size of string table. */
7385 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7387 struct ia64_unw_table_entry * tp;
7388 unsigned long j, nfuns;
7390 bfd_boolean res = TRUE;
7392 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7393 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7394 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7395 aux->funtab[nfuns++] = aux->symtab[j];
7397 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7399 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7403 const unsigned char * dp;
7404 const unsigned char * head;
7405 const unsigned char * end;
7406 const char * procname;
7408 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7409 aux->strtab_size, tp->start, &procname, &offset);
7411 fputs ("\n<", stdout);
7415 fputs (procname, stdout);
7418 printf ("+%lx", (unsigned long) offset);
7421 fputs (">: [", stdout);
7422 print_vma (tp->start.offset, PREFIX_HEX);
7423 fputc ('-', stdout);
7424 print_vma (tp->end.offset, PREFIX_HEX);
7425 printf ("], info at +0x%lx\n",
7426 (unsigned long) (tp->info.offset - aux->seg_base));
7428 /* PR 17531: file: 86232b32. */
7429 if (aux->info == NULL)
7432 /* PR 17531: file: 0997b4d1. */
7433 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7435 warn (_("Invalid offset %lx in table entry %ld\n"),
7436 (long) tp->info.offset, (long) (tp - aux->table));
7441 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7442 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7444 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7445 (unsigned) UNW_VER (stamp),
7446 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7447 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7448 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7449 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7451 if (UNW_VER (stamp) != 1)
7453 printf (_("\tUnknown version.\n"));
7458 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7459 /* PR 17531: file: 16ceda89. */
7460 if (end > aux->info + aux->info_size)
7461 end = aux->info + aux->info_size;
7462 for (dp = head + 8; dp < end;)
7463 dp = unw_decode (dp, in_body, & in_body, end);
7472 slurp_ia64_unwind_table (Filedata * filedata,
7473 struct ia64_unw_aux_info * aux,
7474 Elf_Internal_Shdr * sec)
7476 unsigned long size, nrelas, i;
7477 Elf_Internal_Phdr * seg;
7478 struct ia64_unw_table_entry * tep;
7479 Elf_Internal_Shdr * relsec;
7480 Elf_Internal_Rela * rela;
7481 Elf_Internal_Rela * rp;
7482 unsigned char * table;
7484 Elf_Internal_Sym * sym;
7485 const char * relname;
7489 /* First, find the starting address of the segment that includes
7492 if (filedata->file_header.e_phnum)
7494 if (! get_program_headers (filedata))
7497 for (seg = filedata->program_headers;
7498 seg < filedata->program_headers + filedata->file_header.e_phnum;
7501 if (seg->p_type != PT_LOAD)
7504 if (sec->sh_addr >= seg->p_vaddr
7505 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7507 aux->seg_base = seg->p_vaddr;
7513 /* Second, build the unwind table from the contents of the unwind section: */
7514 size = sec->sh_size;
7515 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7520 aux->table_len = size / (3 * eh_addr_size);
7521 aux->table = (struct ia64_unw_table_entry *)
7522 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7525 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7527 tep->start.section = SHN_UNDEF;
7528 tep->end.section = SHN_UNDEF;
7529 tep->info.section = SHN_UNDEF;
7530 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7531 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7532 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7533 tep->start.offset += aux->seg_base;
7534 tep->end.offset += aux->seg_base;
7535 tep->info.offset += aux->seg_base;
7539 /* Third, apply any relocations to the unwind table: */
7540 for (relsec = filedata->section_headers;
7541 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7544 if (relsec->sh_type != SHT_RELA
7545 || relsec->sh_info >= filedata->file_header.e_shnum
7546 || filedata->section_headers + relsec->sh_info != sec)
7549 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7558 for (rp = rela; rp < rela + nrelas; ++rp)
7560 relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7561 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7563 /* PR 17531: file: 9fa67536. */
7564 if (relname == NULL)
7566 warn (_("Skipping unknown relocation type: %u\n"),
7567 get_reloc_type (filedata, rp->r_info));
7571 if (! const_strneq (relname, "R_IA64_SEGREL"))
7573 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7577 i = rp->r_offset / (3 * eh_addr_size);
7579 /* PR 17531: file: 5bc8d9bf. */
7580 if (i >= aux->table_len)
7582 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7586 switch (rp->r_offset / eh_addr_size % 3)
7589 aux->table[i].start.section = sym->st_shndx;
7590 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7593 aux->table[i].end.section = sym->st_shndx;
7594 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7597 aux->table[i].info.section = sym->st_shndx;
7598 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7612 ia64_process_unwind (Filedata * filedata)
7614 Elf_Internal_Shdr * sec;
7615 Elf_Internal_Shdr * unwsec = NULL;
7616 Elf_Internal_Shdr * strsec;
7617 unsigned long i, unwcount = 0, unwstart = 0;
7618 struct ia64_unw_aux_info aux;
7619 bfd_boolean res = TRUE;
7621 memset (& aux, 0, sizeof (aux));
7623 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7625 if (sec->sh_type == SHT_SYMTAB
7626 && sec->sh_link < filedata->file_header.e_shnum)
7628 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7630 strsec = filedata->section_headers + sec->sh_link;
7631 if (aux.strtab != NULL)
7633 error (_("Multiple auxillary string tables encountered\n"));
7637 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7640 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7642 else if (sec->sh_type == SHT_IA_64_UNWIND)
7647 printf (_("\nThere are no unwind sections in this file.\n"));
7649 while (unwcount-- > 0)
7654 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7655 i < filedata->file_header.e_shnum; ++i, ++sec)
7656 if (sec->sh_type == SHT_IA_64_UNWIND)
7661 /* We have already counted the number of SHT_IA64_UNWIND
7662 sections so the loop above should never fail. */
7663 assert (unwsec != NULL);
7666 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7668 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7670 /* We need to find which section group it is in. */
7671 struct group_list * g;
7673 if (section_headers_groups == NULL
7674 || section_headers_groups [i] == NULL)
7675 i = filedata->file_header.e_shnum;
7678 g = section_headers_groups [i]->root;
7680 for (; g != NULL; g = g->next)
7682 sec = filedata->section_headers + g->section_index;
7684 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7689 i = filedata->file_header.e_shnum;
7692 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7694 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7695 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7696 suffix = SECTION_NAME (unwsec) + len;
7697 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7699 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7700 && streq (SECTION_NAME (sec) + len2, suffix))
7705 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7706 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7707 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7708 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7710 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7711 suffix = SECTION_NAME (unwsec) + len;
7712 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7714 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7715 && streq (SECTION_NAME (sec) + len2, suffix))
7719 if (i == filedata->file_header.e_shnum)
7721 printf (_("\nCould not find unwind info section for "));
7723 if (filedata->string_table == NULL)
7724 printf ("%d", unwsec->sh_name);
7726 printf ("'%s'", printable_section_name (filedata, unwsec));
7730 aux.info_addr = sec->sh_addr;
7731 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7734 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7736 printf (_("\nUnwind section "));
7738 if (filedata->string_table == NULL)
7739 printf ("%d", unwsec->sh_name);
7741 printf ("'%s'", printable_section_name (filedata, unwsec));
7743 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7744 (unsigned long) unwsec->sh_offset,
7745 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7747 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7748 && aux.table_len > 0)
7749 dump_ia64_unwind (filedata, & aux);
7752 free ((char *) aux.table);
7754 free ((char *) aux.info);
7763 free ((char *) aux.strtab);
7768 struct hppa_unw_table_entry
7770 struct absaddr start;
7772 unsigned int Cannot_unwind:1; /* 0 */
7773 unsigned int Millicode:1; /* 1 */
7774 unsigned int Millicode_save_sr0:1; /* 2 */
7775 unsigned int Region_description:2; /* 3..4 */
7776 unsigned int reserved1:1; /* 5 */
7777 unsigned int Entry_SR:1; /* 6 */
7778 unsigned int Entry_FR:4; /* Number saved 7..10 */
7779 unsigned int Entry_GR:5; /* Number saved 11..15 */
7780 unsigned int Args_stored:1; /* 16 */
7781 unsigned int Variable_Frame:1; /* 17 */
7782 unsigned int Separate_Package_Body:1; /* 18 */
7783 unsigned int Frame_Extension_Millicode:1; /* 19 */
7784 unsigned int Stack_Overflow_Check:1; /* 20 */
7785 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7786 unsigned int Ada_Region:1; /* 22 */
7787 unsigned int cxx_info:1; /* 23 */
7788 unsigned int cxx_try_catch:1; /* 24 */
7789 unsigned int sched_entry_seq:1; /* 25 */
7790 unsigned int reserved2:1; /* 26 */
7791 unsigned int Save_SP:1; /* 27 */
7792 unsigned int Save_RP:1; /* 28 */
7793 unsigned int Save_MRP_in_frame:1; /* 29 */
7794 unsigned int extn_ptr_defined:1; /* 30 */
7795 unsigned int Cleanup_defined:1; /* 31 */
7797 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7798 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7799 unsigned int Large_frame:1; /* 2 */
7800 unsigned int Pseudo_SP_Set:1; /* 3 */
7801 unsigned int reserved4:1; /* 4 */
7802 unsigned int Total_frame_size:27; /* 5..31 */
7805 struct hppa_unw_aux_info
7807 struct hppa_unw_table_entry * table; /* Unwind table. */
7808 unsigned long table_len; /* Length of unwind table. */
7809 bfd_vma seg_base; /* Starting address of segment. */
7810 Elf_Internal_Sym * symtab; /* The symbol table. */
7811 unsigned long nsyms; /* Number of symbols. */
7812 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7813 unsigned long nfuns; /* Number of entries in funtab. */
7814 char * strtab; /* The string table. */
7815 unsigned long strtab_size; /* Size of string table. */
7819 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7821 struct hppa_unw_table_entry * tp;
7822 unsigned long j, nfuns;
7823 bfd_boolean res = TRUE;
7825 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7826 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7827 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7828 aux->funtab[nfuns++] = aux->symtab[j];
7830 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7832 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7835 const char * procname;
7837 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7838 aux->strtab_size, tp->start, &procname,
7841 fputs ("\n<", stdout);
7845 fputs (procname, stdout);
7848 printf ("+%lx", (unsigned long) offset);
7851 fputs (">: [", stdout);
7852 print_vma (tp->start.offset, PREFIX_HEX);
7853 fputc ('-', stdout);
7854 print_vma (tp->end.offset, PREFIX_HEX);
7857 #define PF(_m) if (tp->_m) printf (#_m " ");
7858 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7861 PF(Millicode_save_sr0);
7862 /* PV(Region_description); */
7868 PF(Separate_Package_Body);
7869 PF(Frame_Extension_Millicode);
7870 PF(Stack_Overflow_Check);
7871 PF(Two_Instruction_SP_Increment);
7875 PF(sched_entry_seq);
7878 PF(Save_MRP_in_frame);
7879 PF(extn_ptr_defined);
7880 PF(Cleanup_defined);
7881 PF(MPE_XL_interrupt_marker);
7882 PF(HP_UX_interrupt_marker);
7885 PV(Total_frame_size);
7898 slurp_hppa_unwind_table (Filedata * filedata,
7899 struct hppa_unw_aux_info * aux,
7900 Elf_Internal_Shdr * sec)
7902 unsigned long size, unw_ent_size, nentries, nrelas, i;
7903 Elf_Internal_Phdr * seg;
7904 struct hppa_unw_table_entry * tep;
7905 Elf_Internal_Shdr * relsec;
7906 Elf_Internal_Rela * rela;
7907 Elf_Internal_Rela * rp;
7908 unsigned char * table;
7910 Elf_Internal_Sym * sym;
7911 const char * relname;
7913 /* First, find the starting address of the segment that includes
7915 if (filedata->file_header.e_phnum)
7917 if (! get_program_headers (filedata))
7920 for (seg = filedata->program_headers;
7921 seg < filedata->program_headers + filedata->file_header.e_phnum;
7924 if (seg->p_type != PT_LOAD)
7927 if (sec->sh_addr >= seg->p_vaddr
7928 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7930 aux->seg_base = seg->p_vaddr;
7936 /* Second, build the unwind table from the contents of the unwind
7938 size = sec->sh_size;
7939 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7945 nentries = size / unw_ent_size;
7946 size = unw_ent_size * nentries;
7948 tep = aux->table = (struct hppa_unw_table_entry *)
7949 xcmalloc (nentries, sizeof (aux->table[0]));
7951 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7953 unsigned int tmp1, tmp2;
7955 tep->start.section = SHN_UNDEF;
7956 tep->end.section = SHN_UNDEF;
7958 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7959 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7960 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7961 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7963 tep->start.offset += aux->seg_base;
7964 tep->end.offset += aux->seg_base;
7966 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7967 tep->Millicode = (tmp1 >> 30) & 0x1;
7968 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7969 tep->Region_description = (tmp1 >> 27) & 0x3;
7970 tep->reserved1 = (tmp1 >> 26) & 0x1;
7971 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7972 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7973 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7974 tep->Args_stored = (tmp1 >> 15) & 0x1;
7975 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7976 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7977 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7978 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7979 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7980 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7981 tep->cxx_info = (tmp1 >> 8) & 0x1;
7982 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7983 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7984 tep->reserved2 = (tmp1 >> 5) & 0x1;
7985 tep->Save_SP = (tmp1 >> 4) & 0x1;
7986 tep->Save_RP = (tmp1 >> 3) & 0x1;
7987 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7988 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7989 tep->Cleanup_defined = tmp1 & 0x1;
7991 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7992 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7993 tep->Large_frame = (tmp2 >> 29) & 0x1;
7994 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7995 tep->reserved4 = (tmp2 >> 27) & 0x1;
7996 tep->Total_frame_size = tmp2 & 0x7ffffff;
8000 /* Third, apply any relocations to the unwind table. */
8001 for (relsec = filedata->section_headers;
8002 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8005 if (relsec->sh_type != SHT_RELA
8006 || relsec->sh_info >= filedata->file_header.e_shnum
8007 || filedata->section_headers + relsec->sh_info != sec)
8010 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8014 for (rp = rela; rp < rela + nrelas; ++rp)
8016 relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8017 sym = aux->symtab + get_reloc_symindex (rp->r_info);
8019 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8020 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8022 warn (_("Skipping unexpected relocation type %s\n"), relname);
8026 i = rp->r_offset / unw_ent_size;
8028 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8031 aux->table[i].start.section = sym->st_shndx;
8032 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8035 aux->table[i].end.section = sym->st_shndx;
8036 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8046 aux->table_len = nentries;
8052 hppa_process_unwind (Filedata * filedata)
8054 struct hppa_unw_aux_info aux;
8055 Elf_Internal_Shdr * unwsec = NULL;
8056 Elf_Internal_Shdr * strsec;
8057 Elf_Internal_Shdr * sec;
8059 bfd_boolean res = TRUE;
8061 if (filedata->string_table == NULL)
8064 memset (& aux, 0, sizeof (aux));
8066 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8068 if (sec->sh_type == SHT_SYMTAB
8069 && sec->sh_link < filedata->file_header.e_shnum)
8071 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8073 strsec = filedata->section_headers + sec->sh_link;
8074 if (aux.strtab != NULL)
8076 error (_("Multiple auxillary string tables encountered\n"));
8080 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8083 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8085 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8090 printf (_("\nThere are no unwind sections in this file.\n"));
8092 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8094 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8096 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8098 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8099 "contains %lu entry:\n",
8100 "\nUnwind section '%s' at offset 0x%lx "
8101 "contains %lu entries:\n",
8103 printable_section_name (filedata, sec),
8104 (unsigned long) sec->sh_offset,
8107 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8110 if (aux.table_len > 0)
8112 if (! dump_hppa_unwind (filedata, &aux))
8117 free ((char *) aux.table);
8125 free ((char *) aux.strtab);
8132 unsigned char * data; /* The unwind data. */
8133 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8134 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8135 unsigned long nrelas; /* The number of relocations. */
8136 unsigned int rel_type; /* REL or RELA ? */
8137 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8140 struct arm_unw_aux_info
8142 Filedata * filedata; /* The file containing the unwind sections. */
8143 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8144 unsigned long nsyms; /* Number of symbols. */
8145 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8146 unsigned long nfuns; /* Number of these symbols. */
8147 char * strtab; /* The file's string table. */
8148 unsigned long strtab_size; /* Size of string table. */
8152 arm_print_vma_and_name (Filedata * filedata,
8153 struct arm_unw_aux_info * aux,
8155 struct absaddr addr)
8157 const char *procname;
8160 if (addr.section == SHN_UNDEF)
8163 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8164 aux->strtab_size, addr, &procname,
8167 print_vma (fn, PREFIX_HEX);
8171 fputs (" <", stdout);
8172 fputs (procname, stdout);
8175 printf ("+0x%lx", (unsigned long) sym_offset);
8176 fputc ('>', stdout);
8183 arm_free_section (struct arm_section *arm_sec)
8185 if (arm_sec->data != NULL)
8186 free (arm_sec->data);
8188 if (arm_sec->rela != NULL)
8189 free (arm_sec->rela);
8192 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8193 cached section and install SEC instead.
8194 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8195 and return its valued in * WORDP, relocating if necessary.
8196 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8197 relocation's offset in ADDR.
8198 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8199 into the string table of the symbol associated with the reloc. If no
8200 reloc was applied store -1 there.
8201 5) Return TRUE upon success, FALSE otherwise. */
8204 get_unwind_section_word (Filedata * filedata,
8205 struct arm_unw_aux_info * aux,
8206 struct arm_section * arm_sec,
8207 Elf_Internal_Shdr * sec,
8208 bfd_vma word_offset,
8209 unsigned int * wordp,
8210 struct absaddr * addr,
8213 Elf_Internal_Rela *rp;
8214 Elf_Internal_Sym *sym;
8215 const char * relname;
8217 bfd_boolean wrapped;
8219 if (sec == NULL || arm_sec == NULL)
8222 addr->section = SHN_UNDEF;
8225 if (sym_name != NULL)
8226 *sym_name = (bfd_vma) -1;
8228 /* If necessary, update the section cache. */
8229 if (sec != arm_sec->sec)
8231 Elf_Internal_Shdr *relsec;
8233 arm_free_section (arm_sec);
8236 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8237 sec->sh_size, _("unwind data"));
8238 arm_sec->rela = NULL;
8239 arm_sec->nrelas = 0;
8241 for (relsec = filedata->section_headers;
8242 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8245 if (relsec->sh_info >= filedata->file_header.e_shnum
8246 || filedata->section_headers + relsec->sh_info != sec
8247 /* PR 15745: Check the section type as well. */
8248 || (relsec->sh_type != SHT_REL
8249 && relsec->sh_type != SHT_RELA))
8252 arm_sec->rel_type = relsec->sh_type;
8253 if (relsec->sh_type == SHT_REL)
8255 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8257 & arm_sec->rela, & arm_sec->nrelas))
8260 else /* relsec->sh_type == SHT_RELA */
8262 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8264 & arm_sec->rela, & arm_sec->nrelas))
8270 arm_sec->next_rela = arm_sec->rela;
8273 /* If there is no unwind data we can do nothing. */
8274 if (arm_sec->data == NULL)
8277 /* If the offset is invalid then fail. */
8278 if (/* PR 21343 *//* PR 18879 */
8280 || word_offset > (sec->sh_size - 4)
8281 || ((bfd_signed_vma) word_offset) < 0)
8284 /* Get the word at the required offset. */
8285 word = byte_get (arm_sec->data + word_offset, 4);
8287 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8288 if (arm_sec->rela == NULL)
8294 /* Look through the relocs to find the one that applies to the provided offset. */
8296 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8298 bfd_vma prelval, offset;
8300 if (rp->r_offset > word_offset && !wrapped)
8305 if (rp->r_offset > word_offset)
8308 if (rp->r_offset & 3)
8310 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8311 (unsigned long) rp->r_offset);
8315 if (rp->r_offset < word_offset)
8318 /* PR 17531: file: 027-161405-0.004 */
8319 if (aux->symtab == NULL)
8322 if (arm_sec->rel_type == SHT_REL)
8324 offset = word & 0x7fffffff;
8325 if (offset & 0x40000000)
8326 offset |= ~ (bfd_vma) 0x7fffffff;
8328 else if (arm_sec->rel_type == SHT_RELA)
8329 offset = rp->r_addend;
8332 error (_("Unknown section relocation type %d encountered\n"),
8337 /* PR 17531 file: 027-1241568-0.004. */
8338 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8340 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8341 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8345 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8346 offset += sym->st_value;
8347 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8349 /* Check that we are processing the expected reloc type. */
8350 if (filedata->file_header.e_machine == EM_ARM)
8352 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8353 if (relname == NULL)
8355 warn (_("Skipping unknown ARM relocation type: %d\n"),
8356 (int) ELF32_R_TYPE (rp->r_info));
8360 if (streq (relname, "R_ARM_NONE"))
8363 if (! streq (relname, "R_ARM_PREL31"))
8365 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8369 else if (filedata->file_header.e_machine == EM_TI_C6000)
8371 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8372 if (relname == NULL)
8374 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8375 (int) ELF32_R_TYPE (rp->r_info));
8379 if (streq (relname, "R_C6000_NONE"))
8382 if (! streq (relname, "R_C6000_PREL31"))
8384 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8392 /* This function currently only supports ARM and TI unwinders. */
8393 warn (_("Only TI and ARM unwinders are currently supported\n"));
8397 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8398 addr->section = sym->st_shndx;
8399 addr->offset = offset;
8402 * sym_name = sym->st_name;
8407 arm_sec->next_rela = rp;
8412 static const char *tic6x_unwind_regnames[16] =
8414 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8415 "A14", "A13", "A12", "A11", "A10",
8416 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8420 decode_tic6x_unwind_regmask (unsigned int mask)
8424 for (i = 12; mask; mask >>= 1, i--)
8428 fputs (tic6x_unwind_regnames[i], stdout);
8430 fputs (", ", stdout);
8436 if (remaining == 0 && more_words) \
8439 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8440 data_offset, & word, & addr, NULL)) \
8446 #define GET_OP(OP) \
8451 (OP) = word >> 24; \
8456 printf (_("[Truncated opcode]\n")); \
8459 printf ("0x%02x ", OP)
8462 decode_arm_unwind_bytecode (Filedata * filedata,
8463 struct arm_unw_aux_info * aux,
8465 unsigned int remaining,
8466 unsigned int more_words,
8467 bfd_vma data_offset,
8468 Elf_Internal_Shdr * data_sec,
8469 struct arm_section * data_arm_sec)
8471 struct absaddr addr;
8472 bfd_boolean res = TRUE;
8474 /* Decode the unwinding instructions. */
8477 unsigned int op, op2;
8486 printf (" 0x%02x ", op);
8488 if ((op & 0xc0) == 0x00)
8490 int offset = ((op & 0x3f) << 2) + 4;
8492 printf (" vsp = vsp + %d", offset);
8494 else if ((op & 0xc0) == 0x40)
8496 int offset = ((op & 0x3f) << 2) + 4;
8498 printf (" vsp = vsp - %d", offset);
8500 else if ((op & 0xf0) == 0x80)
8503 if (op == 0x80 && op2 == 0)
8504 printf (_("Refuse to unwind"));
8507 unsigned int mask = ((op & 0x0f) << 8) | op2;
8508 bfd_boolean first = TRUE;
8512 for (i = 0; i < 12; i++)
8513 if (mask & (1 << i))
8519 printf ("r%d", 4 + i);
8524 else if ((op & 0xf0) == 0x90)
8526 if (op == 0x9d || op == 0x9f)
8527 printf (_(" [Reserved]"));
8529 printf (" vsp = r%d", op & 0x0f);
8531 else if ((op & 0xf0) == 0xa0)
8533 int end = 4 + (op & 0x07);
8534 bfd_boolean first = TRUE;
8538 for (i = 4; i <= end; i++)
8554 else if (op == 0xb0)
8555 printf (_(" finish"));
8556 else if (op == 0xb1)
8559 if (op2 == 0 || (op2 & 0xf0) != 0)
8560 printf (_("[Spare]"));
8563 unsigned int mask = op2 & 0x0f;
8564 bfd_boolean first = TRUE;
8568 for (i = 0; i < 12; i++)
8569 if (mask & (1 << i))
8580 else if (op == 0xb2)
8582 unsigned char buf[9];
8583 unsigned int i, len;
8584 unsigned long offset;
8586 for (i = 0; i < sizeof (buf); i++)
8589 if ((buf[i] & 0x80) == 0)
8592 if (i == sizeof (buf))
8594 error (_("corrupt change to vsp"));
8599 offset = read_uleb128 (buf, &len, buf + i + 1);
8600 assert (len == i + 1);
8601 offset = offset * 4 + 0x204;
8602 printf ("vsp = vsp + %ld", offset);
8605 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8607 unsigned int first, last;
8614 printf ("pop {D%d", first);
8616 printf ("-D%d", first + last);
8619 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8621 unsigned int count = op & 0x07;
8625 printf ("-D%d", 8 + count);
8628 else if (op >= 0xc0 && op <= 0xc5)
8630 unsigned int count = op & 0x07;
8632 printf (" pop {wR10");
8634 printf ("-wR%d", 10 + count);
8637 else if (op == 0xc6)
8639 unsigned int first, last;
8644 printf ("pop {wR%d", first);
8646 printf ("-wR%d", first + last);
8649 else if (op == 0xc7)
8652 if (op2 == 0 || (op2 & 0xf0) != 0)
8653 printf (_("[Spare]"));
8656 unsigned int mask = op2 & 0x0f;
8657 bfd_boolean first = TRUE;
8661 for (i = 0; i < 4; i++)
8662 if (mask & (1 << i))
8668 printf ("wCGR%d", i);
8675 printf (_(" [unsupported opcode]"));
8686 decode_tic6x_unwind_bytecode (Filedata * filedata,
8687 struct arm_unw_aux_info * aux,
8689 unsigned int remaining,
8690 unsigned int more_words,
8691 bfd_vma data_offset,
8692 Elf_Internal_Shdr * data_sec,
8693 struct arm_section * data_arm_sec)
8695 struct absaddr addr;
8697 /* Decode the unwinding instructions. */
8700 unsigned int op, op2;
8709 printf (" 0x%02x ", op);
8711 if ((op & 0xc0) == 0x00)
8713 int offset = ((op & 0x3f) << 3) + 8;
8714 printf (" sp = sp + %d", offset);
8716 else if ((op & 0xc0) == 0x80)
8719 if (op == 0x80 && op2 == 0)
8720 printf (_("Refuse to unwind"));
8723 unsigned int mask = ((op & 0x1f) << 8) | op2;
8725 printf ("pop compact {");
8729 decode_tic6x_unwind_regmask (mask);
8733 else if ((op & 0xf0) == 0xc0)
8741 unsigned int offset;
8745 /* Scan entire instruction first so that GET_OP output is not
8746 interleaved with disassembly. */
8748 for (i = 0; nregs < (op & 0xf); i++)
8754 regpos[nregs].offset = i * 2;
8755 regpos[nregs].reg = reg;
8762 regpos[nregs].offset = i * 2 + 1;
8763 regpos[nregs].reg = reg;
8768 printf (_("pop frame {"));
8770 for (i = i * 2; i > 0; i--)
8772 if (regpos[reg].offset == i - 1)
8774 name = tic6x_unwind_regnames[regpos[reg].reg];
8781 fputs (name, stdout);
8788 else if (op == 0xd0)
8789 printf (" MOV FP, SP");
8790 else if (op == 0xd1)
8791 printf (" __c6xabi_pop_rts");
8792 else if (op == 0xd2)
8794 unsigned char buf[9];
8795 unsigned int i, len;
8796 unsigned long offset;
8798 for (i = 0; i < sizeof (buf); i++)
8801 if ((buf[i] & 0x80) == 0)
8804 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8805 if (i == sizeof (buf))
8807 warn (_("Corrupt stack pointer adjustment detected\n"));
8811 offset = read_uleb128 (buf, &len, buf + i + 1);
8812 assert (len == i + 1);
8813 offset = offset * 8 + 0x408;
8814 printf (_("sp = sp + %ld"), offset);
8816 else if ((op & 0xf0) == 0xe0)
8818 if ((op & 0x0f) == 7)
8821 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8825 printf (_(" [unsupported opcode]"));
8834 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8838 offset = word & 0x7fffffff;
8839 if (offset & 0x40000000)
8840 offset |= ~ (bfd_vma) 0x7fffffff;
8842 if (filedata->file_header.e_machine == EM_TI_C6000)
8845 return offset + where;
8849 decode_arm_unwind (Filedata * filedata,
8850 struct arm_unw_aux_info * aux,
8852 unsigned int remaining,
8853 bfd_vma data_offset,
8854 Elf_Internal_Shdr * data_sec,
8855 struct arm_section * data_arm_sec)
8858 unsigned int more_words = 0;
8859 struct absaddr addr;
8860 bfd_vma sym_name = (bfd_vma) -1;
8861 bfd_boolean res = TRUE;
8865 /* Fetch the first word.
8866 Note - when decoding an object file the address extracted
8867 here will always be 0. So we also pass in the sym_name
8868 parameter so that we can find the symbol associated with
8869 the personality routine. */
8870 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8871 & word, & addr, & sym_name))
8877 if ((word & 0x80000000) == 0)
8879 /* Expand prel31 for personality routine. */
8881 const char *procname;
8883 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8884 printf (_(" Personality routine: "));
8886 && addr.section == SHN_UNDEF && addr.offset == 0
8887 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8889 procname = aux->strtab + sym_name;
8890 print_vma (fn, PREFIX_HEX);
8893 fputs (" <", stdout);
8894 fputs (procname, stdout);
8895 fputc ('>', stdout);
8899 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8900 fputc ('\n', stdout);
8902 /* The GCC personality routines use the standard compact
8903 encoding, starting with one byte giving the number of
8905 if (procname != NULL
8906 && (const_strneq (procname, "__gcc_personality_v0")
8907 || const_strneq (procname, "__gxx_personality_v0")
8908 || const_strneq (procname, "__gcj_personality_v0")
8909 || const_strneq (procname, "__gnu_objc_personality_v0")))
8916 printf (_(" [Truncated data]\n"));
8919 more_words = word >> 24;
8929 /* ARM EHABI Section 6.3:
8931 An exception-handling table entry for the compact model looks like:
8935 1 0 index Data for personalityRoutine[index] */
8937 if (filedata->file_header.e_machine == EM_ARM
8938 && (word & 0x70000000))
8940 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8944 per_index = (word >> 24) & 0x7f;
8945 printf (_(" Compact model index: %d\n"), per_index);
8952 else if (per_index < 3)
8954 more_words = (word >> 16) & 0xff;
8960 switch (filedata->file_header.e_machine)
8965 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8966 data_offset, data_sec, data_arm_sec))
8971 warn (_("Unknown ARM compact model index encountered\n"));
8972 printf (_(" [reserved]\n"));
8980 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8981 data_offset, data_sec, data_arm_sec))
8984 else if (per_index < 5)
8986 if (((word >> 17) & 0x7f) == 0x7f)
8987 printf (_(" Restore stack from frame pointer\n"));
8989 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8990 printf (_(" Registers restored: "));
8992 printf (" (compact) ");
8993 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8995 printf (_(" Return register: %s\n"),
8996 tic6x_unwind_regnames[word & 0xf]);
8999 printf (_(" [reserved (%d)]\n"), per_index);
9003 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9004 filedata->file_header.e_machine);
9008 /* Decode the descriptors. Not implemented. */
9014 dump_arm_unwind (Filedata * filedata,
9015 struct arm_unw_aux_info * aux,
9016 Elf_Internal_Shdr * exidx_sec)
9018 struct arm_section exidx_arm_sec, extab_arm_sec;
9019 unsigned int i, exidx_len;
9020 unsigned long j, nfuns;
9021 bfd_boolean res = TRUE;
9023 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9024 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9025 exidx_len = exidx_sec->sh_size / 8;
9027 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9028 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9029 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9030 aux->funtab[nfuns++] = aux->symtab[j];
9032 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9034 for (i = 0; i < exidx_len; i++)
9036 unsigned int exidx_fn, exidx_entry;
9037 struct absaddr fn_addr, entry_addr;
9040 fputc ('\n', stdout);
9042 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9043 8 * i, & exidx_fn, & fn_addr, NULL)
9044 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9045 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9048 arm_free_section (& exidx_arm_sec);
9049 arm_free_section (& extab_arm_sec);
9053 /* ARM EHABI, Section 5:
9054 An index table entry consists of 2 words.
9055 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9056 if (exidx_fn & 0x80000000)
9058 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9062 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9064 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9065 fputs (": ", stdout);
9067 if (exidx_entry == 1)
9069 print_vma (exidx_entry, PREFIX_HEX);
9070 fputs (" [cantunwind]\n", stdout);
9072 else if (exidx_entry & 0x80000000)
9074 print_vma (exidx_entry, PREFIX_HEX);
9075 fputc ('\n', stdout);
9076 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9080 bfd_vma table, table_offset = 0;
9081 Elf_Internal_Shdr *table_sec;
9083 fputs ("@", stdout);
9084 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9085 print_vma (table, PREFIX_HEX);
9088 /* Locate the matching .ARM.extab. */
9089 if (entry_addr.section != SHN_UNDEF
9090 && entry_addr.section < filedata->file_header.e_shnum)
9092 table_sec = filedata->section_headers + entry_addr.section;
9093 table_offset = entry_addr.offset;
9095 if (table_offset > table_sec->sh_size
9096 || ((bfd_signed_vma) table_offset) < 0)
9098 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9099 (unsigned long) table_offset,
9100 printable_section_name (filedata, table_sec));
9107 table_sec = find_section_by_address (filedata, table);
9108 if (table_sec != NULL)
9109 table_offset = table - table_sec->sh_addr;
9112 if (table_sec == NULL)
9114 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9115 (unsigned long) table);
9120 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9129 arm_free_section (&exidx_arm_sec);
9130 arm_free_section (&extab_arm_sec);
9135 /* Used for both ARM and C6X unwinding tables. */
9138 arm_process_unwind (Filedata * filedata)
9140 struct arm_unw_aux_info aux;
9141 Elf_Internal_Shdr *unwsec = NULL;
9142 Elf_Internal_Shdr *strsec;
9143 Elf_Internal_Shdr *sec;
9145 unsigned int sec_type;
9146 bfd_boolean res = TRUE;
9148 switch (filedata->file_header.e_machine)
9151 sec_type = SHT_ARM_EXIDX;
9155 sec_type = SHT_C6000_UNWIND;
9159 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9160 filedata->file_header.e_machine);
9164 if (filedata->string_table == NULL)
9167 memset (& aux, 0, sizeof (aux));
9168 aux.filedata = filedata;
9170 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9172 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9174 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9176 strsec = filedata->section_headers + sec->sh_link;
9178 /* PR binutils/17531 file: 011-12666-0.004. */
9179 if (aux.strtab != NULL)
9181 error (_("Multiple string tables found in file.\n"));
9185 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9186 1, strsec->sh_size, _("string table"));
9187 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9189 else if (sec->sh_type == sec_type)
9194 printf (_("\nThere are no unwind sections in this file.\n"));
9196 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9198 if (sec->sh_type == sec_type)
9200 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9201 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9202 "contains %lu entry:\n",
9203 "\nUnwind section '%s' at offset 0x%lx "
9204 "contains %lu entries:\n",
9206 printable_section_name (filedata, sec),
9207 (unsigned long) sec->sh_offset,
9210 if (! dump_arm_unwind (filedata, &aux, sec))
9218 free ((char *) aux.strtab);
9224 process_unwind (Filedata * filedata)
9226 struct unwind_handler
9228 unsigned int machtype;
9229 bfd_boolean (* handler)(Filedata *);
9232 { EM_ARM, arm_process_unwind },
9233 { EM_IA_64, ia64_process_unwind },
9234 { EM_PARISC, hppa_process_unwind },
9235 { EM_TI_C6000, arm_process_unwind },
9243 for (i = 0; handlers[i].handler != NULL; i++)
9244 if (filedata->file_header.e_machine == handlers[i].machtype)
9245 return handlers[i].handler (filedata);
9247 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9248 get_machine_name (filedata->file_header.e_machine));
9253 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9255 switch (entry->d_tag)
9258 if (entry->d_un.d_val == 0)
9262 static const char * opts[] =
9264 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9265 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9266 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9267 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9271 bfd_boolean first = TRUE;
9273 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9274 if (entry->d_un.d_val & (1 << cnt))
9276 printf ("%s%s", first ? "" : " ", opts[cnt]);
9282 case DT_MIPS_IVERSION:
9283 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9284 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9288 sprintf_vma (buf, entry->d_un.d_ptr);
9289 /* Note: coded this way so that there is a single string for translation. */
9290 printf (_("<corrupt: %s>"), buf);
9294 case DT_MIPS_TIME_STAMP:
9298 time_t atime = entry->d_un.d_val;
9300 tmp = gmtime (&atime);
9301 /* PR 17531: file: 6accc532. */
9303 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9305 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9306 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9307 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9308 printf (_("Time Stamp: %s"), timebuf);
9312 case DT_MIPS_RLD_VERSION:
9313 case DT_MIPS_LOCAL_GOTNO:
9314 case DT_MIPS_CONFLICTNO:
9315 case DT_MIPS_LIBLISTNO:
9316 case DT_MIPS_SYMTABNO:
9317 case DT_MIPS_UNREFEXTNO:
9318 case DT_MIPS_HIPAGENO:
9319 case DT_MIPS_DELTA_CLASS_NO:
9320 case DT_MIPS_DELTA_INSTANCE_NO:
9321 case DT_MIPS_DELTA_RELOC_NO:
9322 case DT_MIPS_DELTA_SYM_NO:
9323 case DT_MIPS_DELTA_CLASSSYM_NO:
9324 case DT_MIPS_COMPACT_SIZE:
9325 print_vma (entry->d_un.d_val, DEC);
9329 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9335 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9337 switch (entry->d_tag)
9339 case DT_HP_DLD_FLAGS:
9348 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9349 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9350 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9351 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9352 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9353 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9354 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9355 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9356 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9357 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9358 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9359 { DT_HP_GST, "HP_GST" },
9360 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9361 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9362 { DT_HP_NODELETE, "HP_NODELETE" },
9363 { DT_HP_GROUP, "HP_GROUP" },
9364 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9366 bfd_boolean first = TRUE;
9368 bfd_vma val = entry->d_un.d_val;
9370 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9371 if (val & flags[cnt].bit)
9375 fputs (flags[cnt].str, stdout);
9377 val ^= flags[cnt].bit;
9380 if (val != 0 || first)
9384 print_vma (val, HEX);
9390 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9398 /* VMS vs Unix time offset and factor. */
9400 #define VMS_EPOCH_OFFSET 35067168000000000LL
9401 #define VMS_GRANULARITY_FACTOR 10000000
9403 /* Display a VMS time in a human readable format. */
9406 print_vms_time (bfd_int64_t vmstime)
9411 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9412 tm = gmtime (&unxtime);
9413 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9414 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9415 tm->tm_hour, tm->tm_min, tm->tm_sec);
9420 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9422 switch (entry->d_tag)
9424 case DT_IA_64_PLT_RESERVE:
9425 /* First 3 slots reserved. */
9426 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9428 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9431 case DT_IA_64_VMS_LINKTIME:
9433 print_vms_time (entry->d_un.d_val);
9437 case DT_IA_64_VMS_LNKFLAGS:
9438 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9439 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9440 printf (" CALL_DEBUG");
9441 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9442 printf (" NOP0BUFS");
9443 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9444 printf (" P0IMAGE");
9445 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9446 printf (" MKTHREADS");
9447 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9448 printf (" UPCALLS");
9449 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9451 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9452 printf (" INITIALIZE");
9453 if (entry->d_un.d_val & VMS_LF_MAIN)
9455 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9456 printf (" EXE_INIT");
9457 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9458 printf (" TBK_IN_IMG");
9459 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9460 printf (" DBG_IN_IMG");
9461 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9462 printf (" TBK_IN_DSF");
9463 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9464 printf (" DBG_IN_DSF");
9465 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9466 printf (" SIGNATURES");
9467 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9468 printf (" REL_SEG_OFF");
9472 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9479 get_32bit_dynamic_section (Filedata * filedata)
9481 Elf32_External_Dyn * edyn;
9482 Elf32_External_Dyn * ext;
9483 Elf_Internal_Dyn * entry;
9485 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9486 dynamic_size, _("dynamic section"));
9490 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9491 might not have the luxury of section headers. Look for the DT_NULL
9492 terminator to determine the number of entries. */
9493 for (ext = edyn, dynamic_nent = 0;
9494 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9498 if (BYTE_GET (ext->d_tag) == DT_NULL)
9502 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9504 if (dynamic_section == NULL)
9506 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9507 (unsigned long) dynamic_nent);
9512 for (ext = edyn, entry = dynamic_section;
9513 entry < dynamic_section + dynamic_nent;
9516 entry->d_tag = BYTE_GET (ext->d_tag);
9517 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9526 get_64bit_dynamic_section (Filedata * filedata)
9528 Elf64_External_Dyn * edyn;
9529 Elf64_External_Dyn * ext;
9530 Elf_Internal_Dyn * entry;
9532 /* Read in the data. */
9533 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9534 dynamic_size, _("dynamic section"));
9538 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9539 might not have the luxury of section headers. Look for the DT_NULL
9540 terminator to determine the number of entries. */
9541 for (ext = edyn, dynamic_nent = 0;
9542 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9543 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9547 if (BYTE_GET (ext->d_tag) == DT_NULL)
9551 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9553 if (dynamic_section == NULL)
9555 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9556 (unsigned long) dynamic_nent);
9561 /* Convert from external to internal formats. */
9562 for (ext = edyn, entry = dynamic_section;
9563 entry < dynamic_section + dynamic_nent;
9566 entry->d_tag = BYTE_GET (ext->d_tag);
9567 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9576 print_dynamic_flags (bfd_vma flags)
9578 bfd_boolean first = TRUE;
9584 flag = flags & - flags;
9594 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9595 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9596 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9597 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9598 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9599 default: fputs (_("unknown"), stdout); break;
9605 /* Parse and display the contents of the dynamic section. */
9608 process_dynamic_section (Filedata * filedata)
9610 Elf_Internal_Dyn * entry;
9612 if (dynamic_size == 0)
9615 printf (_("\nThere is no dynamic section in this file.\n"));
9622 if (! get_32bit_dynamic_section (filedata))
9627 if (! get_64bit_dynamic_section (filedata))
9631 /* Find the appropriate symbol table. */
9632 if (dynamic_symbols == NULL)
9634 for (entry = dynamic_section;
9635 entry < dynamic_section + dynamic_nent;
9638 Elf_Internal_Shdr section;
9640 if (entry->d_tag != DT_SYMTAB)
9643 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9645 /* Since we do not know how big the symbol table is,
9646 we default to reading in the entire file (!) and
9647 processing that. This is overkill, I know, but it
9649 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9650 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9652 /* See PR 21379 for a reproducer. */
9653 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9657 if (archive_file_offset != 0)
9658 section.sh_size = archive_file_size - section.sh_offset;
9660 section.sh_size = filedata->file_size - section.sh_offset;
9663 section.sh_entsize = sizeof (Elf32_External_Sym);
9665 section.sh_entsize = sizeof (Elf64_External_Sym);
9666 section.sh_name = filedata->string_table_length;
9668 dynamic_symbols = GET_ELF_SYMBOLS (filedata, §ion, & num_dynamic_syms);
9669 if (num_dynamic_syms < 1)
9671 error (_("Unable to determine the number of symbols to load\n"));
9677 /* Similarly find a string table. */
9678 if (dynamic_strings == NULL)
9680 for (entry = dynamic_section;
9681 entry < dynamic_section + dynamic_nent;
9684 unsigned long offset;
9687 if (entry->d_tag != DT_STRTAB)
9690 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9692 /* Since we do not know how big the string table is,
9693 we default to reading in the entire file (!) and
9694 processing that. This is overkill, I know, but it
9697 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9699 if (archive_file_offset != 0)
9700 str_tab_len = archive_file_size - offset;
9702 str_tab_len = filedata->file_size - offset;
9704 if (str_tab_len < 1)
9707 (_("Unable to determine the length of the dynamic string table\n"));
9711 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9713 _("dynamic string table"));
9714 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9719 /* And find the syminfo section if available. */
9720 if (dynamic_syminfo == NULL)
9722 unsigned long syminsz = 0;
9724 for (entry = dynamic_section;
9725 entry < dynamic_section + dynamic_nent;
9728 if (entry->d_tag == DT_SYMINENT)
9730 /* Note: these braces are necessary to avoid a syntax
9731 error from the SunOS4 C compiler. */
9732 /* PR binutils/17531: A corrupt file can trigger this test.
9733 So do not use an assert, instead generate an error message. */
9734 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9735 error (_("Bad value (%d) for SYMINENT entry\n"),
9736 (int) entry->d_un.d_val);
9738 else if (entry->d_tag == DT_SYMINSZ)
9739 syminsz = entry->d_un.d_val;
9740 else if (entry->d_tag == DT_SYMINFO)
9741 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9745 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9747 Elf_External_Syminfo * extsyminfo;
9748 Elf_External_Syminfo * extsym;
9749 Elf_Internal_Syminfo * syminfo;
9751 /* There is a syminfo section. Read the data. */
9752 extsyminfo = (Elf_External_Syminfo *)
9753 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9754 _("symbol information"));
9758 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9759 if (dynamic_syminfo == NULL)
9761 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9762 (unsigned long) syminsz);
9766 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9767 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9768 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9769 ++syminfo, ++extsym)
9771 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9772 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9779 if (do_dynamic && dynamic_addr)
9780 printf (ngettext ("\nDynamic section at offset 0x%lx "
9781 "contains %lu entry:\n",
9782 "\nDynamic section at offset 0x%lx "
9783 "contains %lu entries:\n",
9785 dynamic_addr, (unsigned long) dynamic_nent);
9787 printf (_(" Tag Type Name/Value\n"));
9789 for (entry = dynamic_section;
9790 entry < dynamic_section + dynamic_nent;
9798 print_vma (entry->d_tag, FULL_HEX);
9799 dtype = get_dynamic_type (filedata, entry->d_tag);
9800 printf (" (%s)%*s", dtype,
9801 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9804 switch (entry->d_tag)
9808 print_dynamic_flags (entry->d_un.d_val);
9818 switch (entry->d_tag)
9821 printf (_("Auxiliary library"));
9825 printf (_("Filter library"));
9829 printf (_("Configuration file"));
9833 printf (_("Dependency audit library"));
9837 printf (_("Audit library"));
9841 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9842 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9846 print_vma (entry->d_un.d_val, PREFIX_HEX);
9855 printf (_("Flags:"));
9857 if (entry->d_un.d_val == 0)
9858 printf (_(" None\n"));
9861 unsigned long int val = entry->d_un.d_val;
9863 if (val & DTF_1_PARINIT)
9865 printf (" PARINIT");
9866 val ^= DTF_1_PARINIT;
9868 if (val & DTF_1_CONFEXP)
9870 printf (" CONFEXP");
9871 val ^= DTF_1_CONFEXP;
9874 printf (" %lx", val);
9883 printf (_("Flags:"));
9885 if (entry->d_un.d_val == 0)
9886 printf (_(" None\n"));
9889 unsigned long int val = entry->d_un.d_val;
9891 if (val & DF_P1_LAZYLOAD)
9893 printf (" LAZYLOAD");
9894 val ^= DF_P1_LAZYLOAD;
9896 if (val & DF_P1_GROUPPERM)
9898 printf (" GROUPPERM");
9899 val ^= DF_P1_GROUPPERM;
9902 printf (" %lx", val);
9911 printf (_("Flags:"));
9912 if (entry->d_un.d_val == 0)
9913 printf (_(" None\n"));
9916 unsigned long int val = entry->d_un.d_val;
9923 if (val & DF_1_GLOBAL)
9928 if (val & DF_1_GROUP)
9933 if (val & DF_1_NODELETE)
9935 printf (" NODELETE");
9936 val ^= DF_1_NODELETE;
9938 if (val & DF_1_LOADFLTR)
9940 printf (" LOADFLTR");
9941 val ^= DF_1_LOADFLTR;
9943 if (val & DF_1_INITFIRST)
9945 printf (" INITFIRST");
9946 val ^= DF_1_INITFIRST;
9948 if (val & DF_1_NOOPEN)
9953 if (val & DF_1_ORIGIN)
9958 if (val & DF_1_DIRECT)
9963 if (val & DF_1_TRANS)
9968 if (val & DF_1_INTERPOSE)
9970 printf (" INTERPOSE");
9971 val ^= DF_1_INTERPOSE;
9973 if (val & DF_1_NODEFLIB)
9975 printf (" NODEFLIB");
9976 val ^= DF_1_NODEFLIB;
9978 if (val & DF_1_NODUMP)
9983 if (val & DF_1_CONFALT)
9985 printf (" CONFALT");
9986 val ^= DF_1_CONFALT;
9988 if (val & DF_1_ENDFILTEE)
9990 printf (" ENDFILTEE");
9991 val ^= DF_1_ENDFILTEE;
9993 if (val & DF_1_DISPRELDNE)
9995 printf (" DISPRELDNE");
9996 val ^= DF_1_DISPRELDNE;
9998 if (val & DF_1_DISPRELPND)
10000 printf (" DISPRELPND");
10001 val ^= DF_1_DISPRELPND;
10003 if (val & DF_1_NODIRECT)
10005 printf (" NODIRECT");
10006 val ^= DF_1_NODIRECT;
10008 if (val & DF_1_IGNMULDEF)
10010 printf (" IGNMULDEF");
10011 val ^= DF_1_IGNMULDEF;
10013 if (val & DF_1_NOKSYMS)
10015 printf (" NOKSYMS");
10016 val ^= DF_1_NOKSYMS;
10018 if (val & DF_1_NOHDR)
10023 if (val & DF_1_EDITED)
10025 printf (" EDITED");
10026 val ^= DF_1_EDITED;
10028 if (val & DF_1_NORELOC)
10030 printf (" NORELOC");
10031 val ^= DF_1_NORELOC;
10033 if (val & DF_1_SYMINTPOSE)
10035 printf (" SYMINTPOSE");
10036 val ^= DF_1_SYMINTPOSE;
10038 if (val & DF_1_GLOBAUDIT)
10040 printf (" GLOBAUDIT");
10041 val ^= DF_1_GLOBAUDIT;
10043 if (val & DF_1_SINGLETON)
10045 printf (" SINGLETON");
10046 val ^= DF_1_SINGLETON;
10048 if (val & DF_1_STUB)
10053 if (val & DF_1_PIE)
10058 if (val & DF_1_KMOD)
10063 if (val & DF_1_WEAKFILTER)
10065 printf (" WEAKFILTER");
10066 val ^= DF_1_WEAKFILTER;
10068 if (val & DF_1_NOCOMMON)
10070 printf (" NOCOMMON");
10071 val ^= DF_1_NOCOMMON;
10074 printf (" %lx", val);
10081 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10083 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10103 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10109 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10110 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10116 switch (entry->d_tag)
10119 printf (_("Shared library: [%s]"), name);
10121 if (streq (name, program_interpreter))
10122 printf (_(" program interpreter"));
10126 printf (_("Library soname: [%s]"), name);
10130 printf (_("Library rpath: [%s]"), name);
10134 printf (_("Library runpath: [%s]"), name);
10138 print_vma (entry->d_un.d_val, PREFIX_HEX);
10143 print_vma (entry->d_un.d_val, PREFIX_HEX);
10156 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10157 /* Fall through. */
10161 case DT_INIT_ARRAYSZ:
10162 case DT_FINI_ARRAYSZ:
10163 case DT_GNU_CONFLICTSZ:
10164 case DT_GNU_LIBLISTSZ:
10167 print_vma (entry->d_un.d_val, UNSIGNED);
10168 printf (_(" (bytes)\n"));
10173 case DT_VERNEEDNUM:
10178 print_vma (entry->d_un.d_val, UNSIGNED);
10187 case DT_INIT_ARRAY:
10188 case DT_FINI_ARRAY:
10191 if (entry->d_tag == DT_USED
10192 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10194 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10198 printf (_("Not needed object: [%s]\n"), name);
10203 print_vma (entry->d_un.d_val, PREFIX_HEX);
10209 /* The value of this entry is ignored. */
10214 case DT_GNU_PRELINKED:
10218 time_t atime = entry->d_un.d_val;
10220 tmp = gmtime (&atime);
10221 /* PR 17533 file: 041-1244816-0.004. */
10223 printf (_("<corrupt time val: %lx"),
10224 (unsigned long) atime);
10226 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10227 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10228 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10234 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10237 print_vma (entry->d_un.d_val, PREFIX_HEX);
10243 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10244 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10249 switch (filedata->file_header.e_machine)
10252 case EM_MIPS_RS3_LE:
10253 dynamic_section_mips_val (entry);
10256 dynamic_section_parisc_val (entry);
10259 dynamic_section_ia64_val (entry);
10262 print_vma (entry->d_un.d_val, PREFIX_HEX);
10274 get_ver_flags (unsigned int flags)
10276 static char buff[128];
10283 if (flags & VER_FLG_BASE)
10284 strcat (buff, "BASE");
10286 if (flags & VER_FLG_WEAK)
10288 if (flags & VER_FLG_BASE)
10289 strcat (buff, " | ");
10291 strcat (buff, "WEAK");
10294 if (flags & VER_FLG_INFO)
10296 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10297 strcat (buff, " | ");
10299 strcat (buff, "INFO");
10302 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10304 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10305 strcat (buff, " | ");
10307 strcat (buff, _("<unknown>"));
10313 /* Display the contents of the version sections. */
10316 process_version_sections (Filedata * filedata)
10318 Elf_Internal_Shdr * section;
10320 bfd_boolean found = FALSE;
10325 for (i = 0, section = filedata->section_headers;
10326 i < filedata->file_header.e_shnum;
10329 switch (section->sh_type)
10331 case SHT_GNU_verdef:
10333 Elf_External_Verdef * edefs;
10340 printf (ngettext ("\nVersion definition section '%s' "
10341 "contains %u entry:\n",
10342 "\nVersion definition section '%s' "
10343 "contains %u entries:\n",
10345 printable_section_name (filedata, section),
10348 printf (_(" Addr: 0x"));
10349 printf_vma (section->sh_addr);
10350 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10351 (unsigned long) section->sh_offset, section->sh_link,
10352 printable_section_name_from_index (filedata, section->sh_link));
10354 edefs = (Elf_External_Verdef *)
10355 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10356 _("version definition section"));
10359 endbuf = (char *) edefs + section->sh_size;
10361 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10364 Elf_External_Verdef * edef;
10365 Elf_Internal_Verdef ent;
10366 Elf_External_Verdaux * eaux;
10367 Elf_Internal_Verdaux aux;
10368 unsigned long isum;
10371 vstart = ((char *) edefs) + idx;
10372 if (vstart + sizeof (*edef) > endbuf)
10375 edef = (Elf_External_Verdef *) vstart;
10377 ent.vd_version = BYTE_GET (edef->vd_version);
10378 ent.vd_flags = BYTE_GET (edef->vd_flags);
10379 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10380 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10381 ent.vd_hash = BYTE_GET (edef->vd_hash);
10382 ent.vd_aux = BYTE_GET (edef->vd_aux);
10383 ent.vd_next = BYTE_GET (edef->vd_next);
10385 printf (_(" %#06lx: Rev: %d Flags: %s"),
10386 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10388 printf (_(" Index: %d Cnt: %d "),
10389 ent.vd_ndx, ent.vd_cnt);
10391 /* Check for overflow. */
10392 if (ent.vd_aux > (size_t) (endbuf - vstart))
10395 vstart += ent.vd_aux;
10397 if (vstart + sizeof (*eaux) > endbuf)
10399 eaux = (Elf_External_Verdaux *) vstart;
10401 aux.vda_name = BYTE_GET (eaux->vda_name);
10402 aux.vda_next = BYTE_GET (eaux->vda_next);
10404 if (VALID_DYNAMIC_NAME (aux.vda_name))
10405 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10407 printf (_("Name index: %ld\n"), aux.vda_name);
10409 isum = idx + ent.vd_aux;
10411 for (j = 1; j < ent.vd_cnt; j++)
10413 if (aux.vda_next < sizeof (*eaux)
10414 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10416 warn (_("Invalid vda_next field of %lx\n"),
10421 /* Check for overflow. */
10422 if (aux.vda_next > (size_t) (endbuf - vstart))
10425 isum += aux.vda_next;
10426 vstart += aux.vda_next;
10428 if (vstart + sizeof (*eaux) > endbuf)
10430 eaux = (Elf_External_Verdaux *) vstart;
10432 aux.vda_name = BYTE_GET (eaux->vda_name);
10433 aux.vda_next = BYTE_GET (eaux->vda_next);
10435 if (VALID_DYNAMIC_NAME (aux.vda_name))
10436 printf (_(" %#06lx: Parent %d: %s\n"),
10437 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10439 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10440 isum, j, aux.vda_name);
10443 if (j < ent.vd_cnt)
10444 printf (_(" Version def aux past end of section\n"));
10447 file: id:000001,src:000172+005151,op:splice,rep:2. */
10448 if (ent.vd_next < sizeof (*edef)
10449 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10451 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10452 cnt = section->sh_info;
10455 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10458 idx += ent.vd_next;
10461 if (cnt < section->sh_info)
10462 printf (_(" Version definition past end of section\n"));
10468 case SHT_GNU_verneed:
10470 Elf_External_Verneed * eneed;
10477 printf (ngettext ("\nVersion needs section '%s' "
10478 "contains %u entry:\n",
10479 "\nVersion needs section '%s' "
10480 "contains %u entries:\n",
10482 printable_section_name (filedata, section), section->sh_info);
10484 printf (_(" Addr: 0x"));
10485 printf_vma (section->sh_addr);
10486 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10487 (unsigned long) section->sh_offset, section->sh_link,
10488 printable_section_name_from_index (filedata, section->sh_link));
10490 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10491 section->sh_offset, 1,
10493 _("Version Needs section"));
10496 endbuf = (char *) eneed + section->sh_size;
10498 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10500 Elf_External_Verneed * entry;
10501 Elf_Internal_Verneed ent;
10502 unsigned long isum;
10506 vstart = ((char *) eneed) + idx;
10507 if (vstart + sizeof (*entry) > endbuf)
10510 entry = (Elf_External_Verneed *) vstart;
10512 ent.vn_version = BYTE_GET (entry->vn_version);
10513 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10514 ent.vn_file = BYTE_GET (entry->vn_file);
10515 ent.vn_aux = BYTE_GET (entry->vn_aux);
10516 ent.vn_next = BYTE_GET (entry->vn_next);
10518 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10520 if (VALID_DYNAMIC_NAME (ent.vn_file))
10521 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10523 printf (_(" File: %lx"), ent.vn_file);
10525 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10527 /* Check for overflow. */
10528 if (ent.vn_aux > (size_t) (endbuf - vstart))
10530 vstart += ent.vn_aux;
10532 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10534 Elf_External_Vernaux * eaux;
10535 Elf_Internal_Vernaux aux;
10537 if (vstart + sizeof (*eaux) > endbuf)
10539 eaux = (Elf_External_Vernaux *) vstart;
10541 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10542 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10543 aux.vna_other = BYTE_GET (eaux->vna_other);
10544 aux.vna_name = BYTE_GET (eaux->vna_name);
10545 aux.vna_next = BYTE_GET (eaux->vna_next);
10547 if (VALID_DYNAMIC_NAME (aux.vna_name))
10548 printf (_(" %#06lx: Name: %s"),
10549 isum, GET_DYNAMIC_NAME (aux.vna_name));
10551 printf (_(" %#06lx: Name index: %lx"),
10552 isum, aux.vna_name);
10554 printf (_(" Flags: %s Version: %d\n"),
10555 get_ver_flags (aux.vna_flags), aux.vna_other);
10557 if (aux.vna_next < sizeof (*eaux)
10558 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10560 warn (_("Invalid vna_next field of %lx\n"),
10565 /* Check for overflow. */
10566 if (aux.vna_next > (size_t) (endbuf - vstart))
10568 isum += aux.vna_next;
10569 vstart += aux.vna_next;
10572 if (j < ent.vn_cnt)
10573 warn (_("Missing Version Needs auxillary information\n"));
10575 if (ent.vn_next < sizeof (*entry)
10576 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10578 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10579 cnt = section->sh_info;
10582 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10584 idx += ent.vn_next;
10587 if (cnt < section->sh_info)
10588 warn (_("Missing Version Needs information\n"));
10594 case SHT_GNU_versym:
10596 Elf_Internal_Shdr * link_section;
10599 unsigned char * edata;
10600 unsigned short * data;
10602 Elf_Internal_Sym * symbols;
10603 Elf_Internal_Shdr * string_sec;
10604 unsigned long num_syms;
10607 if (section->sh_link >= filedata->file_header.e_shnum)
10610 link_section = filedata->section_headers + section->sh_link;
10611 total = section->sh_size / sizeof (Elf_External_Versym);
10613 if (link_section->sh_link >= filedata->file_header.e_shnum)
10618 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10619 if (symbols == NULL)
10622 string_sec = filedata->section_headers + link_section->sh_link;
10624 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10625 string_sec->sh_size,
10626 _("version string table"));
10633 printf (ngettext ("\nVersion symbols section '%s' "
10634 "contains %lu entry:\n",
10635 "\nVersion symbols section '%s' "
10636 "contains %lu entries:\n",
10638 printable_section_name (filedata, section), (unsigned long) total);
10640 printf (_(" Addr: "));
10641 printf_vma (section->sh_addr);
10642 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10643 (unsigned long) section->sh_offset, section->sh_link,
10644 printable_section_name (filedata, link_section));
10646 off = offset_from_vma (filedata,
10647 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10648 total * sizeof (short));
10649 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10651 _("version symbol data"));
10659 data = (short unsigned int *) cmalloc (total, sizeof (short));
10661 for (cnt = total; cnt --;)
10662 data[cnt] = byte_get (edata + cnt * sizeof (short),
10667 for (cnt = 0; cnt < total; cnt += 4)
10671 char *invalid = _("*invalid*");
10673 printf (" %03x:", cnt);
10675 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10676 switch (data[cnt + j])
10679 fputs (_(" 0 (*local*) "), stdout);
10683 fputs (_(" 1 (*global*) "), stdout);
10687 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10688 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10690 /* If this index value is greater than the size of the symbols
10691 array, break to avoid an out-of-bounds read. */
10692 if ((unsigned long)(cnt + j) >= num_syms)
10694 warn (_("invalid index into symbol array\n"));
10699 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10701 Elf_Internal_Verneed ivn;
10702 unsigned long offset;
10704 offset = offset_from_vma
10705 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10706 sizeof (Elf_External_Verneed));
10710 Elf_Internal_Vernaux ivna;
10711 Elf_External_Verneed evn;
10712 Elf_External_Vernaux evna;
10713 unsigned long a_off;
10715 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10716 _("version need")) == NULL)
10719 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10720 ivn.vn_next = BYTE_GET (evn.vn_next);
10722 a_off = offset + ivn.vn_aux;
10726 if (get_data (&evna, filedata, a_off, sizeof (evna),
10727 1, _("version need aux (2)")) == NULL)
10730 ivna.vna_other = 0;
10734 ivna.vna_next = BYTE_GET (evna.vna_next);
10735 ivna.vna_other = BYTE_GET (evna.vna_other);
10738 a_off += ivna.vna_next;
10740 while (ivna.vna_other != data[cnt + j]
10741 && ivna.vna_next != 0);
10743 if (ivna.vna_other == data[cnt + j])
10745 ivna.vna_name = BYTE_GET (evna.vna_name);
10747 if (ivna.vna_name >= string_sec->sh_size)
10750 name = strtab + ivna.vna_name;
10754 offset += ivn.vn_next;
10756 while (ivn.vn_next);
10759 if (data[cnt + j] != 0x8001
10760 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10762 Elf_Internal_Verdef ivd;
10763 Elf_External_Verdef evd;
10764 unsigned long offset;
10766 offset = offset_from_vma
10767 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10772 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10773 _("version def")) == NULL)
10776 /* PR 17531: file: 046-1082287-0.004. */
10777 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10782 ivd.vd_next = BYTE_GET (evd.vd_next);
10783 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10786 offset += ivd.vd_next;
10788 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10789 && ivd.vd_next != 0);
10791 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10793 Elf_External_Verdaux evda;
10794 Elf_Internal_Verdaux ivda;
10796 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10798 if (get_data (&evda, filedata,
10799 offset - ivd.vd_next + ivd.vd_aux,
10801 _("version def aux")) == NULL)
10804 ivda.vda_name = BYTE_GET (evda.vda_name);
10806 if (ivda.vda_name >= string_sec->sh_size)
10808 else if (name != NULL && name != invalid)
10809 name = _("*both*");
10811 name = strtab + ivda.vda_name;
10815 nn += printf ("(%s%-*s",
10817 12 - (int) strlen (name),
10821 printf ("%*c", 18 - nn, ' ');
10839 printf (_("\nNo version information found in this file.\n"));
10844 static const char *
10845 get_symbol_binding (Filedata * filedata, unsigned int binding)
10847 static char buff[32];
10851 case STB_LOCAL: return "LOCAL";
10852 case STB_GLOBAL: return "GLOBAL";
10853 case STB_WEAK: return "WEAK";
10855 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10856 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10858 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10860 if (binding == STB_GNU_UNIQUE
10861 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10862 /* GNU is still using the default value 0. */
10863 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10865 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10868 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10873 static const char *
10874 get_symbol_type (Filedata * filedata, unsigned int type)
10876 static char buff[32];
10880 case STT_NOTYPE: return "NOTYPE";
10881 case STT_OBJECT: return "OBJECT";
10882 case STT_FUNC: return "FUNC";
10883 case STT_SECTION: return "SECTION";
10884 case STT_FILE: return "FILE";
10885 case STT_COMMON: return "COMMON";
10886 case STT_TLS: return "TLS";
10887 case STT_RELC: return "RELC";
10888 case STT_SRELC: return "SRELC";
10890 if (type >= STT_LOPROC && type <= STT_HIPROC)
10892 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10893 return "THUMB_FUNC";
10895 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10898 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10899 return "PARISC_MILLI";
10901 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10903 else if (type >= STT_LOOS && type <= STT_HIOS)
10905 if (filedata->file_header.e_machine == EM_PARISC)
10907 if (type == STT_HP_OPAQUE)
10908 return "HP_OPAQUE";
10909 if (type == STT_HP_STUB)
10913 if (type == STT_GNU_IFUNC
10914 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10915 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10916 /* GNU is still using the default value 0. */
10917 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10920 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10923 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10928 static const char *
10929 get_symbol_visibility (unsigned int visibility)
10931 switch (visibility)
10933 case STV_DEFAULT: return "DEFAULT";
10934 case STV_INTERNAL: return "INTERNAL";
10935 case STV_HIDDEN: return "HIDDEN";
10936 case STV_PROTECTED: return "PROTECTED";
10938 error (_("Unrecognized visibility value: %u"), visibility);
10939 return _("<unknown>");
10943 static const char *
10944 get_solaris_symbol_visibility (unsigned int visibility)
10946 switch (visibility)
10948 case 4: return "EXPORTED";
10949 case 5: return "SINGLETON";
10950 case 6: return "ELIMINATE";
10951 default: return get_symbol_visibility (visibility);
10955 static const char *
10956 get_mips_symbol_other (unsigned int other)
10960 case STO_OPTIONAL: return "OPTIONAL";
10961 case STO_MIPS_PLT: return "MIPS PLT";
10962 case STO_MIPS_PIC: return "MIPS PIC";
10963 case STO_MICROMIPS: return "MICROMIPS";
10964 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10965 case STO_MIPS16: return "MIPS16";
10966 default: return NULL;
10970 static const char *
10971 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10973 if (is_ia64_vms (filedata))
10975 static char res[32];
10979 /* Function types is for images and .STB files only. */
10980 switch (filedata->file_header.e_type)
10984 switch (VMS_ST_FUNC_TYPE (other))
10986 case VMS_SFT_CODE_ADDR:
10987 strcat (res, " CA");
10989 case VMS_SFT_SYMV_IDX:
10990 strcat (res, " VEC");
10993 strcat (res, " FD");
10995 case VMS_SFT_RESERVE:
10996 strcat (res, " RSV");
10999 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11000 VMS_ST_FUNC_TYPE (other));
11001 strcat (res, " <unknown>");
11008 switch (VMS_ST_LINKAGE (other))
11010 case VMS_STL_IGNORE:
11011 strcat (res, " IGN");
11013 case VMS_STL_RESERVE:
11014 strcat (res, " RSV");
11017 strcat (res, " STD");
11020 strcat (res, " LNK");
11023 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11024 VMS_ST_LINKAGE (other));
11025 strcat (res, " <unknown>");
11037 static const char *
11038 get_ppc64_symbol_other (unsigned int other)
11040 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
11042 static char buf[32];
11043 snprintf (buf, sizeof buf, _("<localentry>: %d"),
11044 PPC64_LOCAL_ENTRY_OFFSET (other));
11050 static const char *
11051 get_symbol_other (Filedata * filedata, unsigned int other)
11053 const char * result = NULL;
11054 static char buff [32];
11059 switch (filedata->file_header.e_machine)
11062 result = get_mips_symbol_other (other);
11065 result = get_ia64_symbol_other (filedata, other);
11068 result = get_ppc64_symbol_other (other);
11078 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11082 static const char *
11083 get_symbol_index_type (Filedata * filedata, unsigned int type)
11085 static char buff[32];
11089 case SHN_UNDEF: return "UND";
11090 case SHN_ABS: return "ABS";
11091 case SHN_COMMON: return "COM";
11093 if (type == SHN_IA_64_ANSI_COMMON
11094 && filedata->file_header.e_machine == EM_IA_64
11095 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11097 else if ((filedata->file_header.e_machine == EM_X86_64
11098 || filedata->file_header.e_machine == EM_L1OM
11099 || filedata->file_header.e_machine == EM_K1OM)
11100 && type == SHN_X86_64_LCOMMON)
11101 return "LARGE_COM";
11102 else if ((type == SHN_MIPS_SCOMMON
11103 && filedata->file_header.e_machine == EM_MIPS)
11104 || (type == SHN_TIC6X_SCOMMON
11105 && filedata->file_header.e_machine == EM_TI_C6000))
11107 else if (type == SHN_MIPS_SUNDEFINED
11108 && filedata->file_header.e_machine == EM_MIPS)
11110 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11111 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11112 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11113 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11114 else if (type >= SHN_LORESERVE)
11115 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11116 else if (type >= filedata->file_header.e_shnum)
11117 sprintf (buff, _("bad section index[%3d]"), type);
11119 sprintf (buff, "%3d", type);
11127 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11129 unsigned char * e_data;
11132 /* If the size_t type is smaller than the bfd_size_type, eg because
11133 you are building a 32-bit tool on a 64-bit host, then make sure
11134 that when (number) is cast to (size_t) no information is lost. */
11135 if (sizeof (size_t) < sizeof (bfd_size_type)
11136 && (bfd_size_type) ((size_t) number) != number)
11138 error (_("Size truncation prevents reading %s elements of size %u\n"),
11139 bfd_vmatoa ("u", number), ent_size);
11143 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11144 attempting to allocate memory when the read is bound to fail. */
11145 if (ent_size * number > filedata->file_size)
11147 error (_("Invalid number of dynamic entries: %s\n"),
11148 bfd_vmatoa ("u", number));
11152 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11153 if (e_data == NULL)
11155 error (_("Out of memory reading %s dynamic entries\n"),
11156 bfd_vmatoa ("u", number));
11160 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11162 error (_("Unable to read in %s bytes of dynamic data\n"),
11163 bfd_vmatoa ("u", number * ent_size));
11168 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11169 if (i_data == NULL)
11171 error (_("Out of memory allocating space for %s dynamic entries\n"),
11172 bfd_vmatoa ("u", number));
11178 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11186 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11188 Elf_Internal_Sym * psym;
11191 n = print_vma (si, DEC_5);
11193 fputs (&" "[n], stdout);
11194 printf (" %3lu: ", hn);
11196 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11198 printf (_("<No info available for dynamic symbol number %lu>\n"),
11199 (unsigned long) si);
11203 psym = dynamic_symbols + si;
11204 print_vma (psym->st_value, LONG_HEX);
11206 print_vma (psym->st_size, DEC_5);
11208 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11209 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11211 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11212 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11215 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11217 printf (" %-7s", get_symbol_visibility (vis));
11218 /* Check to see if any other bits in the st_other field are set.
11219 Note - displaying this information disrupts the layout of the
11220 table being generated, but for the moment this case is very
11222 if (psym->st_other ^ vis)
11223 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11226 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11227 if (VALID_DYNAMIC_NAME (psym->st_name))
11228 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11230 printf (_(" <corrupt: %14ld>"), psym->st_name);
11234 static const char *
11235 get_symbol_version_string (Filedata * filedata,
11236 bfd_boolean is_dynsym,
11237 const char * strtab,
11238 unsigned long int strtab_size,
11240 Elf_Internal_Sym * psym,
11241 enum versioned_symbol_info * sym_info,
11242 unsigned short * vna_other)
11244 unsigned char data[2];
11245 unsigned short vers_data;
11246 unsigned long offset;
11249 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11252 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11253 sizeof data + si * sizeof (vers_data));
11255 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11256 sizeof (data), 1, _("version data")) == NULL)
11259 vers_data = byte_get (data, 2);
11261 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11264 /* Usually we'd only see verdef for defined symbols, and verneed for
11265 undefined symbols. However, symbols defined by the linker in
11266 .dynbss for variables copied from a shared library in order to
11267 avoid text relocations are defined yet have verneed. We could
11268 use a heuristic to detect the special case, for example, check
11269 for verneed first on symbols defined in SHT_NOBITS sections, but
11270 it is simpler and more reliable to just look for both verdef and
11271 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11273 if (psym->st_shndx != SHN_UNDEF
11274 && vers_data != 0x8001
11275 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11277 Elf_Internal_Verdef ivd;
11278 Elf_Internal_Verdaux ivda;
11279 Elf_External_Verdaux evda;
11282 off = offset_from_vma (filedata,
11283 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11284 sizeof (Elf_External_Verdef));
11288 Elf_External_Verdef evd;
11290 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11291 _("version def")) == NULL)
11299 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11300 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11301 ivd.vd_next = BYTE_GET (evd.vd_next);
11304 off += ivd.vd_next;
11306 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11308 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11310 off -= ivd.vd_next;
11313 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11314 _("version def aux")) != NULL)
11316 ivda.vda_name = BYTE_GET (evda.vda_name);
11318 if (psym->st_name != ivda.vda_name)
11320 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11321 ? symbol_hidden : symbol_public);
11322 return (ivda.vda_name < strtab_size
11323 ? strtab + ivda.vda_name : _("<corrupt>"));
11329 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11331 Elf_External_Verneed evn;
11332 Elf_Internal_Verneed ivn;
11333 Elf_Internal_Vernaux ivna;
11335 offset = offset_from_vma (filedata,
11336 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11340 unsigned long vna_off;
11342 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11343 _("version need")) == NULL)
11346 ivna.vna_other = 0;
11351 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11352 ivn.vn_next = BYTE_GET (evn.vn_next);
11354 vna_off = offset + ivn.vn_aux;
11358 Elf_External_Vernaux evna;
11360 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11361 _("version need aux (3)")) == NULL)
11364 ivna.vna_other = 0;
11369 ivna.vna_other = BYTE_GET (evna.vna_other);
11370 ivna.vna_next = BYTE_GET (evna.vna_next);
11371 ivna.vna_name = BYTE_GET (evna.vna_name);
11374 vna_off += ivna.vna_next;
11376 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11378 if (ivna.vna_other == vers_data)
11381 offset += ivn.vn_next;
11383 while (ivn.vn_next != 0);
11385 if (ivna.vna_other == vers_data)
11387 *sym_info = symbol_undefined;
11388 *vna_other = ivna.vna_other;
11389 return (ivna.vna_name < strtab_size
11390 ? strtab + ivna.vna_name : _("<corrupt>"));
11396 /* Dump the symbol table. */
11398 process_symbol_table (Filedata * filedata)
11400 Elf_Internal_Shdr * section;
11401 bfd_size_type nbuckets = 0;
11402 bfd_size_type nchains = 0;
11403 bfd_vma * buckets = NULL;
11404 bfd_vma * chains = NULL;
11405 bfd_vma ngnubuckets = 0;
11406 bfd_vma * gnubuckets = NULL;
11407 bfd_vma * gnuchains = NULL;
11408 bfd_vma gnusymidx = 0;
11409 bfd_size_type ngnuchains = 0;
11411 if (!do_syms && !do_dyn_syms && !do_histogram)
11414 if (dynamic_info[DT_HASH]
11416 || (do_using_dynamic
11418 && dynamic_strings != NULL)))
11420 unsigned char nb[8];
11421 unsigned char nc[8];
11422 unsigned int hash_ent_size = 4;
11424 if ((filedata->file_header.e_machine == EM_ALPHA
11425 || filedata->file_header.e_machine == EM_S390
11426 || filedata->file_header.e_machine == EM_S390_OLD)
11427 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11430 if (fseek (filedata->handle,
11431 (archive_file_offset
11432 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11433 sizeof nb + sizeof nc)),
11436 error (_("Unable to seek to start of dynamic information\n"));
11440 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11442 error (_("Failed to read in number of buckets\n"));
11446 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11448 error (_("Failed to read in number of chains\n"));
11452 nbuckets = byte_get (nb, hash_ent_size);
11453 nchains = byte_get (nc, hash_ent_size);
11455 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11456 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11459 if (buckets == NULL || chains == NULL)
11461 if (do_using_dynamic)
11472 if (dynamic_info_DT_GNU_HASH
11474 || (do_using_dynamic
11476 && dynamic_strings != NULL)))
11478 unsigned char nb[16];
11479 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11480 bfd_vma buckets_vma;
11482 if (fseek (filedata->handle,
11483 (archive_file_offset
11484 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11488 error (_("Unable to seek to start of dynamic information\n"));
11492 if (fread (nb, 16, 1, filedata->handle) != 1)
11494 error (_("Failed to read in number of buckets\n"));
11498 ngnubuckets = byte_get (nb, 4);
11499 gnusymidx = byte_get (nb + 4, 4);
11500 bitmaskwords = byte_get (nb + 8, 4);
11501 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11503 buckets_vma += bitmaskwords * 4;
11505 buckets_vma += bitmaskwords * 8;
11507 if (fseek (filedata->handle,
11508 (archive_file_offset
11509 + offset_from_vma (filedata, buckets_vma, 4)),
11512 error (_("Unable to seek to start of dynamic information\n"));
11516 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11518 if (gnubuckets == NULL)
11521 for (i = 0; i < ngnubuckets; i++)
11522 if (gnubuckets[i] != 0)
11524 if (gnubuckets[i] < gnusymidx)
11527 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11528 maxchain = gnubuckets[i];
11531 if (maxchain == 0xffffffff)
11534 maxchain -= gnusymidx;
11536 if (fseek (filedata->handle,
11537 (archive_file_offset
11538 + offset_from_vma (filedata, buckets_vma
11539 + 4 * (ngnubuckets + maxchain), 4)),
11542 error (_("Unable to seek to start of dynamic information\n"));
11548 if (fread (nb, 4, 1, filedata->handle) != 1)
11550 error (_("Failed to determine last chain length\n"));
11554 if (maxchain + 1 == 0)
11559 while ((byte_get (nb, 4) & 1) == 0);
11561 if (fseek (filedata->handle,
11562 (archive_file_offset
11563 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11566 error (_("Unable to seek to start of dynamic information\n"));
11570 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11571 ngnuchains = maxchain;
11574 if (gnuchains == NULL)
11579 if (do_using_dynamic)
11584 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11586 && do_using_dynamic
11587 && dynamic_strings != NULL
11588 && dynamic_symbols != NULL)
11592 if (dynamic_info[DT_HASH])
11597 printf (_("\nSymbol table for image:\n"));
11599 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11601 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11603 visited = xcmalloc (nchains, 1);
11604 memset (visited, 0, nchains);
11605 for (hn = 0; hn < nbuckets; hn++)
11607 for (si = buckets[hn]; si > 0; si = chains[si])
11609 print_dynamic_symbol (filedata, si, hn);
11610 if (si >= nchains || visited[si])
11612 error (_("histogram chain is corrupt\n"));
11621 if (dynamic_info_DT_GNU_HASH)
11623 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11625 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11627 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11629 for (hn = 0; hn < ngnubuckets; ++hn)
11630 if (gnubuckets[hn] != 0)
11632 bfd_vma si = gnubuckets[hn];
11633 bfd_vma off = si - gnusymidx;
11637 print_dynamic_symbol (filedata, si, hn);
11640 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11644 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11645 && filedata->section_headers != NULL)
11649 for (i = 0, section = filedata->section_headers;
11650 i < filedata->file_header.e_shnum;
11654 char * strtab = NULL;
11655 unsigned long int strtab_size = 0;
11656 Elf_Internal_Sym * symtab;
11657 Elf_Internal_Sym * psym;
11658 unsigned long num_syms;
11660 if ((section->sh_type != SHT_SYMTAB
11661 && section->sh_type != SHT_DYNSYM)
11663 && section->sh_type == SHT_SYMTAB))
11666 if (section->sh_entsize == 0)
11668 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11669 printable_section_name (filedata, section));
11673 num_syms = section->sh_size / section->sh_entsize;
11674 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11675 "\nSymbol table '%s' contains %lu entries:\n",
11677 printable_section_name (filedata, section),
11681 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11683 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11685 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11686 if (symtab == NULL)
11689 if (section->sh_link == filedata->file_header.e_shstrndx)
11691 strtab = filedata->string_table;
11692 strtab_size = filedata->string_table_length;
11694 else if (section->sh_link < filedata->file_header.e_shnum)
11696 Elf_Internal_Shdr * string_sec;
11698 string_sec = filedata->section_headers + section->sh_link;
11700 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11701 1, string_sec->sh_size,
11702 _("string table"));
11703 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11706 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11708 const char *version_string;
11709 enum versioned_symbol_info sym_info;
11710 unsigned short vna_other;
11712 printf ("%6d: ", si);
11713 print_vma (psym->st_value, LONG_HEX);
11715 print_vma (psym->st_size, DEC_5);
11716 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11717 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11718 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11719 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11722 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11724 printf (" %-7s", get_symbol_visibility (vis));
11725 /* Check to see if any other bits in the st_other field are set.
11726 Note - displaying this information disrupts the layout of the
11727 table being generated, but for the moment this case is very rare. */
11728 if (psym->st_other ^ vis)
11729 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11731 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11732 print_symbol (25, psym->st_name < strtab_size
11733 ? strtab + psym->st_name : _("<corrupt>"));
11736 = get_symbol_version_string (filedata,
11737 section->sh_type == SHT_DYNSYM,
11738 strtab, strtab_size, si,
11739 psym, &sym_info, &vna_other);
11740 if (version_string)
11742 if (sym_info == symbol_undefined)
11743 printf ("@%s (%d)", version_string, vna_other);
11745 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11751 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11752 && si >= section->sh_info
11753 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11754 && filedata->file_header.e_machine != EM_MIPS
11755 /* Solaris binaries have been found to violate this requirement as
11756 well. Not sure if this is a bug or an ABI requirement. */
11757 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11758 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11759 si, printable_section_name (filedata, section), section->sh_info);
11763 if (strtab != filedata->string_table)
11769 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11771 if (do_histogram && buckets != NULL)
11773 unsigned long * lengths;
11774 unsigned long * counts;
11777 unsigned long maxlength = 0;
11778 unsigned long nzero_counts = 0;
11779 unsigned long nsyms = 0;
11782 printf (ngettext ("\nHistogram for bucket list length "
11783 "(total of %lu bucket):\n",
11784 "\nHistogram for bucket list length "
11785 "(total of %lu buckets):\n",
11786 (unsigned long) nbuckets),
11787 (unsigned long) nbuckets);
11789 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11790 if (lengths == NULL)
11792 error (_("Out of memory allocating space for histogram buckets\n"));
11795 visited = xcmalloc (nchains, 1);
11796 memset (visited, 0, nchains);
11798 printf (_(" Length Number %% of total Coverage\n"));
11799 for (hn = 0; hn < nbuckets; ++hn)
11801 for (si = buckets[hn]; si > 0; si = chains[si])
11804 if (maxlength < ++lengths[hn])
11806 if (si >= nchains || visited[si])
11808 error (_("histogram chain is corrupt\n"));
11816 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11817 if (counts == NULL)
11820 error (_("Out of memory allocating space for histogram counts\n"));
11824 for (hn = 0; hn < nbuckets; ++hn)
11825 ++counts[lengths[hn]];
11830 printf (" 0 %-10lu (%5.1f%%)\n",
11831 counts[0], (counts[0] * 100.0) / nbuckets);
11832 for (i = 1; i <= maxlength; ++i)
11834 nzero_counts += counts[i] * i;
11835 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11836 i, counts[i], (counts[i] * 100.0) / nbuckets,
11837 (nzero_counts * 100.0) / nsyms);
11845 if (buckets != NULL)
11851 if (do_histogram && gnubuckets != NULL)
11853 unsigned long * lengths;
11854 unsigned long * counts;
11856 unsigned long maxlength = 0;
11857 unsigned long nzero_counts = 0;
11858 unsigned long nsyms = 0;
11860 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11861 "(total of %lu bucket):\n",
11862 "\nHistogram for `.gnu.hash' bucket list length "
11863 "(total of %lu buckets):\n",
11864 (unsigned long) ngnubuckets),
11865 (unsigned long) ngnubuckets);
11867 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11868 if (lengths == NULL)
11870 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11874 printf (_(" Length Number %% of total Coverage\n"));
11876 for (hn = 0; hn < ngnubuckets; ++hn)
11877 if (gnubuckets[hn] != 0)
11879 bfd_vma off, length = 1;
11881 for (off = gnubuckets[hn] - gnusymidx;
11882 /* PR 17531 file: 010-77222-0.004. */
11883 off < ngnuchains && (gnuchains[off] & 1) == 0;
11886 lengths[hn] = length;
11887 if (length > maxlength)
11888 maxlength = length;
11892 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11893 if (counts == NULL)
11896 error (_("Out of memory allocating space for gnu histogram counts\n"));
11900 for (hn = 0; hn < ngnubuckets; ++hn)
11901 ++counts[lengths[hn]];
11903 if (ngnubuckets > 0)
11906 printf (" 0 %-10lu (%5.1f%%)\n",
11907 counts[0], (counts[0] * 100.0) / ngnubuckets);
11908 for (j = 1; j <= maxlength; ++j)
11910 nzero_counts += counts[j] * j;
11911 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11912 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11913 (nzero_counts * 100.0) / nsyms);
11927 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11931 if (dynamic_syminfo == NULL
11933 /* No syminfo, this is ok. */
11936 /* There better should be a dynamic symbol section. */
11937 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11941 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11942 "contains %d entry:\n",
11943 "\nDynamic info segment at offset 0x%lx "
11944 "contains %d entries:\n",
11945 dynamic_syminfo_nent),
11946 dynamic_syminfo_offset, dynamic_syminfo_nent);
11948 printf (_(" Num: Name BoundTo Flags\n"));
11949 for (i = 0; i < dynamic_syminfo_nent; ++i)
11951 unsigned short int flags = dynamic_syminfo[i].si_flags;
11953 printf ("%4d: ", i);
11954 if (i >= num_dynamic_syms)
11955 printf (_("<corrupt index>"));
11956 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11957 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11959 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11962 switch (dynamic_syminfo[i].si_boundto)
11964 case SYMINFO_BT_SELF:
11965 fputs ("SELF ", stdout);
11967 case SYMINFO_BT_PARENT:
11968 fputs ("PARENT ", stdout);
11971 if (dynamic_syminfo[i].si_boundto > 0
11972 && dynamic_syminfo[i].si_boundto < dynamic_nent
11973 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11975 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11979 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11983 if (flags & SYMINFO_FLG_DIRECT)
11984 printf (" DIRECT");
11985 if (flags & SYMINFO_FLG_PASSTHRU)
11986 printf (" PASSTHRU");
11987 if (flags & SYMINFO_FLG_COPY)
11989 if (flags & SYMINFO_FLG_LAZYLOAD)
11990 printf (" LAZYLOAD");
11998 #define IN_RANGE(START,END,ADDR,OFF) \
11999 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12001 /* Check to see if the given reloc needs to be handled in a target specific
12002 manner. If so then process the reloc and return TRUE otherwise return
12005 If called with reloc == NULL, then this is a signal that reloc processing
12006 for the current section has finished, and any saved state should be
12010 target_specific_reloc_handling (Filedata * filedata,
12011 Elf_Internal_Rela * reloc,
12012 unsigned char * start,
12013 unsigned char * end,
12014 Elf_Internal_Sym * symtab,
12015 unsigned long num_syms)
12017 unsigned int reloc_type = 0;
12018 unsigned long sym_index = 0;
12022 reloc_type = get_reloc_type (filedata, reloc->r_info);
12023 sym_index = get_reloc_symindex (reloc->r_info);
12026 switch (filedata->file_header.e_machine)
12029 case EM_MSP430_OLD:
12031 static Elf_Internal_Sym * saved_sym = NULL;
12039 switch (reloc_type)
12041 case 10: /* R_MSP430_SYM_DIFF */
12042 if (uses_msp430x_relocs (filedata))
12044 /* Fall through. */
12045 case 21: /* R_MSP430X_SYM_DIFF */
12047 if (sym_index >= num_syms)
12048 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12051 saved_sym = symtab + sym_index;
12054 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12055 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12056 goto handle_sym_diff;
12058 case 5: /* R_MSP430_16_BYTE */
12059 case 9: /* R_MSP430_8 */
12060 if (uses_msp430x_relocs (filedata))
12062 goto handle_sym_diff;
12064 case 2: /* R_MSP430_ABS16 */
12065 case 15: /* R_MSP430X_ABS16 */
12066 if (! uses_msp430x_relocs (filedata))
12068 goto handle_sym_diff;
12071 if (saved_sym != NULL)
12073 int reloc_size = reloc_type == 1 ? 4 : 2;
12076 if (sym_index >= num_syms)
12077 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12081 value = reloc->r_addend + (symtab[sym_index].st_value
12082 - saved_sym->st_value);
12084 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12085 byte_put (start + reloc->r_offset, value, reloc_size);
12088 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12089 (long) reloc->r_offset);
12098 if (saved_sym != NULL)
12099 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12106 case EM_CYGNUS_MN10300:
12108 static Elf_Internal_Sym * saved_sym = NULL;
12116 switch (reloc_type)
12118 case 34: /* R_MN10300_ALIGN */
12120 case 33: /* R_MN10300_SYM_DIFF */
12121 if (sym_index >= num_syms)
12122 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12125 saved_sym = symtab + sym_index;
12128 case 1: /* R_MN10300_32 */
12129 case 2: /* R_MN10300_16 */
12130 if (saved_sym != NULL)
12132 int reloc_size = reloc_type == 1 ? 4 : 2;
12135 if (sym_index >= num_syms)
12136 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12140 value = reloc->r_addend + (symtab[sym_index].st_value
12141 - saved_sym->st_value);
12143 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12144 byte_put (start + reloc->r_offset, value, reloc_size);
12146 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12147 (long) reloc->r_offset);
12155 if (saved_sym != NULL)
12156 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12164 static bfd_vma saved_sym1 = 0;
12165 static bfd_vma saved_sym2 = 0;
12166 static bfd_vma value;
12170 saved_sym1 = saved_sym2 = 0;
12174 switch (reloc_type)
12176 case 0x80: /* R_RL78_SYM. */
12177 saved_sym1 = saved_sym2;
12178 if (sym_index >= num_syms)
12179 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12183 saved_sym2 = symtab[sym_index].st_value;
12184 saved_sym2 += reloc->r_addend;
12188 case 0x83: /* R_RL78_OPsub. */
12189 value = saved_sym1 - saved_sym2;
12190 saved_sym2 = saved_sym1 = 0;
12194 case 0x41: /* R_RL78_ABS32. */
12195 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12196 byte_put (start + reloc->r_offset, value, 4);
12198 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12199 (long) reloc->r_offset);
12203 case 0x43: /* R_RL78_ABS16. */
12204 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12205 byte_put (start + reloc->r_offset, value, 2);
12207 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12208 (long) reloc->r_offset);
12222 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12223 DWARF debug sections. This is a target specific test. Note - we do not
12224 go through the whole including-target-headers-multiple-times route, (as
12225 we have already done with <elf/h8.h>) because this would become very
12226 messy and even then this function would have to contain target specific
12227 information (the names of the relocs instead of their numeric values).
12228 FIXME: This is not the correct way to solve this problem. The proper way
12229 is to have target specific reloc sizing and typing functions created by
12230 the reloc-macros.h header, in the same way that it already creates the
12231 reloc naming functions. */
12234 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12236 /* Please keep this table alpha-sorted for ease of visual lookup. */
12237 switch (filedata->file_header.e_machine)
12241 return reloc_type == 1; /* R_386_32. */
12243 return reloc_type == 1; /* R_68K_32. */
12245 return reloc_type == 1; /* R_860_32. */
12247 return reloc_type == 2; /* R_960_32. */
12249 return (reloc_type == 258
12250 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12251 case EM_ADAPTEVA_EPIPHANY:
12252 return reloc_type == 3;
12254 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12256 return reloc_type == 1; /* R_ARC_32. */
12257 case EM_ARC_COMPACT:
12258 case EM_ARC_COMPACT2:
12259 return reloc_type == 4; /* R_ARC_32. */
12261 return reloc_type == 2; /* R_ARM_ABS32 */
12264 return reloc_type == 1;
12266 return reloc_type == 0x12; /* R_byte4_data. */
12268 return reloc_type == 3; /* R_CRIS_32. */
12270 return reloc_type == 3; /* R_CR16_NUM32. */
12272 return reloc_type == 15; /* R_CRX_NUM32. */
12273 case EM_CYGNUS_FRV:
12274 return reloc_type == 1;
12275 case EM_CYGNUS_D10V:
12277 return reloc_type == 6; /* R_D10V_32. */
12278 case EM_CYGNUS_D30V:
12280 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12282 return reloc_type == 3; /* R_DLX_RELOC_32. */
12283 case EM_CYGNUS_FR30:
12285 return reloc_type == 3; /* R_FR30_32. */
12287 return reloc_type == 1; /* R_FT32_32. */
12291 return reloc_type == 1; /* R_H8_DIR32. */
12293 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12294 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12295 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12296 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12299 return reloc_type == 2; /* R_IP2K_32. */
12301 return reloc_type == 2; /* R_IQ2000_32. */
12302 case EM_LATTICEMICO32:
12303 return reloc_type == 3; /* R_LM32_32. */
12306 return reloc_type == 3; /* R_M32C_32. */
12308 return reloc_type == 34; /* R_M32R_32_RELA. */
12311 return reloc_type == 6; /* R_M68HC11_32. */
12313 return reloc_type == 1; /* R_MCORE_ADDR32. */
12314 case EM_CYGNUS_MEP:
12315 return reloc_type == 4; /* R_MEP_32. */
12317 return reloc_type == 2; /* R_METAG_ADDR32. */
12318 case EM_MICROBLAZE:
12319 return reloc_type == 1; /* R_MICROBLAZE_32. */
12321 return reloc_type == 2; /* R_MIPS_32. */
12323 return reloc_type == 4; /* R_MMIX_32. */
12324 case EM_CYGNUS_MN10200:
12326 return reloc_type == 1; /* R_MN10200_32. */
12327 case EM_CYGNUS_MN10300:
12329 return reloc_type == 1; /* R_MN10300_32. */
12331 return reloc_type == 1; /* R_MOXIE_32. */
12332 case EM_MSP430_OLD:
12334 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12336 return reloc_type == 2; /* R_MT_32. */
12338 return reloc_type == 20; /* R_NDS32_RELA. */
12339 case EM_ALTERA_NIOS2:
12340 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12342 return reloc_type == 1; /* R_NIOS_32. */
12344 return reloc_type == 1; /* R_OR1K_32. */
12346 return (reloc_type == 1 /* R_PARISC_DIR32. */
12347 || reloc_type == 2 /* R_PARISC_DIR21L. */
12348 || reloc_type == 41); /* R_PARISC_SECREL32. */
12351 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12353 return reloc_type == 1; /* R_PPC64_ADDR32. */
12355 return reloc_type == 1; /* R_PPC_ADDR32. */
12357 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12359 return reloc_type == 1; /* R_RISCV_32. */
12361 return reloc_type == 1; /* R_RL78_DIR32. */
12363 return reloc_type == 1; /* R_RX_DIR32. */
12365 return reloc_type == 1; /* R_I370_ADDR31. */
12368 return reloc_type == 4; /* R_S390_32. */
12370 return reloc_type == 8; /* R_SCORE_ABS32. */
12372 return reloc_type == 1; /* R_SH_DIR32. */
12373 case EM_SPARC32PLUS:
12376 return reloc_type == 3 /* R_SPARC_32. */
12377 || reloc_type == 23; /* R_SPARC_UA32. */
12379 return reloc_type == 6; /* R_SPU_ADDR32 */
12381 return reloc_type == 1; /* R_C6000_ABS32. */
12383 return reloc_type == 2; /* R_TILEGX_32. */
12385 return reloc_type == 1; /* R_TILEPRO_32. */
12386 case EM_CYGNUS_V850:
12388 return reloc_type == 6; /* R_V850_ABS32. */
12390 return reloc_type == 0x33; /* R_V810_WORD. */
12392 return reloc_type == 1; /* R_VAX_32. */
12394 return reloc_type == 3; /* R_VISIUM_32. */
12395 case EM_WEBASSEMBLY:
12396 return reloc_type == 1; /* R_WASM32_32. */
12400 return reloc_type == 10; /* R_X86_64_32. */
12403 return reloc_type == 3; /* R_XC16C_ABS_32. */
12405 return reloc_type == 4; /* R_XGATE_32. */
12407 return reloc_type == 1; /* R_XSTROMY16_32. */
12408 case EM_XTENSA_OLD:
12410 return reloc_type == 1; /* R_XTENSA_32. */
12413 static unsigned int prev_warn = 0;
12415 /* Avoid repeating the same warning multiple times. */
12416 if (prev_warn != filedata->file_header.e_machine)
12417 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12418 filedata->file_header.e_machine);
12419 prev_warn = filedata->file_header.e_machine;
12425 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12426 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12429 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12431 switch (filedata->file_header.e_machine)
12432 /* Please keep this table alpha-sorted for ease of visual lookup. */
12436 return reloc_type == 2; /* R_386_PC32. */
12438 return reloc_type == 4; /* R_68K_PC32. */
12440 return reloc_type == 261; /* R_AARCH64_PREL32 */
12441 case EM_ADAPTEVA_EPIPHANY:
12442 return reloc_type == 6;
12444 return reloc_type == 10; /* R_ALPHA_SREL32. */
12445 case EM_ARC_COMPACT:
12446 case EM_ARC_COMPACT2:
12447 return reloc_type == 49; /* R_ARC_32_PCREL. */
12449 return reloc_type == 3; /* R_ARM_REL32 */
12452 return reloc_type == 36; /* R_AVR_32_PCREL. */
12453 case EM_MICROBLAZE:
12454 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12456 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12458 return reloc_type == 9; /* R_PARISC_PCREL32. */
12460 return reloc_type == 26; /* R_PPC_REL32. */
12462 return reloc_type == 26; /* R_PPC64_REL32. */
12465 return reloc_type == 5; /* R_390_PC32. */
12467 return reloc_type == 2; /* R_SH_REL32. */
12468 case EM_SPARC32PLUS:
12471 return reloc_type == 6; /* R_SPARC_DISP32. */
12473 return reloc_type == 13; /* R_SPU_REL32. */
12475 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12477 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12479 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12483 return reloc_type == 2; /* R_X86_64_PC32. */
12484 case EM_XTENSA_OLD:
12486 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12488 /* Do not abort or issue an error message here. Not all targets use
12489 pc-relative 32-bit relocs in their DWARF debug information and we
12490 have already tested for target coverage in is_32bit_abs_reloc. A
12491 more helpful warning message will be generated by apply_relocations
12492 anyway, so just return. */
12497 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12498 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12501 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12503 switch (filedata->file_header.e_machine)
12506 return reloc_type == 257; /* R_AARCH64_ABS64. */
12508 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12510 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12511 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12513 return reloc_type == 80; /* R_PARISC_DIR64. */
12515 return reloc_type == 38; /* R_PPC64_ADDR64. */
12517 return reloc_type == 2; /* R_RISCV_64. */
12518 case EM_SPARC32PLUS:
12521 return reloc_type == 32 /* R_SPARC_64. */
12522 || reloc_type == 54; /* R_SPARC_UA64. */
12526 return reloc_type == 1; /* R_X86_64_64. */
12529 return reloc_type == 22; /* R_S390_64. */
12531 return reloc_type == 1; /* R_TILEGX_64. */
12533 return reloc_type == 18; /* R_MIPS_64. */
12539 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12540 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12543 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12545 switch (filedata->file_header.e_machine)
12548 return reloc_type == 260; /* R_AARCH64_PREL64. */
12550 return reloc_type == 11; /* R_ALPHA_SREL64. */
12552 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12553 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12555 return reloc_type == 72; /* R_PARISC_PCREL64. */
12557 return reloc_type == 44; /* R_PPC64_REL64. */
12558 case EM_SPARC32PLUS:
12561 return reloc_type == 46; /* R_SPARC_DISP64. */
12565 return reloc_type == 24; /* R_X86_64_PC64. */
12568 return reloc_type == 23; /* R_S390_PC64. */
12570 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12576 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12577 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12580 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12582 switch (filedata->file_header.e_machine)
12584 case EM_CYGNUS_MN10200:
12586 return reloc_type == 4; /* R_MN10200_24. */
12588 return reloc_type == 5; /* R_FT32_20. */
12594 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12595 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12598 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12600 /* Please keep this table alpha-sorted for ease of visual lookup. */
12601 switch (filedata->file_header.e_machine)
12604 case EM_ARC_COMPACT:
12605 case EM_ARC_COMPACT2:
12606 return reloc_type == 2; /* R_ARC_16. */
12607 case EM_ADAPTEVA_EPIPHANY:
12608 return reloc_type == 5;
12611 return reloc_type == 4; /* R_AVR_16. */
12612 case EM_CYGNUS_D10V:
12614 return reloc_type == 3; /* R_D10V_16. */
12616 return reloc_type == 2; /* R_FT32_16. */
12620 return reloc_type == R_H8_DIR16;
12623 return reloc_type == 1; /* R_IP2K_16. */
12626 return reloc_type == 1; /* R_M32C_16 */
12627 case EM_CYGNUS_MN10200:
12629 return reloc_type == 2; /* R_MN10200_16. */
12630 case EM_CYGNUS_MN10300:
12632 return reloc_type == 2; /* R_MN10300_16. */
12634 if (uses_msp430x_relocs (filedata))
12635 return reloc_type == 2; /* R_MSP430_ABS16. */
12636 /* Fall through. */
12637 case EM_MSP430_OLD:
12638 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12640 return reloc_type == 19; /* R_NDS32_RELA. */
12641 case EM_ALTERA_NIOS2:
12642 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12644 return reloc_type == 9; /* R_NIOS_16. */
12646 return reloc_type == 2; /* R_OR1K_16. */
12648 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12650 return reloc_type == 2; /* R_C6000_ABS16. */
12652 return reloc_type == 2; /* R_VISIUM_16. */
12655 return reloc_type == 2; /* R_XC16C_ABS_16. */
12657 return reloc_type == 3; /* R_XGATE_16. */
12663 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12664 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12667 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12669 /* Please keep this table alpha-sorted for ease of visual lookup. */
12670 switch (filedata->file_header.e_machine)
12673 return reloc_type == 35; /* R_RISCV_ADD32. */
12679 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12680 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12683 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12685 /* Please keep this table alpha-sorted for ease of visual lookup. */
12686 switch (filedata->file_header.e_machine)
12689 return reloc_type == 39; /* R_RISCV_SUB32. */
12695 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12696 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12699 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12701 /* Please keep this table alpha-sorted for ease of visual lookup. */
12702 switch (filedata->file_header.e_machine)
12705 return reloc_type == 36; /* R_RISCV_ADD64. */
12711 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12712 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12715 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12717 /* Please keep this table alpha-sorted for ease of visual lookup. */
12718 switch (filedata->file_header.e_machine)
12721 return reloc_type == 40; /* R_RISCV_SUB64. */
12727 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12728 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12731 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12733 /* Please keep this table alpha-sorted for ease of visual lookup. */
12734 switch (filedata->file_header.e_machine)
12737 return reloc_type == 34; /* R_RISCV_ADD16. */
12743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12747 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12749 /* Please keep this table alpha-sorted for ease of visual lookup. */
12750 switch (filedata->file_header.e_machine)
12753 return reloc_type == 38; /* R_RISCV_SUB16. */
12759 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12760 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12763 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12765 /* Please keep this table alpha-sorted for ease of visual lookup. */
12766 switch (filedata->file_header.e_machine)
12769 return reloc_type == 33; /* R_RISCV_ADD8. */
12775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12776 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12779 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12781 /* Please keep this table alpha-sorted for ease of visual lookup. */
12782 switch (filedata->file_header.e_machine)
12785 return reloc_type == 37; /* R_RISCV_SUB8. */
12791 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12792 relocation entries (possibly formerly used for SHT_GROUP sections). */
12795 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12797 switch (filedata->file_header.e_machine)
12799 case EM_386: /* R_386_NONE. */
12800 case EM_68K: /* R_68K_NONE. */
12801 case EM_ADAPTEVA_EPIPHANY:
12802 case EM_ALPHA: /* R_ALPHA_NONE. */
12803 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12804 case EM_ARC: /* R_ARC_NONE. */
12805 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12806 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12807 case EM_ARM: /* R_ARM_NONE. */
12808 case EM_C166: /* R_XC16X_NONE. */
12809 case EM_CRIS: /* R_CRIS_NONE. */
12810 case EM_FT32: /* R_FT32_NONE. */
12811 case EM_IA_64: /* R_IA64_NONE. */
12812 case EM_K1OM: /* R_X86_64_NONE. */
12813 case EM_L1OM: /* R_X86_64_NONE. */
12814 case EM_M32R: /* R_M32R_NONE. */
12815 case EM_MIPS: /* R_MIPS_NONE. */
12816 case EM_MN10300: /* R_MN10300_NONE. */
12817 case EM_MOXIE: /* R_MOXIE_NONE. */
12818 case EM_NIOS32: /* R_NIOS_NONE. */
12819 case EM_OR1K: /* R_OR1K_NONE. */
12820 case EM_PARISC: /* R_PARISC_NONE. */
12821 case EM_PPC64: /* R_PPC64_NONE. */
12822 case EM_PPC: /* R_PPC_NONE. */
12823 case EM_RISCV: /* R_RISCV_NONE. */
12824 case EM_S390: /* R_390_NONE. */
12826 case EM_SH: /* R_SH_NONE. */
12827 case EM_SPARC32PLUS:
12828 case EM_SPARC: /* R_SPARC_NONE. */
12830 case EM_TILEGX: /* R_TILEGX_NONE. */
12831 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12832 case EM_TI_C6000:/* R_C6000_NONE. */
12833 case EM_X86_64: /* R_X86_64_NONE. */
12835 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12836 return reloc_type == 0;
12839 return reloc_type == 0 || reloc_type == 256;
12842 return (reloc_type == 0 /* R_AVR_NONE. */
12843 || reloc_type == 30 /* R_AVR_DIFF8. */
12844 || reloc_type == 31 /* R_AVR_DIFF16. */
12845 || reloc_type == 32 /* R_AVR_DIFF32. */);
12847 return reloc_type == 3; /* R_METAG_NONE. */
12849 return (reloc_type == 0 /* R_XTENSA_NONE. */
12850 || reloc_type == 204 /* R_NDS32_DIFF8. */
12851 || reloc_type == 205 /* R_NDS32_DIFF16. */
12852 || reloc_type == 206 /* R_NDS32_DIFF32. */
12853 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12855 return (reloc_type == 0 /* R_PRU_NONE. */
12856 || reloc_type == 65 /* R_PRU_DIFF8. */
12857 || reloc_type == 66 /* R_PRU_DIFF16. */
12858 || reloc_type == 67 /* R_PRU_DIFF32. */);
12859 case EM_XTENSA_OLD:
12861 return (reloc_type == 0 /* R_XTENSA_NONE. */
12862 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12863 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12864 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12869 /* Returns TRUE if there is a relocation against
12870 section NAME at OFFSET bytes. */
12873 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12875 Elf_Internal_Rela * relocs;
12876 Elf_Internal_Rela * rp;
12878 if (dsec == NULL || dsec->reloc_info == NULL)
12881 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12883 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12884 if (rp->r_offset == offset)
12890 /* Apply relocations to a section.
12891 Returns TRUE upon success, FALSE otherwise.
12892 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12893 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12894 will be set to the number of relocs loaded.
12896 Note: So far support has been added only for those relocations
12897 which can be found in debug sections. FIXME: Add support for
12898 more relocations ? */
12901 apply_relocations (Filedata * filedata,
12902 const Elf_Internal_Shdr * section,
12903 unsigned char * start,
12904 bfd_size_type size,
12905 void ** relocs_return,
12906 unsigned long * num_relocs_return)
12908 Elf_Internal_Shdr * relsec;
12909 unsigned char * end = start + size;
12910 bfd_boolean res = TRUE;
12912 if (relocs_return != NULL)
12914 * (Elf_Internal_Rela **) relocs_return = NULL;
12915 * num_relocs_return = 0;
12918 if (filedata->file_header.e_type != ET_REL)
12919 /* No relocs to apply. */
12922 /* Find the reloc section associated with the section. */
12923 for (relsec = filedata->section_headers;
12924 relsec < filedata->section_headers + filedata->file_header.e_shnum;
12927 bfd_boolean is_rela;
12928 unsigned long num_relocs;
12929 Elf_Internal_Rela * relocs;
12930 Elf_Internal_Rela * rp;
12931 Elf_Internal_Shdr * symsec;
12932 Elf_Internal_Sym * symtab;
12933 unsigned long num_syms;
12934 Elf_Internal_Sym * sym;
12936 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12937 || relsec->sh_info >= filedata->file_header.e_shnum
12938 || filedata->section_headers + relsec->sh_info != section
12939 || relsec->sh_size == 0
12940 || relsec->sh_link >= filedata->file_header.e_shnum)
12943 is_rela = relsec->sh_type == SHT_RELA;
12947 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12948 relsec->sh_size, & relocs, & num_relocs))
12953 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12954 relsec->sh_size, & relocs, & num_relocs))
12958 /* SH uses RELA but uses in place value instead of the addend field. */
12959 if (filedata->file_header.e_machine == EM_SH)
12962 symsec = filedata->section_headers + relsec->sh_link;
12963 if (symsec->sh_type != SHT_SYMTAB
12964 && symsec->sh_type != SHT_DYNSYM)
12966 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12968 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12971 unsigned int reloc_type;
12972 unsigned int reloc_size;
12973 bfd_boolean reloc_inplace = FALSE;
12974 bfd_boolean reloc_subtract = FALSE;
12975 unsigned char * rloc;
12976 unsigned long sym_index;
12978 reloc_type = get_reloc_type (filedata, rp->r_info);
12980 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12982 else if (is_none_reloc (filedata, reloc_type))
12984 else if (is_32bit_abs_reloc (filedata, reloc_type)
12985 || is_32bit_pcrel_reloc (filedata, reloc_type))
12987 else if (is_64bit_abs_reloc (filedata, reloc_type)
12988 || is_64bit_pcrel_reloc (filedata, reloc_type))
12990 else if (is_24bit_abs_reloc (filedata, reloc_type))
12992 else if (is_16bit_abs_reloc (filedata, reloc_type))
12994 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12996 || is_32bit_inplace_add_reloc (filedata, reloc_type))
12999 reloc_inplace = TRUE;
13001 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13003 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13006 reloc_inplace = TRUE;
13008 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13010 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13013 reloc_inplace = TRUE;
13015 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13017 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13020 reloc_inplace = TRUE;
13024 static unsigned int prev_reloc = 0;
13026 if (reloc_type != prev_reloc)
13027 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13028 reloc_type, printable_section_name (filedata, section));
13029 prev_reloc = reloc_type;
13034 rloc = start + rp->r_offset;
13035 if ((rloc + reloc_size) > end || (rloc < start))
13037 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13038 (unsigned long) rp->r_offset,
13039 printable_section_name (filedata, section));
13044 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13045 if (sym_index >= num_syms)
13047 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13048 sym_index, printable_section_name (filedata, section));
13052 sym = symtab + sym_index;
13054 /* If the reloc has a symbol associated with it,
13055 make sure that it is of an appropriate type.
13057 Relocations against symbols without type can happen.
13058 Gcc -feliminate-dwarf2-dups may generate symbols
13059 without type for debug info.
13061 Icc generates relocations against function symbols
13062 instead of local labels.
13064 Relocations against object symbols can happen, eg when
13065 referencing a global array. For an example of this see
13066 the _clz.o binary in libgcc.a. */
13068 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13069 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13071 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13072 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13073 printable_section_name (filedata, relsec),
13074 (long int)(rp - relocs));
13081 addend += rp->r_addend;
13082 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13083 partial_inplace. */
13085 || (filedata->file_header.e_machine == EM_XTENSA
13086 && reloc_type == 1)
13087 || ((filedata->file_header.e_machine == EM_PJ
13088 || filedata->file_header.e_machine == EM_PJ_OLD)
13089 && reloc_type == 1)
13090 || ((filedata->file_header.e_machine == EM_D30V
13091 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13092 && reloc_type == 12)
13094 addend += byte_get (rloc, reloc_size);
13096 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13097 || is_64bit_pcrel_reloc (filedata, reloc_type))
13099 /* On HPPA, all pc-relative relocations are biased by 8. */
13100 if (filedata->file_header.e_machine == EM_PARISC)
13102 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13105 else if (reloc_subtract)
13106 byte_put (rloc, addend - sym->st_value, reloc_size);
13108 byte_put (rloc, addend + sym->st_value, reloc_size);
13112 /* Let the target specific reloc processing code know that
13113 we have finished with these relocs. */
13114 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13118 * (Elf_Internal_Rela **) relocs_return = relocs;
13119 * num_relocs_return = num_relocs;
13130 #ifdef SUPPORT_DISASSEMBLY
13132 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13134 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13136 /* FIXME: XXX -- to be done --- XXX */
13142 /* Reads in the contents of SECTION from FILE, returning a pointer
13143 to a malloc'ed buffer or NULL if something went wrong. */
13146 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13148 bfd_size_type num_bytes = section->sh_size;
13150 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13152 printf (_("Section '%s' has no data to dump.\n"),
13153 printable_section_name (filedata, section));
13157 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13158 _("section contents"));
13161 /* Uncompresses a section that was compressed using zlib, in place. */
13164 uncompress_section_contents (unsigned char ** buffer,
13165 dwarf_size_type uncompressed_size,
13166 dwarf_size_type * size)
13168 dwarf_size_type compressed_size = *size;
13169 unsigned char * compressed_buffer = *buffer;
13170 unsigned char * uncompressed_buffer;
13174 /* It is possible the section consists of several compressed
13175 buffers concatenated together, so we uncompress in a loop. */
13176 /* PR 18313: The state field in the z_stream structure is supposed
13177 to be invisible to the user (ie us), but some compilers will
13178 still complain about it being used without initialisation. So
13179 we first zero the entire z_stream structure and then set the fields
13181 memset (& strm, 0, sizeof strm);
13182 strm.avail_in = compressed_size;
13183 strm.next_in = (Bytef *) compressed_buffer;
13184 strm.avail_out = uncompressed_size;
13185 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13187 rc = inflateInit (& strm);
13188 while (strm.avail_in > 0)
13192 strm.next_out = ((Bytef *) uncompressed_buffer
13193 + (uncompressed_size - strm.avail_out));
13194 rc = inflate (&strm, Z_FINISH);
13195 if (rc != Z_STREAM_END)
13197 rc = inflateReset (& strm);
13199 rc = inflateEnd (& strm);
13201 || strm.avail_out != 0)
13204 *buffer = uncompressed_buffer;
13205 *size = uncompressed_size;
13209 free (uncompressed_buffer);
13210 /* Indicate decompression failure. */
13216 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13218 Elf_Internal_Shdr * relsec;
13219 bfd_size_type num_bytes;
13220 unsigned char * data;
13221 unsigned char * end;
13222 unsigned char * real_start;
13223 unsigned char * start;
13224 bfd_boolean some_strings_shown;
13226 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13228 /* PR 21820: Do not fail if the section was empty. */
13229 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13231 num_bytes = section->sh_size;
13233 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13235 if (decompress_dumps)
13237 dwarf_size_type new_size = num_bytes;
13238 dwarf_size_type uncompressed_size = 0;
13240 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13242 Elf_Internal_Chdr chdr;
13243 unsigned int compression_header_size
13244 = get_compression_header (& chdr, (unsigned char *) start,
13247 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13249 warn (_("section '%s' has unsupported compress type: %d\n"),
13250 printable_section_name (filedata, section), chdr.ch_type);
13253 else if (chdr.ch_addralign != section->sh_addralign)
13255 warn (_("compressed section '%s' is corrupted\n"),
13256 printable_section_name (filedata, section));
13259 uncompressed_size = chdr.ch_size;
13260 start += compression_header_size;
13261 new_size -= compression_header_size;
13263 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13265 /* Read the zlib header. In this case, it should be "ZLIB"
13266 followed by the uncompressed section size, 8 bytes in
13267 big-endian order. */
13268 uncompressed_size = start[4]; uncompressed_size <<= 8;
13269 uncompressed_size += start[5]; uncompressed_size <<= 8;
13270 uncompressed_size += start[6]; uncompressed_size <<= 8;
13271 uncompressed_size += start[7]; uncompressed_size <<= 8;
13272 uncompressed_size += start[8]; uncompressed_size <<= 8;
13273 uncompressed_size += start[9]; uncompressed_size <<= 8;
13274 uncompressed_size += start[10]; uncompressed_size <<= 8;
13275 uncompressed_size += start[11];
13280 if (uncompressed_size)
13282 if (uncompress_section_contents (& start,
13283 uncompressed_size, & new_size))
13284 num_bytes = new_size;
13287 error (_("Unable to decompress section %s\n"),
13288 printable_section_name (filedata, section));
13293 start = real_start;
13296 /* If the section being dumped has relocations against it the user might
13297 be expecting these relocations to have been applied. Check for this
13298 case and issue a warning message in order to avoid confusion.
13299 FIXME: Maybe we ought to have an option that dumps a section with
13300 relocs applied ? */
13301 for (relsec = filedata->section_headers;
13302 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13305 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13306 || relsec->sh_info >= filedata->file_header.e_shnum
13307 || filedata->section_headers + relsec->sh_info != section
13308 || relsec->sh_size == 0
13309 || relsec->sh_link >= filedata->file_header.e_shnum)
13312 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13317 end = start + num_bytes;
13318 some_strings_shown = FALSE;
13322 while (!ISPRINT (* data))
13323 if (++ data >= end)
13328 size_t maxlen = end - data;
13331 /* PR 11128: Use two separate invocations in order to work
13332 around bugs in the Solaris 8 implementation of printf. */
13333 printf (" [%6tx] ", data - start);
13335 printf (" [%6Ix] ", (size_t) (data - start));
13339 print_symbol ((int) maxlen, (const char *) data);
13341 data += strnlen ((const char *) data, maxlen);
13345 printf (_("<corrupt>\n"));
13348 some_strings_shown = TRUE;
13352 if (! some_strings_shown)
13353 printf (_(" No strings found in this section."));
13362 dump_section_as_bytes (Elf_Internal_Shdr * section,
13363 Filedata * filedata,
13364 bfd_boolean relocate)
13366 Elf_Internal_Shdr * relsec;
13367 bfd_size_type bytes;
13368 bfd_size_type section_size;
13370 unsigned char * data;
13371 unsigned char * real_start;
13372 unsigned char * start;
13374 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13376 /* PR 21820: Do not fail if the section was empty. */
13377 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13379 section_size = section->sh_size;
13381 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13383 if (decompress_dumps)
13385 dwarf_size_type new_size = section_size;
13386 dwarf_size_type uncompressed_size = 0;
13388 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13390 Elf_Internal_Chdr chdr;
13391 unsigned int compression_header_size
13392 = get_compression_header (& chdr, start, section_size);
13394 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13396 warn (_("section '%s' has unsupported compress type: %d\n"),
13397 printable_section_name (filedata, section), chdr.ch_type);
13400 else if (chdr.ch_addralign != section->sh_addralign)
13402 warn (_("compressed section '%s' is corrupted\n"),
13403 printable_section_name (filedata, section));
13406 uncompressed_size = chdr.ch_size;
13407 start += compression_header_size;
13408 new_size -= compression_header_size;
13410 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13412 /* Read the zlib header. In this case, it should be "ZLIB"
13413 followed by the uncompressed section size, 8 bytes in
13414 big-endian order. */
13415 uncompressed_size = start[4]; uncompressed_size <<= 8;
13416 uncompressed_size += start[5]; uncompressed_size <<= 8;
13417 uncompressed_size += start[6]; uncompressed_size <<= 8;
13418 uncompressed_size += start[7]; uncompressed_size <<= 8;
13419 uncompressed_size += start[8]; uncompressed_size <<= 8;
13420 uncompressed_size += start[9]; uncompressed_size <<= 8;
13421 uncompressed_size += start[10]; uncompressed_size <<= 8;
13422 uncompressed_size += start[11];
13427 if (uncompressed_size)
13429 if (uncompress_section_contents (& start, uncompressed_size,
13432 section_size = new_size;
13436 error (_("Unable to decompress section %s\n"),
13437 printable_section_name (filedata, section));
13438 /* FIXME: Print the section anyway ? */
13443 start = real_start;
13448 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13453 /* If the section being dumped has relocations against it the user might
13454 be expecting these relocations to have been applied. Check for this
13455 case and issue a warning message in order to avoid confusion.
13456 FIXME: Maybe we ought to have an option that dumps a section with
13457 relocs applied ? */
13458 for (relsec = filedata->section_headers;
13459 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13462 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13463 || relsec->sh_info >= filedata->file_header.e_shnum
13464 || filedata->section_headers + relsec->sh_info != section
13465 || relsec->sh_size == 0
13466 || relsec->sh_link >= filedata->file_header.e_shnum)
13469 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13474 addr = section->sh_addr;
13475 bytes = section_size;
13484 lbytes = (bytes > 16 ? 16 : bytes);
13486 printf (" 0x%8.8lx ", (unsigned long) addr);
13488 for (j = 0; j < 16; j++)
13491 printf ("%2.2x", data[j]);
13499 for (j = 0; j < lbytes; j++)
13502 if (k >= ' ' && k < 0x7f)
13522 load_specific_debug_section (enum dwarf_section_display_enum debug,
13523 const Elf_Internal_Shdr * sec,
13526 struct dwarf_section * section = &debug_displays [debug].section;
13528 Filedata * filedata = (Filedata *) data;
13530 if (section->start != NULL)
13532 /* If it is already loaded, do nothing. */
13533 if (streq (section->filename, filedata->file_name))
13535 free (section->start);
13538 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13539 section->address = sec->sh_addr;
13540 section->user_data = NULL;
13541 section->filename = filedata->file_name;
13542 section->start = (unsigned char *) get_data (NULL, filedata,
13544 sec->sh_size, buf);
13545 if (section->start == NULL)
13549 unsigned char *start = section->start;
13550 dwarf_size_type size = sec->sh_size;
13551 dwarf_size_type uncompressed_size = 0;
13553 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13555 Elf_Internal_Chdr chdr;
13556 unsigned int compression_header_size;
13558 if (size < (is_32bit_elf
13559 ? sizeof (Elf32_External_Chdr)
13560 : sizeof (Elf64_External_Chdr)))
13562 warn (_("compressed section %s is too small to contain a compression header"),
13567 compression_header_size = get_compression_header (&chdr, start, size);
13569 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13571 warn (_("section '%s' has unsupported compress type: %d\n"),
13572 section->name, chdr.ch_type);
13575 else if (chdr.ch_addralign != sec->sh_addralign)
13577 warn (_("compressed section '%s' is corrupted\n"),
13581 uncompressed_size = chdr.ch_size;
13582 start += compression_header_size;
13583 size -= compression_header_size;
13585 else if (size > 12 && streq ((char *) start, "ZLIB"))
13587 /* Read the zlib header. In this case, it should be "ZLIB"
13588 followed by the uncompressed section size, 8 bytes in
13589 big-endian order. */
13590 uncompressed_size = start[4]; uncompressed_size <<= 8;
13591 uncompressed_size += start[5]; uncompressed_size <<= 8;
13592 uncompressed_size += start[6]; uncompressed_size <<= 8;
13593 uncompressed_size += start[7]; uncompressed_size <<= 8;
13594 uncompressed_size += start[8]; uncompressed_size <<= 8;
13595 uncompressed_size += start[9]; uncompressed_size <<= 8;
13596 uncompressed_size += start[10]; uncompressed_size <<= 8;
13597 uncompressed_size += start[11];
13602 if (uncompressed_size)
13604 if (uncompress_section_contents (&start, uncompressed_size,
13607 /* Free the compressed buffer, update the section buffer
13608 and the section size if uncompress is successful. */
13609 free (section->start);
13610 section->start = start;
13614 error (_("Unable to decompress section %s\n"),
13615 printable_section_name (filedata, sec));
13620 section->size = size;
13623 if (section->start == NULL)
13626 if (debug_displays [debug].relocate)
13628 if (! apply_relocations (filedata, sec, section->start, section->size,
13629 & section->reloc_info, & section->num_relocs))
13634 section->reloc_info = NULL;
13635 section->num_relocs = 0;
13641 /* If this is not NULL, load_debug_section will only look for sections
13642 within the list of sections given here. */
13643 static unsigned int * section_subset = NULL;
13646 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13648 struct dwarf_section * section = &debug_displays [debug].section;
13649 Elf_Internal_Shdr * sec;
13650 Filedata * filedata = (Filedata *) data;
13652 /* Without section headers we cannot find any sections. */
13653 if (filedata->section_headers == NULL)
13656 if (filedata->string_table == NULL
13657 && filedata->file_header.e_shstrndx != SHN_UNDEF
13658 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13660 Elf_Internal_Shdr * strs;
13662 /* Read in the string table, so that we have section names to scan. */
13663 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13665 if (strs != NULL && strs->sh_size != 0)
13667 filedata->string_table
13668 = (char *) get_data (NULL, filedata, strs->sh_offset,
13669 1, strs->sh_size, _("string table"));
13671 filedata->string_table_length
13672 = filedata->string_table != NULL ? strs->sh_size : 0;
13676 /* Locate the debug section. */
13677 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13679 section->name = section->uncompressed_name;
13682 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13684 section->name = section->compressed_name;
13689 /* If we're loading from a subset of sections, and we've loaded
13690 a section matching this name before, it's likely that it's a
13692 if (section_subset != NULL)
13693 free_debug_section (debug);
13695 return load_specific_debug_section (debug, sec, data);
13699 free_debug_section (enum dwarf_section_display_enum debug)
13701 struct dwarf_section * section = &debug_displays [debug].section;
13703 if (section->start == NULL)
13706 free ((char *) section->start);
13707 section->start = NULL;
13708 section->address = 0;
13713 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13715 char * name = SECTION_NAME (section);
13716 const char * print_name = printable_section_name (filedata, section);
13717 bfd_size_type length;
13718 bfd_boolean result = TRUE;
13721 length = section->sh_size;
13724 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13727 if (section->sh_type == SHT_NOBITS)
13729 /* There is no point in dumping the contents of a debugging section
13730 which has the NOBITS type - the bits in the file will be random.
13731 This can happen when a file containing a .eh_frame section is
13732 stripped with the --only-keep-debug command line option. */
13733 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13738 if (const_strneq (name, ".gnu.linkonce.wi."))
13739 name = ".debug_info";
13741 /* See if we know how to display the contents of this section. */
13742 for (i = 0; i < max; i++)
13744 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
13745 struct dwarf_section_display * display = debug_displays + i;
13746 struct dwarf_section * sec = & display->section;
13748 if (streq (sec->uncompressed_name, name)
13749 || (id == line && const_strneq (name, ".debug_line."))
13750 || streq (sec->compressed_name, name))
13752 bfd_boolean secondary = (section != find_section (filedata, name));
13755 free_debug_section (id);
13757 if (i == line && const_strneq (name, ".debug_line."))
13759 else if (streq (sec->uncompressed_name, name))
13760 sec->name = sec->uncompressed_name;
13762 sec->name = sec->compressed_name;
13764 if (load_specific_debug_section (id, section, filedata))
13766 /* If this debug section is part of a CU/TU set in a .dwp file,
13767 restrict load_debug_section to the sections in that set. */
13768 section_subset = find_cu_tu_set (filedata, shndx);
13770 result &= display->display (sec, filedata);
13772 section_subset = NULL;
13774 if (secondary || (id != info && id != abbrev))
13775 free_debug_section (id);
13783 printf (_("Unrecognized debug section: %s\n"), print_name);
13790 /* Set DUMP_SECTS for all sections where dumps were requested
13791 based on section name. */
13794 initialise_dumps_byname (Filedata * filedata)
13796 struct dump_list_entry * cur;
13798 for (cur = dump_sects_byname; cur; cur = cur->next)
13801 bfd_boolean any = FALSE;
13803 for (i = 0; i < filedata->file_header.e_shnum; i++)
13804 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13806 request_dump_bynumber (filedata, i, cur->type);
13811 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13817 process_section_contents (Filedata * filedata)
13819 Elf_Internal_Shdr * section;
13821 bfd_boolean res = TRUE;
13826 initialise_dumps_byname (filedata);
13828 for (i = 0, section = filedata->section_headers;
13829 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13832 dump_type dump = filedata->dump_sects[i];
13834 #ifdef SUPPORT_DISASSEMBLY
13835 if (dump & DISASS_DUMP)
13837 if (! disassemble_section (section, filedata))
13841 if (dump & HEX_DUMP)
13843 if (! dump_section_as_bytes (section, filedata, FALSE))
13847 if (dump & RELOC_DUMP)
13849 if (! dump_section_as_bytes (section, filedata, TRUE))
13853 if (dump & STRING_DUMP)
13855 if (! dump_section_as_strings (section, filedata))
13859 if (dump & DEBUG_DUMP)
13861 if (! display_debug_section (i, section, filedata))
13866 /* Check to see if the user requested a
13867 dump of a section that does not exist. */
13868 while (i < filedata->num_dump_sects)
13870 if (filedata->dump_sects[i])
13872 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13882 process_mips_fpe_exception (int mask)
13886 bfd_boolean first = TRUE;
13888 if (mask & OEX_FPU_INEX)
13889 fputs ("INEX", stdout), first = FALSE;
13890 if (mask & OEX_FPU_UFLO)
13891 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13892 if (mask & OEX_FPU_OFLO)
13893 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13894 if (mask & OEX_FPU_DIV0)
13895 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13896 if (mask & OEX_FPU_INVAL)
13897 printf ("%sINVAL", first ? "" : "|");
13900 fputs ("0", stdout);
13903 /* Display's the value of TAG at location P. If TAG is
13904 greater than 0 it is assumed to be an unknown tag, and
13905 a message is printed to this effect. Otherwise it is
13906 assumed that a message has already been printed.
13908 If the bottom bit of TAG is set it assumed to have a
13909 string value, otherwise it is assumed to have an integer
13912 Returns an updated P pointing to the first unread byte
13913 beyond the end of TAG's value.
13915 Reads at or beyond END will not be made. */
13917 static unsigned char *
13918 display_tag_value (signed int tag,
13920 const unsigned char * const end)
13925 printf (" Tag_unknown_%d: ", tag);
13929 warn (_("<corrupt tag>\n"));
13933 /* PR 17531 file: 027-19978-0.004. */
13934 size_t maxlen = (end - p) - 1;
13939 print_symbol ((int) maxlen, (const char *) p);
13940 p += strnlen ((char *) p, maxlen) + 1;
13944 printf (_("<corrupt string tag>"));
13945 p = (unsigned char *) end;
13953 val = read_uleb128 (p, &len, end);
13955 printf ("%ld (0x%lx)\n", val, val);
13962 /* ARC ABI attributes section. */
13964 static unsigned char *
13965 display_arc_attribute (unsigned char * p,
13966 const unsigned char * const end)
13972 tag = read_uleb128 (p, &len, end);
13977 case Tag_ARC_PCS_config:
13978 val = read_uleb128 (p, &len, end);
13980 printf (" Tag_ARC_PCS_config: ");
13984 printf (_("Absent/Non standard\n"));
13987 printf (_("Bare metal/mwdt\n"));
13990 printf (_("Bare metal/newlib\n"));
13993 printf (_("Linux/uclibc\n"));
13996 printf (_("Linux/glibc\n"));
13999 printf (_("Unknown\n"));
14004 case Tag_ARC_CPU_base:
14005 val = read_uleb128 (p, &len, end);
14007 printf (" Tag_ARC_CPU_base: ");
14012 printf (_("Absent\n"));
14014 case TAG_CPU_ARC6xx:
14015 printf ("ARC6xx\n");
14017 case TAG_CPU_ARC7xx:
14018 printf ("ARC7xx\n");
14020 case TAG_CPU_ARCEM:
14021 printf ("ARCEM\n");
14023 case TAG_CPU_ARCHS:
14024 printf ("ARCHS\n");
14029 case Tag_ARC_CPU_variation:
14030 val = read_uleb128 (p, &len, end);
14032 printf (" Tag_ARC_CPU_variation: ");
14036 if (val > 0 && val < 16)
14037 printf ("Core%d\n", val);
14039 printf ("Unknown\n");
14043 printf (_("Absent\n"));
14048 case Tag_ARC_CPU_name:
14049 printf (" Tag_ARC_CPU_name: ");
14050 p = display_tag_value (-1, p, end);
14053 case Tag_ARC_ABI_rf16:
14054 val = read_uleb128 (p, &len, end);
14056 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14059 case Tag_ARC_ABI_osver:
14060 val = read_uleb128 (p, &len, end);
14062 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14065 case Tag_ARC_ABI_pic:
14066 case Tag_ARC_ABI_sda:
14067 val = read_uleb128 (p, &len, end);
14069 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14070 : " Tag_ARC_ABI_pic: ");
14074 printf (_("Absent\n"));
14083 printf (_("Unknown\n"));
14088 case Tag_ARC_ABI_tls:
14089 val = read_uleb128 (p, &len, end);
14091 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14094 case Tag_ARC_ABI_enumsize:
14095 val = read_uleb128 (p, &len, end);
14097 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14101 case Tag_ARC_ABI_exceptions:
14102 val = read_uleb128 (p, &len, end);
14104 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14108 case Tag_ARC_ABI_double_size:
14109 val = read_uleb128 (p, &len, end);
14111 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14114 case Tag_ARC_ISA_config:
14115 printf (" Tag_ARC_ISA_config: ");
14116 p = display_tag_value (-1, p, end);
14119 case Tag_ARC_ISA_apex:
14120 printf (" Tag_ARC_ISA_apex: ");
14121 p = display_tag_value (-1, p, end);
14124 case Tag_ARC_ISA_mpy_option:
14125 val = read_uleb128 (p, &len, end);
14127 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14131 return display_tag_value (tag & 1, p, end);
14137 /* ARM EABI attributes section. */
14142 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14144 const char ** table;
14145 } arm_attr_public_tag;
14147 static const char * arm_attr_tag_CPU_arch[] =
14148 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14149 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14151 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14152 static const char * arm_attr_tag_THUMB_ISA_use[] =
14153 {"No", "Thumb-1", "Thumb-2", "Yes"};
14154 static const char * arm_attr_tag_FP_arch[] =
14155 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14156 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14157 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14158 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14159 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14160 "NEON for ARMv8.1"};
14161 static const char * arm_attr_tag_PCS_config[] =
14162 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14163 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14164 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14165 {"V6", "SB", "TLS", "Unused"};
14166 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14167 {"Absolute", "PC-relative", "SB-relative", "None"};
14168 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14169 {"Absolute", "PC-relative", "None"};
14170 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14171 {"None", "direct", "GOT-indirect"};
14172 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14173 {"None", "??? 1", "2", "??? 3", "4"};
14174 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14175 static const char * arm_attr_tag_ABI_FP_denormal[] =
14176 {"Unused", "Needed", "Sign only"};
14177 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14178 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14179 static const char * arm_attr_tag_ABI_FP_number_model[] =
14180 {"Unused", "Finite", "RTABI", "IEEE 754"};
14181 static const char * arm_attr_tag_ABI_enum_size[] =
14182 {"Unused", "small", "int", "forced to int"};
14183 static const char * arm_attr_tag_ABI_HardFP_use[] =
14184 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14185 static const char * arm_attr_tag_ABI_VFP_args[] =
14186 {"AAPCS", "VFP registers", "custom", "compatible"};
14187 static const char * arm_attr_tag_ABI_WMMX_args[] =
14188 {"AAPCS", "WMMX registers", "custom"};
14189 static const char * arm_attr_tag_ABI_optimization_goals[] =
14190 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14191 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14192 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14193 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14194 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14195 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14196 static const char * arm_attr_tag_FP_HP_extension[] =
14197 {"Not Allowed", "Allowed"};
14198 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14199 {"None", "IEEE 754", "Alternative Format"};
14200 static const char * arm_attr_tag_DSP_extension[] =
14201 {"Follow architecture", "Allowed"};
14202 static const char * arm_attr_tag_MPextension_use[] =
14203 {"Not Allowed", "Allowed"};
14204 static const char * arm_attr_tag_DIV_use[] =
14205 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14206 "Allowed in v7-A with integer division extension"};
14207 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14208 static const char * arm_attr_tag_Virtualization_use[] =
14209 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14210 "TrustZone and Virtualization Extensions"};
14211 static const char * arm_attr_tag_MPextension_use_legacy[] =
14212 {"Not Allowed", "Allowed"};
14214 #define LOOKUP(id, name) \
14215 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14216 static arm_attr_public_tag arm_attr_public_tags[] =
14218 {4, "CPU_raw_name", 1, NULL},
14219 {5, "CPU_name", 1, NULL},
14220 LOOKUP(6, CPU_arch),
14221 {7, "CPU_arch_profile", 0, NULL},
14222 LOOKUP(8, ARM_ISA_use),
14223 LOOKUP(9, THUMB_ISA_use),
14224 LOOKUP(10, FP_arch),
14225 LOOKUP(11, WMMX_arch),
14226 LOOKUP(12, Advanced_SIMD_arch),
14227 LOOKUP(13, PCS_config),
14228 LOOKUP(14, ABI_PCS_R9_use),
14229 LOOKUP(15, ABI_PCS_RW_data),
14230 LOOKUP(16, ABI_PCS_RO_data),
14231 LOOKUP(17, ABI_PCS_GOT_use),
14232 LOOKUP(18, ABI_PCS_wchar_t),
14233 LOOKUP(19, ABI_FP_rounding),
14234 LOOKUP(20, ABI_FP_denormal),
14235 LOOKUP(21, ABI_FP_exceptions),
14236 LOOKUP(22, ABI_FP_user_exceptions),
14237 LOOKUP(23, ABI_FP_number_model),
14238 {24, "ABI_align_needed", 0, NULL},
14239 {25, "ABI_align_preserved", 0, NULL},
14240 LOOKUP(26, ABI_enum_size),
14241 LOOKUP(27, ABI_HardFP_use),
14242 LOOKUP(28, ABI_VFP_args),
14243 LOOKUP(29, ABI_WMMX_args),
14244 LOOKUP(30, ABI_optimization_goals),
14245 LOOKUP(31, ABI_FP_optimization_goals),
14246 {32, "compatibility", 0, NULL},
14247 LOOKUP(34, CPU_unaligned_access),
14248 LOOKUP(36, FP_HP_extension),
14249 LOOKUP(38, ABI_FP_16bit_format),
14250 LOOKUP(42, MPextension_use),
14251 LOOKUP(44, DIV_use),
14252 LOOKUP(46, DSP_extension),
14253 {64, "nodefaults", 0, NULL},
14254 {65, "also_compatible_with", 0, NULL},
14255 LOOKUP(66, T2EE_use),
14256 {67, "conformance", 1, NULL},
14257 LOOKUP(68, Virtualization_use),
14258 LOOKUP(70, MPextension_use_legacy)
14262 static unsigned char *
14263 display_arm_attribute (unsigned char * p,
14264 const unsigned char * const end)
14269 arm_attr_public_tag * attr;
14273 tag = read_uleb128 (p, &len, end);
14276 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14278 if (arm_attr_public_tags[i].tag == tag)
14280 attr = &arm_attr_public_tags[i];
14287 printf (" Tag_%s: ", attr->name);
14288 switch (attr->type)
14293 case 7: /* Tag_CPU_arch_profile. */
14294 val = read_uleb128 (p, &len, end);
14298 case 0: printf (_("None\n")); break;
14299 case 'A': printf (_("Application\n")); break;
14300 case 'R': printf (_("Realtime\n")); break;
14301 case 'M': printf (_("Microcontroller\n")); break;
14302 case 'S': printf (_("Application or Realtime\n")); break;
14303 default: printf ("??? (%d)\n", val); break;
14307 case 24: /* Tag_align_needed. */
14308 val = read_uleb128 (p, &len, end);
14312 case 0: printf (_("None\n")); break;
14313 case 1: printf (_("8-byte\n")); break;
14314 case 2: printf (_("4-byte\n")); break;
14315 case 3: printf ("??? 3\n"); break;
14318 printf (_("8-byte and up to %d-byte extended\n"),
14321 printf ("??? (%d)\n", val);
14326 case 25: /* Tag_align_preserved. */
14327 val = read_uleb128 (p, &len, end);
14331 case 0: printf (_("None\n")); break;
14332 case 1: printf (_("8-byte, except leaf SP\n")); break;
14333 case 2: printf (_("8-byte\n")); break;
14334 case 3: printf ("??? 3\n"); break;
14337 printf (_("8-byte and up to %d-byte extended\n"),
14340 printf ("??? (%d)\n", val);
14345 case 32: /* Tag_compatibility. */
14347 val = read_uleb128 (p, &len, end);
14349 printf (_("flag = %d, vendor = "), val);
14352 size_t maxlen = (end - p) - 1;
14354 print_symbol ((int) maxlen, (const char *) p);
14355 p += strnlen ((char *) p, maxlen) + 1;
14359 printf (_("<corrupt>"));
14360 p = (unsigned char *) end;
14366 case 64: /* Tag_nodefaults. */
14367 /* PR 17531: file: 001-505008-0.01. */
14370 printf (_("True\n"));
14373 case 65: /* Tag_also_compatible_with. */
14374 val = read_uleb128 (p, &len, end);
14376 if (val == 6 /* Tag_CPU_arch. */)
14378 val = read_uleb128 (p, &len, end);
14380 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14381 printf ("??? (%d)\n", val);
14383 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14387 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14392 printf (_("<unknown: %d>\n"), tag);
14398 return display_tag_value (-1, p, end);
14400 return display_tag_value (0, p, end);
14403 assert (attr->type & 0x80);
14404 val = read_uleb128 (p, &len, end);
14406 type = attr->type & 0x7f;
14408 printf ("??? (%d)\n", val);
14410 printf ("%s\n", attr->table[val]);
14415 return display_tag_value (tag, p, end);
14418 static unsigned char *
14419 display_gnu_attribute (unsigned char * p,
14420 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14421 const unsigned char * const end)
14427 tag = read_uleb128 (p, &len, end);
14430 /* Tag_compatibility is the only generic GNU attribute defined at
14434 val = read_uleb128 (p, &len, end);
14437 printf (_("flag = %d, vendor = "), val);
14440 printf (_("<corrupt>\n"));
14441 warn (_("corrupt vendor attribute\n"));
14447 size_t maxlen = (end - p) - 1;
14449 print_symbol ((int) maxlen, (const char *) p);
14450 p += strnlen ((char *) p, maxlen) + 1;
14454 printf (_("<corrupt>"));
14455 p = (unsigned char *) end;
14462 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14463 return display_proc_gnu_attribute (p, tag, end);
14465 return display_tag_value (tag, p, end);
14468 static unsigned char *
14469 display_power_gnu_attribute (unsigned char * p,
14471 const unsigned char * const end)
14476 if (tag == Tag_GNU_Power_ABI_FP)
14478 val = read_uleb128 (p, &len, end);
14480 printf (" Tag_GNU_Power_ABI_FP: ");
14483 printf (_("<corrupt>\n"));
14488 printf ("(%#x), ", val);
14493 printf (_("unspecified hard/soft float, "));
14496 printf (_("hard float, "));
14499 printf (_("soft float, "));
14502 printf (_("single-precision hard float, "));
14509 printf (_("unspecified long double\n"));
14512 printf (_("128-bit IBM long double\n"));
14515 printf (_("64-bit long double\n"));
14518 printf (_("128-bit IEEE long double\n"));
14524 if (tag == Tag_GNU_Power_ABI_Vector)
14526 val = read_uleb128 (p, &len, end);
14528 printf (" Tag_GNU_Power_ABI_Vector: ");
14531 printf (_("<corrupt>\n"));
14536 printf ("(%#x), ", val);
14541 printf (_("unspecified\n"));
14544 printf (_("generic\n"));
14547 printf ("AltiVec\n");
14556 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14558 val = read_uleb128 (p, &len, end);
14560 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14563 printf (_("<corrupt>\n"));
14568 printf ("(%#x), ", val);
14573 printf (_("unspecified\n"));
14576 printf ("r3/r4\n");
14579 printf (_("memory\n"));
14588 return display_tag_value (tag & 1, p, end);
14591 static unsigned char *
14592 display_s390_gnu_attribute (unsigned char * p,
14594 const unsigned char * const end)
14599 if (tag == Tag_GNU_S390_ABI_Vector)
14601 val = read_uleb128 (p, &len, end);
14603 printf (" Tag_GNU_S390_ABI_Vector: ");
14608 printf (_("any\n"));
14611 printf (_("software\n"));
14614 printf (_("hardware\n"));
14617 printf ("??? (%d)\n", val);
14623 return display_tag_value (tag & 1, p, end);
14627 display_sparc_hwcaps (unsigned int mask)
14631 bfd_boolean first = TRUE;
14633 if (mask & ELF_SPARC_HWCAP_MUL32)
14634 fputs ("mul32", stdout), first = FALSE;
14635 if (mask & ELF_SPARC_HWCAP_DIV32)
14636 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14637 if (mask & ELF_SPARC_HWCAP_FSMULD)
14638 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14639 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14640 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14641 if (mask & ELF_SPARC_HWCAP_POPC)
14642 printf ("%spopc", first ? "" : "|"), first = FALSE;
14643 if (mask & ELF_SPARC_HWCAP_VIS)
14644 printf ("%svis", first ? "" : "|"), first = FALSE;
14645 if (mask & ELF_SPARC_HWCAP_VIS2)
14646 printf ("%svis2", first ? "" : "|"), first = FALSE;
14647 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14648 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14649 if (mask & ELF_SPARC_HWCAP_FMAF)
14650 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14651 if (mask & ELF_SPARC_HWCAP_VIS3)
14652 printf ("%svis3", first ? "" : "|"), first = FALSE;
14653 if (mask & ELF_SPARC_HWCAP_HPC)
14654 printf ("%shpc", first ? "" : "|"), first = FALSE;
14655 if (mask & ELF_SPARC_HWCAP_RANDOM)
14656 printf ("%srandom", first ? "" : "|"), first = FALSE;
14657 if (mask & ELF_SPARC_HWCAP_TRANS)
14658 printf ("%strans", first ? "" : "|"), first = FALSE;
14659 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14660 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14661 if (mask & ELF_SPARC_HWCAP_IMA)
14662 printf ("%sima", first ? "" : "|"), first = FALSE;
14663 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14664 printf ("%scspare", first ? "" : "|"), first = FALSE;
14667 fputc ('0', stdout);
14668 fputc ('\n', stdout);
14672 display_sparc_hwcaps2 (unsigned int mask)
14676 bfd_boolean first = TRUE;
14678 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14679 fputs ("fjathplus", stdout), first = FALSE;
14680 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14681 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14682 if (mask & ELF_SPARC_HWCAP2_ADP)
14683 printf ("%sadp", first ? "" : "|"), first = FALSE;
14684 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14685 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14686 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14687 printf ("%smwait", first ? "" : "|"), first = FALSE;
14688 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14689 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14690 if (mask & ELF_SPARC_HWCAP2_XMONT)
14691 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14692 if (mask & ELF_SPARC_HWCAP2_NSEC)
14693 printf ("%snsec", first ? "" : "|"), first = FALSE;
14694 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14695 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14696 if (mask & ELF_SPARC_HWCAP2_FJDES)
14697 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14698 if (mask & ELF_SPARC_HWCAP2_FJAES)
14699 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14702 fputc ('0', stdout);
14703 fputc ('\n', stdout);
14706 static unsigned char *
14707 display_sparc_gnu_attribute (unsigned char * p,
14709 const unsigned char * const end)
14714 if (tag == Tag_GNU_Sparc_HWCAPS)
14716 val = read_uleb128 (p, &len, end);
14718 printf (" Tag_GNU_Sparc_HWCAPS: ");
14719 display_sparc_hwcaps (val);
14722 if (tag == Tag_GNU_Sparc_HWCAPS2)
14724 val = read_uleb128 (p, &len, end);
14726 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14727 display_sparc_hwcaps2 (val);
14731 return display_tag_value (tag, p, end);
14735 print_mips_fp_abi_value (unsigned int val)
14739 case Val_GNU_MIPS_ABI_FP_ANY:
14740 printf (_("Hard or soft float\n"));
14742 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14743 printf (_("Hard float (double precision)\n"));
14745 case Val_GNU_MIPS_ABI_FP_SINGLE:
14746 printf (_("Hard float (single precision)\n"));
14748 case Val_GNU_MIPS_ABI_FP_SOFT:
14749 printf (_("Soft float\n"));
14751 case Val_GNU_MIPS_ABI_FP_OLD_64:
14752 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14754 case Val_GNU_MIPS_ABI_FP_XX:
14755 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14757 case Val_GNU_MIPS_ABI_FP_64:
14758 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14760 case Val_GNU_MIPS_ABI_FP_64A:
14761 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14763 case Val_GNU_MIPS_ABI_FP_NAN2008:
14764 printf (_("NaN 2008 compatibility\n"));
14767 printf ("??? (%d)\n", val);
14772 static unsigned char *
14773 display_mips_gnu_attribute (unsigned char * p,
14775 const unsigned char * const end)
14777 if (tag == Tag_GNU_MIPS_ABI_FP)
14782 val = read_uleb128 (p, &len, end);
14784 printf (" Tag_GNU_MIPS_ABI_FP: ");
14786 print_mips_fp_abi_value (val);
14791 if (tag == Tag_GNU_MIPS_ABI_MSA)
14796 val = read_uleb128 (p, &len, end);
14798 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14802 case Val_GNU_MIPS_ABI_MSA_ANY:
14803 printf (_("Any MSA or not\n"));
14805 case Val_GNU_MIPS_ABI_MSA_128:
14806 printf (_("128-bit MSA\n"));
14809 printf ("??? (%d)\n", val);
14815 return display_tag_value (tag & 1, p, end);
14818 static unsigned char *
14819 display_tic6x_attribute (unsigned char * p,
14820 const unsigned char * const end)
14826 tag = read_uleb128 (p, &len, end);
14832 val = read_uleb128 (p, &len, end);
14834 printf (" Tag_ISA: ");
14838 case C6XABI_Tag_ISA_none:
14839 printf (_("None\n"));
14841 case C6XABI_Tag_ISA_C62X:
14844 case C6XABI_Tag_ISA_C67X:
14847 case C6XABI_Tag_ISA_C67XP:
14848 printf ("C67x+\n");
14850 case C6XABI_Tag_ISA_C64X:
14853 case C6XABI_Tag_ISA_C64XP:
14854 printf ("C64x+\n");
14856 case C6XABI_Tag_ISA_C674X:
14857 printf ("C674x\n");
14860 printf ("??? (%d)\n", val);
14865 case Tag_ABI_wchar_t:
14866 val = read_uleb128 (p, &len, end);
14868 printf (" Tag_ABI_wchar_t: ");
14872 printf (_("Not used\n"));
14875 printf (_("2 bytes\n"));
14878 printf (_("4 bytes\n"));
14881 printf ("??? (%d)\n", val);
14886 case Tag_ABI_stack_align_needed:
14887 val = read_uleb128 (p, &len, end);
14889 printf (" Tag_ABI_stack_align_needed: ");
14893 printf (_("8-byte\n"));
14896 printf (_("16-byte\n"));
14899 printf ("??? (%d)\n", val);
14904 case Tag_ABI_stack_align_preserved:
14905 val = read_uleb128 (p, &len, end);
14907 printf (" Tag_ABI_stack_align_preserved: ");
14911 printf (_("8-byte\n"));
14914 printf (_("16-byte\n"));
14917 printf ("??? (%d)\n", val);
14923 val = read_uleb128 (p, &len, end);
14925 printf (" Tag_ABI_DSBT: ");
14929 printf (_("DSBT addressing not used\n"));
14932 printf (_("DSBT addressing used\n"));
14935 printf ("??? (%d)\n", val);
14941 val = read_uleb128 (p, &len, end);
14943 printf (" Tag_ABI_PID: ");
14947 printf (_("Data addressing position-dependent\n"));
14950 printf (_("Data addressing position-independent, GOT near DP\n"));
14953 printf (_("Data addressing position-independent, GOT far from DP\n"));
14956 printf ("??? (%d)\n", val);
14962 val = read_uleb128 (p, &len, end);
14964 printf (" Tag_ABI_PIC: ");
14968 printf (_("Code addressing position-dependent\n"));
14971 printf (_("Code addressing position-independent\n"));
14974 printf ("??? (%d)\n", val);
14979 case Tag_ABI_array_object_alignment:
14980 val = read_uleb128 (p, &len, end);
14982 printf (" Tag_ABI_array_object_alignment: ");
14986 printf (_("8-byte\n"));
14989 printf (_("4-byte\n"));
14992 printf (_("16-byte\n"));
14995 printf ("??? (%d)\n", val);
15000 case Tag_ABI_array_object_align_expected:
15001 val = read_uleb128 (p, &len, end);
15003 printf (" Tag_ABI_array_object_align_expected: ");
15007 printf (_("8-byte\n"));
15010 printf (_("4-byte\n"));
15013 printf (_("16-byte\n"));
15016 printf ("??? (%d)\n", val);
15021 case Tag_ABI_compatibility:
15023 val = read_uleb128 (p, &len, end);
15025 printf (" Tag_ABI_compatibility: ");
15026 printf (_("flag = %d, vendor = "), val);
15029 size_t maxlen = (end - p) - 1;
15031 print_symbol ((int) maxlen, (const char *) p);
15032 p += strnlen ((char *) p, maxlen) + 1;
15036 printf (_("<corrupt>"));
15037 p = (unsigned char *) end;
15043 case Tag_ABI_conformance:
15045 printf (" Tag_ABI_conformance: \"");
15048 size_t maxlen = (end - p) - 1;
15050 print_symbol ((int) maxlen, (const char *) p);
15051 p += strnlen ((char *) p, maxlen) + 1;
15055 printf (_("<corrupt>"));
15056 p = (unsigned char *) end;
15063 return display_tag_value (tag, p, end);
15067 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15069 unsigned long addr = 0;
15070 size_t bytes = end - p;
15077 int lbytes = (bytes > 16 ? 16 : bytes);
15079 printf (" 0x%8.8lx ", addr);
15081 for (j = 0; j < 16; j++)
15084 printf ("%2.2x", p[j]);
15092 for (j = 0; j < lbytes; j++)
15095 if (k >= ' ' && k < 0x7f)
15111 static unsigned char *
15112 display_msp430x_attribute (unsigned char * p,
15113 const unsigned char * const end)
15119 tag = read_uleb128 (p, & len, end);
15124 case OFBA_MSPABI_Tag_ISA:
15125 val = read_uleb128 (p, &len, end);
15127 printf (" Tag_ISA: ");
15130 case 0: printf (_("None\n")); break;
15131 case 1: printf (_("MSP430\n")); break;
15132 case 2: printf (_("MSP430X\n")); break;
15133 default: printf ("??? (%d)\n", val); break;
15137 case OFBA_MSPABI_Tag_Code_Model:
15138 val = read_uleb128 (p, &len, end);
15140 printf (" Tag_Code_Model: ");
15143 case 0: printf (_("None\n")); break;
15144 case 1: printf (_("Small\n")); break;
15145 case 2: printf (_("Large\n")); break;
15146 default: printf ("??? (%d)\n", val); break;
15150 case OFBA_MSPABI_Tag_Data_Model:
15151 val = read_uleb128 (p, &len, end);
15153 printf (" Tag_Data_Model: ");
15156 case 0: printf (_("None\n")); break;
15157 case 1: printf (_("Small\n")); break;
15158 case 2: printf (_("Large\n")); break;
15159 case 3: printf (_("Restricted Large\n")); break;
15160 default: printf ("??? (%d)\n", val); break;
15165 printf (_(" <unknown tag %d>: "), tag);
15172 size_t maxlen = (end - p) - 1;
15174 print_symbol ((int) maxlen, (const char *) p);
15175 p += strnlen ((char *) p, maxlen) + 1;
15179 printf (_("<corrupt>"));
15180 p = (unsigned char *) end;
15186 val = read_uleb128 (p, &len, end);
15188 printf ("%d (0x%x)\n", val, val);
15198 process_attributes (Filedata * filedata,
15199 const char * public_name,
15200 unsigned int proc_type,
15201 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15202 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15204 Elf_Internal_Shdr * sect;
15206 bfd_boolean res = TRUE;
15208 /* Find the section header so that we get the size. */
15209 for (i = 0, sect = filedata->section_headers;
15210 i < filedata->file_header.e_shnum;
15213 unsigned char * contents;
15216 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15219 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15220 sect->sh_size, _("attributes"));
15221 if (contents == NULL)
15228 /* The first character is the version of the attributes.
15229 Currently only version 1, (aka 'A') is recognised here. */
15232 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15237 bfd_vma section_len;
15239 section_len = sect->sh_size - 1;
15242 while (section_len > 0)
15245 unsigned int namelen;
15246 bfd_boolean public_section;
15247 bfd_boolean gnu_section;
15249 if (section_len <= 4)
15251 error (_("Tag section ends prematurely\n"));
15255 attr_len = byte_get (p, 4);
15258 if (attr_len > section_len)
15260 error (_("Bad attribute length (%u > %u)\n"),
15261 (unsigned) attr_len, (unsigned) section_len);
15262 attr_len = section_len;
15265 /* PR 17531: file: 001-101425-0.004 */
15266 else if (attr_len < 5)
15268 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15273 section_len -= attr_len;
15276 namelen = strnlen ((char *) p, attr_len) + 1;
15277 if (namelen == 0 || namelen >= attr_len)
15279 error (_("Corrupt attribute section name\n"));
15284 printf (_("Attribute Section: "));
15285 print_symbol (INT_MAX, (const char *) p);
15288 if (public_name && streq ((char *) p, public_name))
15289 public_section = TRUE;
15291 public_section = FALSE;
15293 if (streq ((char *) p, "gnu"))
15294 gnu_section = TRUE;
15296 gnu_section = FALSE;
15299 attr_len -= namelen;
15301 while (attr_len > 0 && p < contents + sect->sh_size)
15306 unsigned char * end;
15308 /* PR binutils/17531: Safe handling of corrupt files. */
15311 error (_("Unused bytes at end of section\n"));
15318 size = byte_get (p, 4);
15319 if (size > attr_len)
15321 error (_("Bad subsection length (%u > %u)\n"),
15322 (unsigned) size, (unsigned) attr_len);
15326 /* PR binutils/17531: Safe handling of corrupt files. */
15329 error (_("Bad subsection length (%u < 6)\n"),
15337 end = p + size - 1;
15338 assert (end <= contents + sect->sh_size);
15344 printf (_("File Attributes\n"));
15347 printf (_("Section Attributes:"));
15350 printf (_("Symbol Attributes:"));
15351 /* Fall through. */
15357 val = read_uleb128 (p, &j, end);
15361 printf (" %d", val);
15366 printf (_("Unknown tag: %d\n"), tag);
15367 public_section = FALSE;
15371 if (public_section && display_pub_attribute != NULL)
15374 p = display_pub_attribute (p, end);
15377 else if (gnu_section && display_proc_gnu_attribute != NULL)
15380 p = display_gnu_attribute (p,
15381 display_proc_gnu_attribute,
15387 printf (_(" Unknown attribute:\n"));
15388 display_raw_attribute (p, end);
15403 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15404 Print the Address, Access and Initial fields of an entry at VMA ADDR
15405 and return the VMA of the next entry, or -1 if there was a problem.
15406 Does not read from DATA_END or beyond. */
15409 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15410 unsigned char * data_end)
15413 print_vma (addr, LONG_HEX);
15415 if (addr < pltgot + 0xfff0)
15416 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15418 printf ("%10s", "");
15421 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15425 unsigned char * from = data + addr - pltgot;
15427 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15429 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15430 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15431 return (bfd_vma) -1;
15435 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15436 print_vma (entry, LONG_HEX);
15439 return addr + (is_32bit_elf ? 4 : 8);
15442 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15443 PLTGOT. Print the Address and Initial fields of an entry at VMA
15444 ADDR and return the VMA of the next entry. */
15447 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15450 print_vma (addr, LONG_HEX);
15453 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15458 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15459 print_vma (entry, LONG_HEX);
15461 return addr + (is_32bit_elf ? 4 : 8);
15465 print_mips_ases (unsigned int mask)
15467 if (mask & AFL_ASE_DSP)
15468 fputs ("\n\tDSP ASE", stdout);
15469 if (mask & AFL_ASE_DSPR2)
15470 fputs ("\n\tDSP R2 ASE", stdout);
15471 if (mask & AFL_ASE_DSPR3)
15472 fputs ("\n\tDSP R3 ASE", stdout);
15473 if (mask & AFL_ASE_EVA)
15474 fputs ("\n\tEnhanced VA Scheme", stdout);
15475 if (mask & AFL_ASE_MCU)
15476 fputs ("\n\tMCU (MicroController) ASE", stdout);
15477 if (mask & AFL_ASE_MDMX)
15478 fputs ("\n\tMDMX ASE", stdout);
15479 if (mask & AFL_ASE_MIPS3D)
15480 fputs ("\n\tMIPS-3D ASE", stdout);
15481 if (mask & AFL_ASE_MT)
15482 fputs ("\n\tMT ASE", stdout);
15483 if (mask & AFL_ASE_SMARTMIPS)
15484 fputs ("\n\tSmartMIPS ASE", stdout);
15485 if (mask & AFL_ASE_VIRT)
15486 fputs ("\n\tVZ ASE", stdout);
15487 if (mask & AFL_ASE_MSA)
15488 fputs ("\n\tMSA ASE", stdout);
15489 if (mask & AFL_ASE_MIPS16)
15490 fputs ("\n\tMIPS16 ASE", stdout);
15491 if (mask & AFL_ASE_MICROMIPS)
15492 fputs ("\n\tMICROMIPS ASE", stdout);
15493 if (mask & AFL_ASE_XPA)
15494 fputs ("\n\tXPA ASE", stdout);
15495 if (mask & AFL_ASE_MIPS16E2)
15496 fputs ("\n\tMIPS16e2 ASE", stdout);
15498 fprintf (stdout, "\n\t%s", _("None"));
15499 else if ((mask & ~AFL_ASE_MASK) != 0)
15500 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15504 print_mips_isa_ext (unsigned int isa_ext)
15509 fputs (_("None"), stdout);
15512 fputs ("RMI XLR", stdout);
15514 case AFL_EXT_OCTEON3:
15515 fputs ("Cavium Networks Octeon3", stdout);
15517 case AFL_EXT_OCTEON2:
15518 fputs ("Cavium Networks Octeon2", stdout);
15520 case AFL_EXT_OCTEONP:
15521 fputs ("Cavium Networks OcteonP", stdout);
15523 case AFL_EXT_LOONGSON_3A:
15524 fputs ("Loongson 3A", stdout);
15526 case AFL_EXT_OCTEON:
15527 fputs ("Cavium Networks Octeon", stdout);
15530 fputs ("Toshiba R5900", stdout);
15533 fputs ("MIPS R4650", stdout);
15536 fputs ("LSI R4010", stdout);
15539 fputs ("NEC VR4100", stdout);
15542 fputs ("Toshiba R3900", stdout);
15544 case AFL_EXT_10000:
15545 fputs ("MIPS R10000", stdout);
15548 fputs ("Broadcom SB-1", stdout);
15551 fputs ("NEC VR4111/VR4181", stdout);
15554 fputs ("NEC VR4120", stdout);
15557 fputs ("NEC VR5400", stdout);
15560 fputs ("NEC VR5500", stdout);
15562 case AFL_EXT_LOONGSON_2E:
15563 fputs ("ST Microelectronics Loongson 2E", stdout);
15565 case AFL_EXT_LOONGSON_2F:
15566 fputs ("ST Microelectronics Loongson 2F", stdout);
15568 case AFL_EXT_INTERAPTIV_MR2:
15569 fputs ("Imagination interAptiv MR2", stdout);
15572 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15577 get_mips_reg_size (int reg_size)
15579 return (reg_size == AFL_REG_NONE) ? 0
15580 : (reg_size == AFL_REG_32) ? 32
15581 : (reg_size == AFL_REG_64) ? 64
15582 : (reg_size == AFL_REG_128) ? 128
15587 process_mips_specific (Filedata * filedata)
15589 Elf_Internal_Dyn * entry;
15590 Elf_Internal_Shdr *sect = NULL;
15591 size_t liblist_offset = 0;
15592 size_t liblistno = 0;
15593 size_t conflictsno = 0;
15594 size_t options_offset = 0;
15595 size_t conflicts_offset = 0;
15596 size_t pltrelsz = 0;
15598 bfd_vma pltgot = 0;
15599 bfd_vma mips_pltgot = 0;
15600 bfd_vma jmprel = 0;
15601 bfd_vma local_gotno = 0;
15602 bfd_vma gotsym = 0;
15603 bfd_vma symtabno = 0;
15604 bfd_boolean res = TRUE;
15606 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15607 display_mips_gnu_attribute))
15610 sect = find_section (filedata, ".MIPS.abiflags");
15614 Elf_External_ABIFlags_v0 *abiflags_ext;
15615 Elf_Internal_ABIFlags_v0 abiflags_in;
15617 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15619 error (_("Corrupt MIPS ABI Flags section.\n"));
15624 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15625 sect->sh_size, _("MIPS ABI Flags section"));
15628 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15629 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15630 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15631 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15632 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15633 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15634 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15635 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15636 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15637 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15638 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15640 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15641 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15642 if (abiflags_in.isa_rev > 1)
15643 printf ("r%d", abiflags_in.isa_rev);
15644 printf ("\nGPR size: %d",
15645 get_mips_reg_size (abiflags_in.gpr_size));
15646 printf ("\nCPR1 size: %d",
15647 get_mips_reg_size (abiflags_in.cpr1_size));
15648 printf ("\nCPR2 size: %d",
15649 get_mips_reg_size (abiflags_in.cpr2_size));
15650 fputs ("\nFP ABI: ", stdout);
15651 print_mips_fp_abi_value (abiflags_in.fp_abi);
15652 fputs ("ISA Extension: ", stdout);
15653 print_mips_isa_ext (abiflags_in.isa_ext);
15654 fputs ("\nASEs:", stdout);
15655 print_mips_ases (abiflags_in.ases);
15656 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15657 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15658 fputc ('\n', stdout);
15659 free (abiflags_ext);
15664 /* We have a lot of special sections. Thanks SGI! */
15665 if (dynamic_section == NULL)
15667 /* No dynamic information available. See if there is static GOT. */
15668 sect = find_section (filedata, ".got");
15671 unsigned char *data_end;
15672 unsigned char *data;
15676 pltgot = sect->sh_addr;
15679 addr_size = (is_32bit_elf ? 4 : 8);
15680 end = pltgot + sect->sh_size;
15682 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15684 _("Global Offset Table data"));
15685 /* PR 12855: Null data is handled gracefully throughout. */
15686 data_end = data + (end - pltgot);
15688 printf (_("\nStatic GOT:\n"));
15689 printf (_(" Canonical gp value: "));
15690 print_vma (ent + 0x7ff0, LONG_HEX);
15693 /* In a dynamic binary GOT[0] is reserved for the dynamic
15694 loader to store the lazy resolver pointer, however in
15695 a static binary it may well have been omitted and GOT
15696 reduced to a table of addresses.
15697 PR 21344: Check for the entry being fully available
15698 before fetching it. */
15700 && data + ent - pltgot + addr_size <= data_end
15701 && byte_get (data + ent - pltgot, addr_size) == 0)
15703 printf (_(" Reserved entries:\n"));
15704 printf (_(" %*s %10s %*s\n"),
15705 addr_size * 2, _("Address"), _("Access"),
15706 addr_size * 2, _("Value"));
15707 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15709 if (ent == (bfd_vma) -1)
15710 goto sgot_print_fail;
15712 /* Check for the MSB of GOT[1] being set, identifying a
15713 GNU object. This entry will be used by some runtime
15714 loaders, to store the module pointer. Otherwise this
15715 is an ordinary local entry.
15716 PR 21344: Check for the entry being fully available
15717 before fetching it. */
15719 && data + ent - pltgot + addr_size <= data_end
15720 && (byte_get (data + ent - pltgot, addr_size)
15721 >> (addr_size * 8 - 1)) != 0)
15723 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15725 if (ent == (bfd_vma) -1)
15726 goto sgot_print_fail;
15731 if (data != NULL && ent < end)
15733 printf (_(" Local entries:\n"));
15734 printf (" %*s %10s %*s\n",
15735 addr_size * 2, _("Address"), _("Access"),
15736 addr_size * 2, _("Value"));
15739 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15741 if (ent == (bfd_vma) -1)
15742 goto sgot_print_fail;
15754 for (entry = dynamic_section;
15755 /* PR 17531 file: 012-50589-0.004. */
15756 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15758 switch (entry->d_tag)
15760 case DT_MIPS_LIBLIST:
15762 = offset_from_vma (filedata, entry->d_un.d_val,
15763 liblistno * sizeof (Elf32_External_Lib));
15765 case DT_MIPS_LIBLISTNO:
15766 liblistno = entry->d_un.d_val;
15768 case DT_MIPS_OPTIONS:
15769 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15771 case DT_MIPS_CONFLICT:
15773 = offset_from_vma (filedata, entry->d_un.d_val,
15774 conflictsno * sizeof (Elf32_External_Conflict));
15776 case DT_MIPS_CONFLICTNO:
15777 conflictsno = entry->d_un.d_val;
15780 pltgot = entry->d_un.d_ptr;
15782 case DT_MIPS_LOCAL_GOTNO:
15783 local_gotno = entry->d_un.d_val;
15785 case DT_MIPS_GOTSYM:
15786 gotsym = entry->d_un.d_val;
15788 case DT_MIPS_SYMTABNO:
15789 symtabno = entry->d_un.d_val;
15791 case DT_MIPS_PLTGOT:
15792 mips_pltgot = entry->d_un.d_ptr;
15795 pltrel = entry->d_un.d_val;
15798 pltrelsz = entry->d_un.d_val;
15801 jmprel = entry->d_un.d_ptr;
15807 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15809 Elf32_External_Lib * elib;
15812 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15814 sizeof (Elf32_External_Lib),
15815 _("liblist section data"));
15818 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15819 "\nSection '.liblist' contains %lu entries:\n",
15820 (unsigned long) liblistno),
15821 (unsigned long) liblistno);
15822 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15825 for (cnt = 0; cnt < liblistno; ++cnt)
15832 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15833 atime = BYTE_GET (elib[cnt].l_time_stamp);
15834 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15835 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15836 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15838 tmp = gmtime (&atime);
15839 snprintf (timebuf, sizeof (timebuf),
15840 "%04u-%02u-%02uT%02u:%02u:%02u",
15841 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15842 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15844 printf ("%3lu: ", (unsigned long) cnt);
15845 if (VALID_DYNAMIC_NAME (liblist.l_name))
15846 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15848 printf (_("<corrupt: %9ld>"), liblist.l_name);
15849 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15850 liblist.l_version);
15852 if (liblist.l_flags == 0)
15856 static const struct
15863 { " EXACT_MATCH", LL_EXACT_MATCH },
15864 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15865 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15866 { " EXPORTS", LL_EXPORTS },
15867 { " DELAY_LOAD", LL_DELAY_LOAD },
15868 { " DELTA", LL_DELTA }
15870 int flags = liblist.l_flags;
15873 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15874 if ((flags & l_flags_vals[fcnt].bit) != 0)
15876 fputs (l_flags_vals[fcnt].name, stdout);
15877 flags ^= l_flags_vals[fcnt].bit;
15880 printf (" %#x", (unsigned int) flags);
15892 if (options_offset != 0)
15894 Elf_External_Options * eopt;
15895 Elf_Internal_Options * iopt;
15896 Elf_Internal_Options * option;
15899 sect = filedata->section_headers;
15901 /* Find the section header so that we get the size. */
15902 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15903 /* PR 17533 file: 012-277276-0.004. */
15906 error (_("No MIPS_OPTIONS header found\n"));
15910 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15911 sect->sh_size, _("options"));
15914 iopt = (Elf_Internal_Options *)
15915 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15918 error (_("Out of memory allocating space for MIPS options\n"));
15925 while (offset <= sect->sh_size - sizeof (* eopt))
15927 Elf_External_Options * eoption;
15929 eoption = (Elf_External_Options *) ((char *) eopt + offset);
15931 option->kind = BYTE_GET (eoption->kind);
15932 option->size = BYTE_GET (eoption->size);
15933 option->section = BYTE_GET (eoption->section);
15934 option->info = BYTE_GET (eoption->info);
15936 /* PR 17531: file: ffa0fa3b. */
15937 if (option->size < sizeof (* eopt)
15938 || offset + option->size > sect->sh_size)
15940 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15943 offset += option->size;
15949 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15950 "\nSection '%s' contains %d entries:\n",
15952 printable_section_name (filedata, sect), cnt);
15961 switch (option->kind)
15964 /* This shouldn't happen. */
15965 printf (" NULL %d %lx", option->section, option->info);
15968 printf (" REGINFO ");
15969 if (filedata->file_header.e_machine == EM_MIPS)
15972 Elf32_External_RegInfo * ereg;
15973 Elf32_RegInfo reginfo;
15975 ereg = (Elf32_External_RegInfo *) (option + 1);
15976 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15977 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15978 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15979 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15980 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15981 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15983 printf ("GPR %08lx GP 0x%lx\n",
15984 reginfo.ri_gprmask,
15985 (unsigned long) reginfo.ri_gp_value);
15986 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15987 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15988 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15993 Elf64_External_RegInfo * ereg;
15994 Elf64_Internal_RegInfo reginfo;
15996 ereg = (Elf64_External_RegInfo *) (option + 1);
15997 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15998 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15999 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16000 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16001 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16002 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16004 printf ("GPR %08lx GP 0x",
16005 reginfo.ri_gprmask);
16006 printf_vma (reginfo.ri_gp_value);
16009 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16010 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16011 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16015 case ODK_EXCEPTIONS:
16016 fputs (" EXCEPTIONS fpe_min(", stdout);
16017 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16018 fputs (") fpe_max(", stdout);
16019 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16020 fputs (")", stdout);
16022 if (option->info & OEX_PAGE0)
16023 fputs (" PAGE0", stdout);
16024 if (option->info & OEX_SMM)
16025 fputs (" SMM", stdout);
16026 if (option->info & OEX_FPDBUG)
16027 fputs (" FPDBUG", stdout);
16028 if (option->info & OEX_DISMISS)
16029 fputs (" DISMISS", stdout);
16032 fputs (" PAD ", stdout);
16033 if (option->info & OPAD_PREFIX)
16034 fputs (" PREFIX", stdout);
16035 if (option->info & OPAD_POSTFIX)
16036 fputs (" POSTFIX", stdout);
16037 if (option->info & OPAD_SYMBOL)
16038 fputs (" SYMBOL", stdout);
16041 fputs (" HWPATCH ", stdout);
16042 if (option->info & OHW_R4KEOP)
16043 fputs (" R4KEOP", stdout);
16044 if (option->info & OHW_R8KPFETCH)
16045 fputs (" R8KPFETCH", stdout);
16046 if (option->info & OHW_R5KEOP)
16047 fputs (" R5KEOP", stdout);
16048 if (option->info & OHW_R5KCVTL)
16049 fputs (" R5KCVTL", stdout);
16052 fputs (" FILL ", stdout);
16053 /* XXX Print content of info word? */
16056 fputs (" TAGS ", stdout);
16057 /* XXX Print content of info word? */
16060 fputs (" HWAND ", stdout);
16061 if (option->info & OHWA0_R4KEOP_CHECKED)
16062 fputs (" R4KEOP_CHECKED", stdout);
16063 if (option->info & OHWA0_R4KEOP_CLEAN)
16064 fputs (" R4KEOP_CLEAN", stdout);
16067 fputs (" HWOR ", stdout);
16068 if (option->info & OHWA0_R4KEOP_CHECKED)
16069 fputs (" R4KEOP_CHECKED", stdout);
16070 if (option->info & OHWA0_R4KEOP_CLEAN)
16071 fputs (" R4KEOP_CLEAN", stdout);
16074 printf (" GP_GROUP %#06lx self-contained %#06lx",
16075 option->info & OGP_GROUP,
16076 (option->info & OGP_SELF) >> 16);
16079 printf (" IDENT %#06lx self-contained %#06lx",
16080 option->info & OGP_GROUP,
16081 (option->info & OGP_SELF) >> 16);
16084 /* This shouldn't happen. */
16085 printf (" %3d ??? %d %lx",
16086 option->kind, option->section, option->info);
16090 len = sizeof (* eopt);
16091 while (len < option->size)
16093 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16095 if (ISPRINT (datum))
16096 printf ("%c", datum);
16098 printf ("\\%03o", datum);
16101 fputs ("\n", stdout);
16103 offset += option->size;
16113 if (conflicts_offset != 0 && conflictsno != 0)
16115 Elf32_Conflict * iconf;
16118 if (dynamic_symbols == NULL)
16120 error (_("conflict list found without a dynamic symbol table\n"));
16124 /* PR 21345 - print a slightly more helpful error message
16125 if we are sure that the cmalloc will fail. */
16126 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16128 error (_("Overlarge number of conflicts detected: %lx\n"),
16129 (long) conflictsno);
16133 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16136 error (_("Out of memory allocating space for dynamic conflicts\n"));
16142 Elf32_External_Conflict * econf32;
16144 econf32 = (Elf32_External_Conflict *)
16145 get_data (NULL, filedata, conflicts_offset, conflictsno,
16146 sizeof (* econf32), _("conflict"));
16150 for (cnt = 0; cnt < conflictsno; ++cnt)
16151 iconf[cnt] = BYTE_GET (econf32[cnt]);
16157 Elf64_External_Conflict * econf64;
16159 econf64 = (Elf64_External_Conflict *)
16160 get_data (NULL, filedata, conflicts_offset, conflictsno,
16161 sizeof (* econf64), _("conflict"));
16165 for (cnt = 0; cnt < conflictsno; ++cnt)
16166 iconf[cnt] = BYTE_GET (econf64[cnt]);
16171 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16172 "\nSection '.conflict' contains %lu entries:\n",
16173 (unsigned long) conflictsno),
16174 (unsigned long) conflictsno);
16175 puts (_(" Num: Index Value Name"));
16177 for (cnt = 0; cnt < conflictsno; ++cnt)
16179 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16181 if (iconf[cnt] >= num_dynamic_syms)
16182 printf (_("<corrupt symbol index>"));
16185 Elf_Internal_Sym * psym;
16187 psym = & dynamic_symbols[iconf[cnt]];
16188 print_vma (psym->st_value, FULL_HEX);
16190 if (VALID_DYNAMIC_NAME (psym->st_name))
16191 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16193 printf (_("<corrupt: %14ld>"), psym->st_name);
16201 if (pltgot != 0 && local_gotno != 0)
16203 bfd_vma ent, local_end, global_end;
16205 unsigned char * data;
16206 unsigned char * data_end;
16210 addr_size = (is_32bit_elf ? 4 : 8);
16211 local_end = pltgot + local_gotno * addr_size;
16213 /* PR binutils/17533 file: 012-111227-0.004 */
16214 if (symtabno < gotsym)
16216 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16217 (unsigned long) gotsym, (unsigned long) symtabno);
16221 global_end = local_end + (symtabno - gotsym) * addr_size;
16222 /* PR 17531: file: 54c91a34. */
16223 if (global_end < local_end)
16225 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16229 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16230 data = (unsigned char *) get_data (NULL, filedata, offset,
16231 global_end - pltgot, 1,
16232 _("Global Offset Table data"));
16233 /* PR 12855: Null data is handled gracefully throughout. */
16234 data_end = data + (global_end - pltgot);
16236 printf (_("\nPrimary GOT:\n"));
16237 printf (_(" Canonical gp value: "));
16238 print_vma (pltgot + 0x7ff0, LONG_HEX);
16241 printf (_(" Reserved entries:\n"));
16242 printf (_(" %*s %10s %*s Purpose\n"),
16243 addr_size * 2, _("Address"), _("Access"),
16244 addr_size * 2, _("Initial"));
16245 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16246 printf (_(" Lazy resolver\n"));
16247 if (ent == (bfd_vma) -1)
16248 goto got_print_fail;
16250 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16251 This entry will be used by some runtime loaders, to store the
16252 module pointer. Otherwise this is an ordinary local entry.
16253 PR 21344: Check for the entry being fully available before
16256 && data + ent - pltgot + addr_size <= data_end
16257 && (byte_get (data + ent - pltgot, addr_size)
16258 >> (addr_size * 8 - 1)) != 0)
16260 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16261 printf (_(" Module pointer (GNU extension)\n"));
16262 if (ent == (bfd_vma) -1)
16263 goto got_print_fail;
16267 if (data != NULL && ent < local_end)
16269 printf (_(" Local entries:\n"));
16270 printf (" %*s %10s %*s\n",
16271 addr_size * 2, _("Address"), _("Access"),
16272 addr_size * 2, _("Initial"));
16273 while (ent < local_end)
16275 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16277 if (ent == (bfd_vma) -1)
16278 goto got_print_fail;
16283 if (data != NULL && gotsym < symtabno)
16287 printf (_(" Global entries:\n"));
16288 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16289 addr_size * 2, _("Address"),
16291 addr_size * 2, _("Initial"),
16292 addr_size * 2, _("Sym.Val."),
16294 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16295 _("Ndx"), _("Name"));
16297 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16299 for (i = gotsym; i < symtabno; i++)
16301 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16304 if (dynamic_symbols == NULL)
16305 printf (_("<no dynamic symbols>"));
16306 else if (i < num_dynamic_syms)
16308 Elf_Internal_Sym * psym = dynamic_symbols + i;
16310 print_vma (psym->st_value, LONG_HEX);
16311 printf (" %-7s %3s ",
16312 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16313 get_symbol_index_type (filedata, psym->st_shndx));
16315 if (VALID_DYNAMIC_NAME (psym->st_name))
16316 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16318 printf (_("<corrupt: %14ld>"), psym->st_name);
16321 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16322 (unsigned long) i);
16325 if (ent == (bfd_vma) -1)
16336 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16339 size_t offset, rel_offset;
16340 unsigned long count, i;
16341 unsigned char * data;
16342 int addr_size, sym_width;
16343 Elf_Internal_Rela * rels;
16345 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16346 if (pltrel == DT_RELA)
16348 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16353 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16358 addr_size = (is_32bit_elf ? 4 : 8);
16359 end = mips_pltgot + (2 + count) * addr_size;
16361 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16362 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16363 1, _("Procedure Linkage Table data"));
16367 printf ("\nPLT GOT:\n\n");
16368 printf (_(" Reserved entries:\n"));
16369 printf (_(" %*s %*s Purpose\n"),
16370 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16371 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16372 printf (_(" PLT lazy resolver\n"));
16373 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16374 printf (_(" Module pointer\n"));
16377 printf (_(" Entries:\n"));
16378 printf (" %*s %*s %*s %-7s %3s %s\n",
16379 addr_size * 2, _("Address"),
16380 addr_size * 2, _("Initial"),
16381 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16382 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16383 for (i = 0; i < count; i++)
16385 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16387 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16390 if (idx >= num_dynamic_syms)
16391 printf (_("<corrupt symbol index: %lu>"), idx);
16394 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16396 print_vma (psym->st_value, LONG_HEX);
16397 printf (" %-7s %3s ",
16398 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16399 get_symbol_index_type (filedata, psym->st_shndx));
16400 if (VALID_DYNAMIC_NAME (psym->st_name))
16401 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16403 printf (_("<corrupt: %14ld>"), psym->st_name);
16418 process_nds32_specific (Filedata * filedata)
16420 Elf_Internal_Shdr *sect = NULL;
16422 sect = find_section (filedata, ".nds32_e_flags");
16425 unsigned int *flag;
16427 printf ("\nNDS32 elf flags section:\n");
16428 flag = get_data (NULL, filedata, sect->sh_offset, 1,
16429 sect->sh_size, _("NDS32 elf flags section"));
16434 switch ((*flag) & 0x3)
16437 printf ("(VEC_SIZE):\tNo entry.\n");
16440 printf ("(VEC_SIZE):\t4 bytes\n");
16443 printf ("(VEC_SIZE):\t16 bytes\n");
16446 printf ("(VEC_SIZE):\treserved\n");
16455 process_gnu_liblist (Filedata * filedata)
16457 Elf_Internal_Shdr * section;
16458 Elf_Internal_Shdr * string_sec;
16459 Elf32_External_Lib * elib;
16461 size_t strtab_size;
16463 unsigned long num_liblist;
16465 bfd_boolean res = TRUE;
16470 for (i = 0, section = filedata->section_headers;
16471 i < filedata->file_header.e_shnum;
16474 switch (section->sh_type)
16476 case SHT_GNU_LIBLIST:
16477 if (section->sh_link >= filedata->file_header.e_shnum)
16480 elib = (Elf32_External_Lib *)
16481 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16482 _("liblist section data"));
16490 string_sec = filedata->section_headers + section->sh_link;
16491 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16492 string_sec->sh_size,
16493 _("liblist string table"));
16495 || section->sh_entsize != sizeof (Elf32_External_Lib))
16502 strtab_size = string_sec->sh_size;
16504 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16505 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16506 "\nLibrary list section '%s' contains %lu entries:\n",
16508 printable_section_name (filedata, section),
16511 puts (_(" Library Time Stamp Checksum Version Flags"));
16513 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16521 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16522 atime = BYTE_GET (elib[cnt].l_time_stamp);
16523 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16524 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16525 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16527 tmp = gmtime (&atime);
16528 snprintf (timebuf, sizeof (timebuf),
16529 "%04u-%02u-%02uT%02u:%02u:%02u",
16530 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16531 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16533 printf ("%3lu: ", (unsigned long) cnt);
16535 printf ("%-20s", liblist.l_name < strtab_size
16536 ? strtab + liblist.l_name : _("<corrupt>"));
16538 printf ("%-20.20s", liblist.l_name < strtab_size
16539 ? strtab + liblist.l_name : _("<corrupt>"));
16540 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16541 liblist.l_version, liblist.l_flags);
16552 static const char *
16553 get_note_type (Filedata * filedata, unsigned e_type)
16555 static char buff[64];
16557 if (filedata->file_header.e_type == ET_CORE)
16561 return _("NT_AUXV (auxiliary vector)");
16563 return _("NT_PRSTATUS (prstatus structure)");
16565 return _("NT_FPREGSET (floating point registers)");
16567 return _("NT_PRPSINFO (prpsinfo structure)");
16568 case NT_TASKSTRUCT:
16569 return _("NT_TASKSTRUCT (task structure)");
16571 return _("NT_PRXFPREG (user_xfpregs structure)");
16573 return _("NT_PPC_VMX (ppc Altivec registers)");
16575 return _("NT_PPC_VSX (ppc VSX registers)");
16577 return _("NT_PPC_TAR (ppc TAR register)");
16579 return _("NT_PPC_PPR (ppc PPR register)");
16581 return _("NT_PPC_DSCR (ppc DSCR register)");
16583 return _("NT_PPC_EBB (ppc EBB registers)");
16585 return _("NT_PPC_PMU (ppc PMU registers)");
16586 case NT_PPC_TM_CGPR:
16587 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16588 case NT_PPC_TM_CFPR:
16589 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16590 case NT_PPC_TM_CVMX:
16591 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16592 case NT_PPC_TM_CVSX:
16593 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16594 case NT_PPC_TM_SPR:
16595 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16596 case NT_PPC_TM_CTAR:
16597 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16598 case NT_PPC_TM_CPPR:
16599 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16600 case NT_PPC_TM_CDSCR:
16601 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16603 return _("NT_386_TLS (x86 TLS information)");
16604 case NT_386_IOPERM:
16605 return _("NT_386_IOPERM (x86 I/O permissions)");
16606 case NT_X86_XSTATE:
16607 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16608 case NT_S390_HIGH_GPRS:
16609 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16610 case NT_S390_TIMER:
16611 return _("NT_S390_TIMER (s390 timer register)");
16612 case NT_S390_TODCMP:
16613 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16614 case NT_S390_TODPREG:
16615 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16617 return _("NT_S390_CTRS (s390 control registers)");
16618 case NT_S390_PREFIX:
16619 return _("NT_S390_PREFIX (s390 prefix register)");
16620 case NT_S390_LAST_BREAK:
16621 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16622 case NT_S390_SYSTEM_CALL:
16623 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16625 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16626 case NT_S390_VXRS_LOW:
16627 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16628 case NT_S390_VXRS_HIGH:
16629 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16630 case NT_S390_GS_CB:
16631 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16632 case NT_S390_GS_BC:
16633 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16635 return _("NT_ARM_VFP (arm VFP registers)");
16637 return _("NT_ARM_TLS (AArch TLS registers)");
16638 case NT_ARM_HW_BREAK:
16639 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16640 case NT_ARM_HW_WATCH:
16641 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16643 return _("NT_PSTATUS (pstatus structure)");
16645 return _("NT_FPREGS (floating point registers)");
16647 return _("NT_PSINFO (psinfo structure)");
16649 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16651 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16652 case NT_WIN32PSTATUS:
16653 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16655 return _("NT_SIGINFO (siginfo_t data)");
16657 return _("NT_FILE (mapped files)");
16665 return _("NT_VERSION (version)");
16667 return _("NT_ARCH (architecture)");
16668 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16670 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16676 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16681 print_core_note (Elf_Internal_Note *pnote)
16683 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16684 bfd_vma count, page_size;
16685 unsigned char *descdata, *filenames, *descend;
16687 if (pnote->type != NT_FILE)
16697 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16698 /* Still "successful". */
16703 if (pnote->descsz < 2 * addr_size)
16705 error (_(" Malformed note - too short for header\n"));
16709 descdata = (unsigned char *) pnote->descdata;
16710 descend = descdata + pnote->descsz;
16712 if (descdata[pnote->descsz - 1] != '\0')
16714 error (_(" Malformed note - does not end with \\0\n"));
16718 count = byte_get (descdata, addr_size);
16719 descdata += addr_size;
16721 page_size = byte_get (descdata, addr_size);
16722 descdata += addr_size;
16724 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16725 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16727 error (_(" Malformed note - too short for supplied file count\n"));
16731 printf (_(" Page size: "));
16732 print_vma (page_size, DEC);
16735 printf (_(" %*s%*s%*s\n"),
16736 (int) (2 + 2 * addr_size), _("Start"),
16737 (int) (4 + 2 * addr_size), _("End"),
16738 (int) (4 + 2 * addr_size), _("Page Offset"));
16739 filenames = descdata + count * 3 * addr_size;
16740 while (count-- > 0)
16742 bfd_vma start, end, file_ofs;
16744 if (filenames == descend)
16746 error (_(" Malformed note - filenames end too early\n"));
16750 start = byte_get (descdata, addr_size);
16751 descdata += addr_size;
16752 end = byte_get (descdata, addr_size);
16753 descdata += addr_size;
16754 file_ofs = byte_get (descdata, addr_size);
16755 descdata += addr_size;
16758 print_vma (start, FULL_HEX);
16760 print_vma (end, FULL_HEX);
16762 print_vma (file_ofs, FULL_HEX);
16763 printf ("\n %s\n", filenames);
16765 filenames += 1 + strlen ((char *) filenames);
16771 static const char *
16772 get_gnu_elf_note_type (unsigned e_type)
16774 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16777 case NT_GNU_ABI_TAG:
16778 return _("NT_GNU_ABI_TAG (ABI version tag)");
16780 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16781 case NT_GNU_BUILD_ID:
16782 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16783 case NT_GNU_GOLD_VERSION:
16784 return _("NT_GNU_GOLD_VERSION (gold version)");
16785 case NT_GNU_PROPERTY_TYPE_0:
16786 return _("NT_GNU_PROPERTY_TYPE_0");
16787 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16788 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16789 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16790 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16793 static char buff[64];
16795 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16802 decode_x86_isa (unsigned int bitmask)
16806 unsigned int bit = bitmask & (- bitmask);
16811 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16812 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16813 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16814 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16815 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16816 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16817 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16818 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16819 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16820 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16821 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16822 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16823 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16824 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16825 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16826 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16827 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16828 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16829 default: printf (_("<unknown: %x>"), bit); break;
16837 decode_x86_feature (unsigned int type, unsigned int bitmask)
16841 unsigned int bit = bitmask & (- bitmask);
16846 case GNU_PROPERTY_X86_FEATURE_1_IBT:
16849 case GNU_PROPERTY_X86_FEATURE_1_AND:
16853 /* This should never happen. */
16857 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16860 case GNU_PROPERTY_X86_FEATURE_1_AND:
16864 /* This should never happen. */
16869 printf (_("<unknown: %x>"), bit);
16878 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16880 unsigned char * ptr = (unsigned char *) pnote->descdata;
16881 unsigned char * ptr_end = ptr + pnote->descsz;
16882 unsigned int size = is_32bit_elf ? 4 : 8;
16884 printf (_(" Properties: "));
16886 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16888 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16892 while (ptr < ptr_end)
16896 unsigned int datasz;
16898 if ((size_t) (ptr_end - ptr) < 8)
16900 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16904 type = byte_get (ptr, 4);
16905 datasz = byte_get (ptr + 4, 4);
16909 if (datasz > (size_t) (ptr_end - ptr))
16911 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16916 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16918 if (filedata->file_header.e_machine == EM_X86_64
16919 || filedata->file_header.e_machine == EM_IAMCU
16920 || filedata->file_header.e_machine == EM_386)
16924 case GNU_PROPERTY_X86_ISA_1_USED:
16925 printf ("x86 ISA used: ");
16927 printf (_("<corrupt length: %#x> "), datasz);
16929 decode_x86_isa (byte_get (ptr, 4));
16932 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16933 printf ("x86 ISA needed: ");
16935 printf (_("<corrupt length: %#x> "), datasz);
16937 decode_x86_isa (byte_get (ptr, 4));
16940 case GNU_PROPERTY_X86_FEATURE_1_AND:
16941 printf ("x86 feature: ");
16943 printf (_("<corrupt length: %#x> "), datasz);
16945 decode_x86_feature (type, byte_get (ptr, 4));
16957 case GNU_PROPERTY_STACK_SIZE:
16958 printf (_("stack size: "));
16959 if (datasz != size)
16960 printf (_("<corrupt length: %#x> "), datasz);
16962 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16965 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16966 printf ("no copy on protected ");
16968 printf (_("<corrupt length: %#x> "), datasz);
16976 if (type < GNU_PROPERTY_LOPROC)
16977 printf (_("<unknown type %#x data: "), type);
16978 else if (type < GNU_PROPERTY_LOUSER)
16979 printf (_("<procesor-specific type %#x data: "), type);
16981 printf (_("<application-specific type %#x data: "), type);
16982 for (j = 0; j < datasz; ++j)
16983 printf ("%02x ", ptr[j] & 0xff);
16987 ptr += ((datasz + (size - 1)) & ~ (size - 1));
16988 if (ptr == ptr_end)
17001 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17003 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17004 switch (pnote->type)
17006 case NT_GNU_BUILD_ID:
17010 printf (_(" Build ID: "));
17011 for (i = 0; i < pnote->descsz; ++i)
17012 printf ("%02x", pnote->descdata[i] & 0xff);
17017 case NT_GNU_ABI_TAG:
17019 unsigned long os, major, minor, subminor;
17020 const char *osname;
17022 /* PR 17531: file: 030-599401-0.004. */
17023 if (pnote->descsz < 16)
17025 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17029 os = byte_get ((unsigned char *) pnote->descdata, 4);
17030 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17031 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17032 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17036 case GNU_ABI_TAG_LINUX:
17039 case GNU_ABI_TAG_HURD:
17042 case GNU_ABI_TAG_SOLARIS:
17043 osname = "Solaris";
17045 case GNU_ABI_TAG_FREEBSD:
17046 osname = "FreeBSD";
17048 case GNU_ABI_TAG_NETBSD:
17051 case GNU_ABI_TAG_SYLLABLE:
17052 osname = "Syllable";
17054 case GNU_ABI_TAG_NACL:
17058 osname = "Unknown";
17062 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17063 major, minor, subminor);
17067 case NT_GNU_GOLD_VERSION:
17071 printf (_(" Version: "));
17072 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17073 printf ("%c", pnote->descdata[i]);
17080 unsigned long num_entries, mask;
17082 /* Hardware capabilities information. Word 0 is the number of entries.
17083 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17084 is a series of entries, where each entry is a single byte followed
17085 by a nul terminated string. The byte gives the bit number to test
17086 if enabled in the bitmask. */
17087 printf (_(" Hardware Capabilities: "));
17088 if (pnote->descsz < 8)
17090 error (_("<corrupt GNU_HWCAP>\n"));
17093 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17094 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17095 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17096 /* FIXME: Add code to display the entries... */
17100 case NT_GNU_PROPERTY_TYPE_0:
17101 print_gnu_property_note (filedata, pnote);
17105 /* Handle unrecognised types. An error message should have already been
17106 created by get_gnu_elf_note_type(), so all that we need to do is to
17107 display the data. */
17111 printf (_(" Description data: "));
17112 for (i = 0; i < pnote->descsz; ++i)
17113 printf ("%02x ", pnote->descdata[i] & 0xff);
17122 static const char *
17123 get_v850_elf_note_type (enum v850_notes n_type)
17125 static char buff[64];
17129 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17130 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17131 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17132 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17133 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17134 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17136 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17142 print_v850_note (Elf_Internal_Note * pnote)
17146 if (pnote->descsz != 4)
17149 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17153 printf (_("not set\n"));
17157 switch (pnote->type)
17159 case V850_NOTE_ALIGNMENT:
17162 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17163 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17167 case V850_NOTE_DATA_SIZE:
17170 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17171 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17175 case V850_NOTE_FPU_INFO:
17178 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17179 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17183 case V850_NOTE_MMU_INFO:
17184 case V850_NOTE_CACHE_INFO:
17185 case V850_NOTE_SIMD_INFO:
17186 if (val == EF_RH850_SIMD)
17188 printf (_("yes\n"));
17194 /* An 'unknown note type' message will already have been displayed. */
17198 printf (_("unknown value: %x\n"), val);
17203 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17205 unsigned int version;
17207 switch (pnote->type)
17209 case NT_NETBSD_IDENT:
17210 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17211 if ((version / 10000) % 100)
17212 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17213 version, version / 100000000, (version / 1000000) % 100,
17214 (version / 10000) % 100 > 26 ? "Z" : "",
17215 'A' + (version / 10000) % 26);
17217 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17218 version, version / 100000000, (version / 1000000) % 100,
17219 (version / 100) % 100);
17222 case NT_NETBSD_MARCH:
17223 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17228 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17234 static const char *
17235 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17239 case NT_FREEBSD_THRMISC:
17240 return _("NT_THRMISC (thrmisc structure)");
17241 case NT_FREEBSD_PROCSTAT_PROC:
17242 return _("NT_PROCSTAT_PROC (proc data)");
17243 case NT_FREEBSD_PROCSTAT_FILES:
17244 return _("NT_PROCSTAT_FILES (files data)");
17245 case NT_FREEBSD_PROCSTAT_VMMAP:
17246 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17247 case NT_FREEBSD_PROCSTAT_GROUPS:
17248 return _("NT_PROCSTAT_GROUPS (groups data)");
17249 case NT_FREEBSD_PROCSTAT_UMASK:
17250 return _("NT_PROCSTAT_UMASK (umask data)");
17251 case NT_FREEBSD_PROCSTAT_RLIMIT:
17252 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17253 case NT_FREEBSD_PROCSTAT_OSREL:
17254 return _("NT_PROCSTAT_OSREL (osreldate data)");
17255 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17256 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17257 case NT_FREEBSD_PROCSTAT_AUXV:
17258 return _("NT_PROCSTAT_AUXV (auxv data)");
17259 case NT_FREEBSD_PTLWPINFO:
17260 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17262 return get_note_type (filedata, e_type);
17265 static const char *
17266 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17268 static char buff[64];
17270 if (e_type == NT_NETBSDCORE_PROCINFO)
17271 return _("NetBSD procinfo structure");
17273 /* As of Jan 2002 there are no other machine-independent notes
17274 defined for NetBSD core files. If the note type is less
17275 than the start of the machine-dependent note types, we don't
17278 if (e_type < NT_NETBSDCORE_FIRSTMACH)
17280 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17284 switch (filedata->file_header.e_machine)
17286 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17287 and PT_GETFPREGS == mach+2. */
17292 case EM_SPARC32PLUS:
17296 case NT_NETBSDCORE_FIRSTMACH + 0:
17297 return _("PT_GETREGS (reg structure)");
17298 case NT_NETBSDCORE_FIRSTMACH + 2:
17299 return _("PT_GETFPREGS (fpreg structure)");
17305 /* On all other arch's, PT_GETREGS == mach+1 and
17306 PT_GETFPREGS == mach+3. */
17310 case NT_NETBSDCORE_FIRSTMACH + 1:
17311 return _("PT_GETREGS (reg structure)");
17312 case NT_NETBSDCORE_FIRSTMACH + 3:
17313 return _("PT_GETFPREGS (fpreg structure)");
17319 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17320 e_type - NT_NETBSDCORE_FIRSTMACH);
17324 static const char *
17325 get_stapsdt_note_type (unsigned e_type)
17327 static char buff[64];
17332 return _("NT_STAPSDT (SystemTap probe descriptors)");
17338 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17343 print_stapsdt_note (Elf_Internal_Note *pnote)
17345 int addr_size = is_32bit_elf ? 4 : 8;
17346 char *data = pnote->descdata;
17347 char *data_end = pnote->descdata + pnote->descsz;
17348 bfd_vma pc, base_addr, semaphore;
17349 char *provider, *probe, *arg_fmt;
17351 pc = byte_get ((unsigned char *) data, addr_size);
17353 base_addr = byte_get ((unsigned char *) data, addr_size);
17355 semaphore = byte_get ((unsigned char *) data, addr_size);
17359 data += strlen (data) + 1;
17361 data += strlen (data) + 1;
17363 data += strlen (data) + 1;
17365 printf (_(" Provider: %s\n"), provider);
17366 printf (_(" Name: %s\n"), probe);
17367 printf (_(" Location: "));
17368 print_vma (pc, FULL_HEX);
17369 printf (_(", Base: "));
17370 print_vma (base_addr, FULL_HEX);
17371 printf (_(", Semaphore: "));
17372 print_vma (semaphore, FULL_HEX);
17374 printf (_(" Arguments: %s\n"), arg_fmt);
17376 return data == data_end;
17379 static const char *
17380 get_ia64_vms_note_type (unsigned e_type)
17382 static char buff[64];
17387 return _("NT_VMS_MHD (module header)");
17389 return _("NT_VMS_LNM (language name)");
17391 return _("NT_VMS_SRC (source files)");
17393 return "NT_VMS_TITLE";
17395 return _("NT_VMS_EIDC (consistency check)");
17396 case NT_VMS_FPMODE:
17397 return _("NT_VMS_FPMODE (FP mode)");
17398 case NT_VMS_LINKTIME:
17399 return "NT_VMS_LINKTIME";
17400 case NT_VMS_IMGNAM:
17401 return _("NT_VMS_IMGNAM (image name)");
17403 return _("NT_VMS_IMGID (image id)");
17404 case NT_VMS_LINKID:
17405 return _("NT_VMS_LINKID (link id)");
17406 case NT_VMS_IMGBID:
17407 return _("NT_VMS_IMGBID (build id)");
17408 case NT_VMS_GSTNAM:
17409 return _("NT_VMS_GSTNAM (sym table name)");
17410 case NT_VMS_ORIG_DYN:
17411 return "NT_VMS_ORIG_DYN";
17412 case NT_VMS_PATCHTIME:
17413 return "NT_VMS_PATCHTIME";
17415 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17421 print_ia64_vms_note (Elf_Internal_Note * pnote)
17423 switch (pnote->type)
17426 if (pnote->descsz > 36)
17428 size_t l = strlen (pnote->descdata + 34);
17429 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17430 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17431 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17432 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17435 printf (_(" Invalid size\n"));
17438 printf (_(" Language: %s\n"), pnote->descdata);
17441 case NT_VMS_FPMODE:
17442 printf (_(" Floating Point mode: "));
17443 printf ("0x%016" BFD_VMA_FMT "x\n",
17444 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17446 case NT_VMS_LINKTIME:
17447 printf (_(" Link time: "));
17449 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17452 case NT_VMS_PATCHTIME:
17453 printf (_(" Patch time: "));
17455 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17458 case NT_VMS_ORIG_DYN:
17459 printf (_(" Major id: %u, minor id: %u\n"),
17460 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17461 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17462 printf (_(" Last modified : "));
17464 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17465 printf (_("\n Link flags : "));
17466 printf ("0x%016" BFD_VMA_FMT "x\n",
17467 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17468 printf (_(" Header flags: 0x%08x\n"),
17469 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17470 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17473 case NT_VMS_IMGNAM:
17474 printf (_(" Image name: %s\n"), pnote->descdata);
17476 case NT_VMS_GSTNAM:
17477 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17480 printf (_(" Image id: %s\n"), pnote->descdata);
17482 case NT_VMS_LINKID:
17483 printf (_(" Linker id: %s\n"), pnote->descdata);
17491 /* Find the symbol associated with a build attribute that is attached
17492 to address OFFSET. If PNAME is non-NULL then store the name of
17493 the symbol (if found) in the provided pointer, Returns NULL if a
17494 symbol could not be found. */
17496 static Elf_Internal_Sym *
17497 get_symbol_for_build_attribute (Filedata * filedata,
17498 unsigned long offset,
17499 bfd_boolean is_open_attr,
17500 const char ** pname)
17502 static Filedata * saved_filedata = NULL;
17503 static char * strtab;
17504 static unsigned long strtablen;
17505 static Elf_Internal_Sym * symtab;
17506 static unsigned long nsyms;
17507 Elf_Internal_Sym * saved_sym = NULL;
17508 Elf_Internal_Sym * sym;
17510 if (filedata->section_headers != NULL
17511 && (saved_filedata == NULL || filedata != saved_filedata))
17513 Elf_Internal_Shdr * symsec;
17515 /* Load the symbol and string sections. */
17516 for (symsec = filedata->section_headers;
17517 symsec < filedata->section_headers + filedata->file_header.e_shnum;
17520 if (symsec->sh_type == SHT_SYMTAB)
17522 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17524 if (symsec->sh_link < filedata->file_header.e_shnum)
17526 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17528 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17529 1, strtab_sec->sh_size,
17530 _("string table"));
17531 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17535 saved_filedata = filedata;
17538 if (symtab == NULL || strtab == NULL)
17541 /* Find a symbol whose value matches offset. */
17542 for (sym = symtab; sym < symtab + nsyms; sym ++)
17543 if (sym->st_value == offset)
17545 if (sym->st_name >= strtablen)
17546 /* Huh ? This should not happen. */
17549 if (strtab[sym->st_name] == 0)
17552 /* The AArch64 and ARM architectures define mapping symbols
17553 (eg $d, $x, $t) which we want to ignore. */
17554 if (strtab[sym->st_name] == '$'
17555 && strtab[sym->st_name + 1] != 0
17556 && strtab[sym->st_name + 2] == 0)
17561 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17562 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17563 FUNC symbols entirely. */
17564 switch (ELF_ST_TYPE (sym->st_info))
17571 /* If the symbol has a size associated
17572 with it then we can stop searching. */
17573 sym = symtab + nsyms;
17578 /* Ignore function symbols. */
17585 switch (ELF_ST_BIND (sym->st_info))
17588 if (saved_sym == NULL
17589 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17594 if (saved_sym == NULL)
17604 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17612 if (saved_sym && pname)
17613 * pname = strtab + saved_sym->st_name;
17619 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
17620 Filedata * filedata)
17622 static unsigned long global_offset = 0;
17623 static unsigned long global_end = 0;
17624 static unsigned long func_offset = 0;
17625 static unsigned long func_end = 0;
17627 Elf_Internal_Sym * sym;
17629 unsigned long start;
17631 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17633 switch (pnote->descsz)
17636 /* A zero-length description means that the range of
17637 the previous note of the same type should be used. */
17640 if (global_end > global_offset)
17641 printf (_(" Applies to region from %#lx to %#lx\n"),
17642 global_offset, global_end);
17644 printf (_(" Applies to region from %#lx\n"), global_offset);
17648 if (func_end > func_offset)
17649 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17651 printf (_(" Applies to region from %#lx\n"), func_offset);
17656 start = byte_get ((unsigned char *) pnote->descdata, 4);
17663 /* FIXME: We should check that version 3+ notes are being used here... */
17664 start = byte_get ((unsigned char *) pnote->descdata, 4);
17665 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17669 start = byte_get ((unsigned char *) pnote->descdata, 8);
17675 start = byte_get ((unsigned char *) pnote->descdata, 8);
17676 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17680 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
17681 printf (_(" <invalid descsz>"));
17686 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17687 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17688 in order to avoid them being confused with the start address of the
17689 first function in the file... */
17690 if (sym == NULL && is_open_attr)
17691 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17694 if (end == 0 && sym != NULL && sym->st_size > 0)
17695 end = start + sym->st_size;
17699 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17700 if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17701 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17702 global_end + 1, start - 1);
17704 printf (_(" Applies to region from %#lx"), start);
17705 global_offset = start;
17709 printf (_(" to %#lx"), end);
17715 printf (_(" Applies to region from %#lx"), start);
17716 func_offset = start;
17720 printf (_(" to %#lx"), end);
17726 printf (_(" (%s)"), name);
17733 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17735 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17736 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17737 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17739 char name_attribute;
17740 const char * expected_types;
17741 const char * name = pnote->namedata;
17745 if (name == NULL || pnote->namesz < 2)
17747 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17748 print_symbol (-20, _(" <corrupt name>"));
17757 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17758 if (name[0] == 'G' && name[1] == 'A')
17760 if (pnote->namesz < 4)
17762 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17763 print_symbol (-20, _(" <corrupt name>"));
17772 switch ((name_type = * name))
17774 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17775 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17776 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17777 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17778 printf ("%c", * name);
17782 error (_("unrecognised attribute type in name field: %d\n"), name_type);
17783 print_symbol (-20, _("<unknown name type>"));
17790 switch ((name_attribute = * name))
17792 case GNU_BUILD_ATTRIBUTE_VERSION:
17793 text = _("<version>");
17794 expected_types = string_expected;
17797 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17798 text = _("<stack prot>");
17799 expected_types = "!+*";
17802 case GNU_BUILD_ATTRIBUTE_RELRO:
17803 text = _("<relro>");
17804 expected_types = bool_expected;
17807 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17808 text = _("<stack size>");
17809 expected_types = number_expected;
17812 case GNU_BUILD_ATTRIBUTE_TOOL:
17813 text = _("<tool>");
17814 expected_types = string_expected;
17817 case GNU_BUILD_ATTRIBUTE_ABI:
17819 expected_types = "$*";
17822 case GNU_BUILD_ATTRIBUTE_PIC:
17824 expected_types = number_expected;
17827 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17828 text = _("<short enum>");
17829 expected_types = bool_expected;
17833 if (ISPRINT (* name))
17835 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17837 if (len > left && ! do_wide)
17839 printf ("%.*s:", len, name);
17845 static char tmpbuf [128];
17847 error (_("unrecognised byte in name field: %d\n"), * name);
17848 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17852 expected_types = "*$!+";
17857 left -= printf ("%s", text);
17859 if (strchr (expected_types, name_type) == NULL)
17860 warn (_("attribute does not have an expected type (%c)\n"), name_type);
17862 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17864 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17865 (unsigned long) pnote->namesz,
17866 (long) (name - pnote->namedata));
17870 if (left < 1 && ! do_wide)
17875 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17877 unsigned int bytes;
17878 unsigned long long val = 0;
17879 unsigned int shift = 0;
17880 char * decoded = NULL;
17882 bytes = pnote->namesz - (name - pnote->namedata);
17884 /* The -1 is because the name field is always 0 terminated, and we
17885 want to be able to ensure that the shift in the while loop below
17886 will not overflow. */
17889 if (bytes > sizeof (val))
17891 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17893 bytes = sizeof (val);
17895 /* We do not bother to warn if bytes == 0 as this can
17896 happen with some early versions of the gcc plugin. */
17900 unsigned long byte = (* name ++) & 0xff;
17902 val |= byte << shift;
17906 switch (name_attribute)
17908 case GNU_BUILD_ATTRIBUTE_PIC:
17911 case 0: decoded = "static"; break;
17912 case 1: decoded = "pic"; break;
17913 case 2: decoded = "PIC"; break;
17914 case 3: decoded = "pie"; break;
17915 case 4: decoded = "PIE"; break;
17919 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17922 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17923 case 0: decoded = "off"; break;
17924 case 1: decoded = "on"; break;
17925 case 2: decoded = "all"; break;
17926 case 3: decoded = "strong"; break;
17927 case 4: decoded = "explicit"; break;
17935 if (decoded != NULL)
17937 print_symbol (-left, decoded);
17948 left -= printf ("0x%llx", val);
17950 left -= printf ("0x%-.*llx", left, val);
17954 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17955 left -= print_symbol (- left, name);
17957 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17958 left -= print_symbol (- left, "true");
17960 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17961 left -= print_symbol (- left, "false");
17965 if (do_wide && left > 0)
17966 printf ("%-*s", left, " ");
17971 /* Note that by the ELF standard, the name field is already null byte
17972 terminated, and namesz includes the terminating null byte.
17973 I.E. the value of namesz for the name "FSF" is 4.
17975 If the value of namesz is zero, there is no name present. */
17978 process_note (Elf_Internal_Note * pnote,
17979 Filedata * filedata)
17981 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17984 if (pnote->namesz == 0)
17985 /* If there is no note name, then use the default set of
17986 note type strings. */
17987 nt = get_note_type (filedata, pnote->type);
17989 else if (const_strneq (pnote->namedata, "GNU"))
17990 /* GNU-specific object file notes. */
17991 nt = get_gnu_elf_note_type (pnote->type);
17993 else if (const_strneq (pnote->namedata, "FreeBSD"))
17994 /* FreeBSD-specific core file notes. */
17995 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17997 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17998 /* NetBSD-specific core file notes. */
17999 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18001 else if (const_strneq (pnote->namedata, "NetBSD"))
18002 /* NetBSD-specific core file notes. */
18003 return process_netbsd_elf_note (pnote);
18005 else if (strneq (pnote->namedata, "SPU/", 4))
18007 /* SPU-specific core file notes. */
18008 nt = pnote->namedata + 4;
18012 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18013 /* VMS/ia64-specific file notes. */
18014 nt = get_ia64_vms_note_type (pnote->type);
18016 else if (const_strneq (pnote->namedata, "stapsdt"))
18017 nt = get_stapsdt_note_type (pnote->type);
18020 /* Don't recognize this note name; just use the default set of
18021 note type strings. */
18022 nt = get_note_type (filedata, pnote->type);
18026 if (((const_strneq (pnote->namedata, "GA")
18027 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18028 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18029 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18030 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18031 print_gnu_build_attribute_name (pnote);
18033 print_symbol (-20, name);
18036 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18038 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18040 if (const_strneq (pnote->namedata, "IPF/VMS"))
18041 return print_ia64_vms_note (pnote);
18042 else if (const_strneq (pnote->namedata, "GNU"))
18043 return print_gnu_note (filedata, pnote);
18044 else if (const_strneq (pnote->namedata, "stapsdt"))
18045 return print_stapsdt_note (pnote);
18046 else if (const_strneq (pnote->namedata, "CORE"))
18047 return print_core_note (pnote);
18048 else if (((const_strneq (pnote->namedata, "GA")
18049 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18050 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18051 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18052 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18053 return print_gnu_build_attribute_description (pnote, filedata);
18059 printf (_(" description data: "));
18060 for (i = 0; i < pnote->descsz; i++)
18061 printf ("%02x ", pnote->descdata[i]);
18073 process_notes_at (Filedata * filedata,
18074 Elf_Internal_Shdr * section,
18079 Elf_External_Note * pnotes;
18080 Elf_External_Note * external;
18082 bfd_boolean res = TRUE;
18089 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18092 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18097 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18100 if (pnotes == NULL)
18106 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18108 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18109 (unsigned long) offset, (unsigned long) length);
18111 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18112 specifies that notes should be aligned to 4 bytes in 32-bit
18113 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18114 we also support 4 byte alignment in 64-bit objects. If section
18115 alignment is less than 4, we treate alignment as 4 bytes. */
18118 else if (align != 4 && align != 8)
18120 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18125 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18127 end = (char *) pnotes + length;
18128 while ((char *) external < end)
18130 Elf_Internal_Note inote;
18133 char * temp = NULL;
18134 size_t data_remaining = end - (char *) external;
18136 if (!is_ia64_vms (filedata))
18138 /* PR binutils/15191
18139 Make sure that there is enough data to read. */
18140 min_notesz = offsetof (Elf_External_Note, name);
18141 if (data_remaining < min_notesz)
18143 warn (ngettext ("Corrupt note: only %ld byte remains, "
18144 "not enough for a full note\n",
18145 "Corrupt note: only %ld bytes remain, "
18146 "not enough for a full note\n",
18148 (long) data_remaining);
18151 data_remaining -= min_notesz;
18153 inote.type = BYTE_GET (external->type);
18154 inote.namesz = BYTE_GET (external->namesz);
18155 inote.namedata = external->name;
18156 inote.descsz = BYTE_GET (external->descsz);
18157 inote.descdata = ((char *) external
18158 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18159 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18160 next = ((char *) external
18161 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18165 Elf64_External_VMS_Note *vms_external;
18167 /* PR binutils/15191
18168 Make sure that there is enough data to read. */
18169 min_notesz = offsetof (Elf64_External_VMS_Note, name);
18170 if (data_remaining < min_notesz)
18172 warn (ngettext ("Corrupt note: only %ld byte remains, "
18173 "not enough for a full note\n",
18174 "Corrupt note: only %ld bytes remain, "
18175 "not enough for a full note\n",
18177 (long) data_remaining);
18180 data_remaining -= min_notesz;
18182 vms_external = (Elf64_External_VMS_Note *) external;
18183 inote.type = BYTE_GET (vms_external->type);
18184 inote.namesz = BYTE_GET (vms_external->namesz);
18185 inote.namedata = vms_external->name;
18186 inote.descsz = BYTE_GET (vms_external->descsz);
18187 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18188 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18189 next = inote.descdata + align_power (inote.descsz, 3);
18192 /* PR 17531: file: 3443835e. */
18193 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18194 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18195 || (size_t) (inote.descdata - inote.namedata) > data_remaining
18196 || (size_t) (next - inote.descdata) < inote.descsz
18197 || ((size_t) (next - inote.descdata)
18198 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18200 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18201 (unsigned long) ((char *) external - (char *) pnotes));
18202 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18203 inote.type, inote.namesz, inote.descsz, (int) align);
18207 external = (Elf_External_Note *) next;
18209 /* Verify that name is null terminated. It appears that at least
18210 one version of Linux (RedHat 6.0) generates corefiles that don't
18211 comply with the ELF spec by failing to include the null byte in
18213 if (inote.namedata[inote.namesz - 1] != '\0')
18215 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18217 temp = (char *) malloc (inote.namesz + 1);
18220 error (_("Out of memory allocating space for inote name\n"));
18225 memcpy (temp, inote.namedata, inote.namesz);
18226 inote.namedata = temp;
18228 inote.namedata[inote.namesz] = 0;
18231 if (! process_note (& inote, filedata))
18247 process_corefile_note_segments (Filedata * filedata)
18249 Elf_Internal_Phdr * segment;
18251 bfd_boolean res = TRUE;
18253 if (! get_program_headers (filedata))
18256 for (i = 0, segment = filedata->program_headers;
18257 i < filedata->file_header.e_phnum;
18260 if (segment->p_type == PT_NOTE)
18261 if (! process_notes_at (filedata, NULL,
18262 (bfd_vma) segment->p_offset,
18263 (bfd_vma) segment->p_filesz,
18264 (bfd_vma) segment->p_align))
18272 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18274 Elf_External_Note * pnotes;
18275 Elf_External_Note * external;
18277 bfd_boolean res = TRUE;
18282 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18284 if (pnotes == NULL)
18288 end = (char*) pnotes + length;
18290 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18291 (unsigned long) offset, (unsigned long) length);
18293 while ((char *) external + sizeof (Elf_External_Note) < end)
18295 Elf_External_Note * next;
18296 Elf_Internal_Note inote;
18298 inote.type = BYTE_GET (external->type);
18299 inote.namesz = BYTE_GET (external->namesz);
18300 inote.namedata = external->name;
18301 inote.descsz = BYTE_GET (external->descsz);
18302 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18303 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18305 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18307 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18308 inote.descdata = inote.namedata;
18312 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18314 if ( ((char *) next > end)
18315 || ((char *) next < (char *) pnotes))
18317 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18318 (unsigned long) ((char *) external - (char *) pnotes));
18319 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18320 inote.type, inote.namesz, inote.descsz);
18326 /* Prevent out-of-bounds indexing. */
18327 if ( inote.namedata + inote.namesz > end
18328 || inote.namedata + inote.namesz < inote.namedata)
18330 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18331 (unsigned long) ((char *) external - (char *) pnotes));
18332 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18333 inote.type, inote.namesz, inote.descsz);
18337 printf (" %s: ", get_v850_elf_note_type (inote.type));
18339 if (! print_v850_note (& inote))
18342 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18343 inote.namesz, inote.descsz);
18353 process_note_sections (Filedata * filedata)
18355 Elf_Internal_Shdr * section;
18357 unsigned int n = 0;
18358 bfd_boolean res = TRUE;
18360 for (i = 0, section = filedata->section_headers;
18361 i < filedata->file_header.e_shnum && section != NULL;
18364 if (section->sh_type == SHT_NOTE)
18366 if (! process_notes_at (filedata, section,
18367 (bfd_vma) section->sh_offset,
18368 (bfd_vma) section->sh_size,
18369 (bfd_vma) section->sh_addralign))
18374 if (( filedata->file_header.e_machine == EM_V800
18375 || filedata->file_header.e_machine == EM_V850
18376 || filedata->file_header.e_machine == EM_CYGNUS_V850)
18377 && section->sh_type == SHT_RENESAS_INFO)
18379 if (! process_v850_notes (filedata,
18380 (bfd_vma) section->sh_offset,
18381 (bfd_vma) section->sh_size))
18388 /* Try processing NOTE segments instead. */
18389 return process_corefile_note_segments (filedata);
18395 process_notes (Filedata * filedata)
18397 /* If we have not been asked to display the notes then do nothing. */
18401 if (filedata->file_header.e_type != ET_CORE)
18402 return process_note_sections (filedata);
18404 /* No program headers means no NOTE segment. */
18405 if (filedata->file_header.e_phnum > 0)
18406 return process_corefile_note_segments (filedata);
18408 printf (_("No note segments present in the core file.\n"));
18412 static unsigned char *
18413 display_public_gnu_attributes (unsigned char * start,
18414 const unsigned char * const end)
18416 printf (_(" Unknown GNU attribute: %s\n"), start);
18418 start += strnlen ((char *) start, end - start);
18419 display_raw_attribute (start, end);
18421 return (unsigned char *) end;
18424 static unsigned char *
18425 display_generic_attribute (unsigned char * start,
18427 const unsigned char * const end)
18430 return (unsigned char *) end;
18432 return display_tag_value (tag, start, end);
18436 process_arch_specific (Filedata * filedata)
18441 switch (filedata->file_header.e_machine)
18444 case EM_ARC_COMPACT:
18445 case EM_ARC_COMPACT2:
18446 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18447 display_arc_attribute,
18448 display_generic_attribute);
18450 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18451 display_arm_attribute,
18452 display_generic_attribute);
18455 case EM_MIPS_RS3_LE:
18456 return process_mips_specific (filedata);
18459 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18460 display_msp430x_attribute,
18461 display_generic_attribute);
18464 return process_nds32_specific (filedata);
18468 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18469 display_power_gnu_attribute);
18473 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18474 display_s390_gnu_attribute);
18477 case EM_SPARC32PLUS:
18479 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18480 display_sparc_gnu_attribute);
18483 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18484 display_tic6x_attribute,
18485 display_generic_attribute);
18488 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18489 display_public_gnu_attributes,
18490 display_generic_attribute);
18495 get_file_header (Filedata * filedata)
18497 /* Read in the identity array. */
18498 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18501 /* Determine how to read the rest of the header. */
18502 switch (filedata->file_header.e_ident[EI_DATA])
18507 byte_get = byte_get_little_endian;
18508 byte_put = byte_put_little_endian;
18511 byte_get = byte_get_big_endian;
18512 byte_put = byte_put_big_endian;
18516 /* For now we only support 32 bit and 64 bit ELF files. */
18517 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18519 /* Read in the rest of the header. */
18522 Elf32_External_Ehdr ehdr32;
18524 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18527 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
18528 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
18529 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
18530 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
18531 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18532 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18533 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
18534 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18535 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18536 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18537 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18538 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18539 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18543 Elf64_External_Ehdr ehdr64;
18545 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18546 we will not be able to cope with the 64bit data found in
18547 64 ELF files. Detect this now and abort before we start
18548 overwriting things. */
18549 if (sizeof (bfd_vma) < 8)
18551 error (_("This instance of readelf has been built without support for a\n\
18552 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18556 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18559 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
18560 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
18561 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
18562 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
18563 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18564 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
18565 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
18566 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
18567 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18568 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
18569 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18570 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
18571 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
18574 if (filedata->file_header.e_shoff)
18576 /* There may be some extensions in the first section header. Don't
18577 bomb if we can't read it. */
18579 get_32bit_section_headers (filedata, TRUE);
18581 get_64bit_section_headers (filedata, TRUE);
18588 close_file (Filedata * filedata)
18592 if (filedata->handle)
18593 fclose (filedata->handle);
18599 close_debug_file (void * data)
18601 close_file ((Filedata *) data);
18605 open_file (const char * pathname)
18607 struct stat statbuf;
18608 Filedata * filedata = NULL;
18610 if (stat (pathname, & statbuf) < 0
18611 || ! S_ISREG (statbuf.st_mode))
18614 filedata = calloc (1, sizeof * filedata);
18615 if (filedata == NULL)
18618 filedata->handle = fopen (pathname, "rb");
18619 if (filedata->handle == NULL)
18622 filedata->file_size = (bfd_size_type) statbuf.st_size;
18623 filedata->file_name = pathname;
18625 if (! get_file_header (filedata))
18628 if (filedata->file_header.e_shoff)
18632 /* Read the section headers again, this time for real. */
18634 res = get_32bit_section_headers (filedata, FALSE);
18636 res = get_64bit_section_headers (filedata, FALSE);
18647 if (filedata->handle)
18648 fclose (filedata->handle);
18655 open_debug_file (const char * pathname)
18657 return open_file (pathname);
18660 /* Process one ELF object file according to the command line options.
18661 This file may actually be stored in an archive. The file is
18662 positioned at the start of the ELF object. Returns TRUE if no
18663 problems were encountered, FALSE otherwise. */
18666 process_object (Filedata * filedata)
18668 Filedata * separates;
18670 bfd_boolean res = TRUE;
18672 if (! get_file_header (filedata))
18674 error (_("%s: Failed to read file header\n"), filedata->file_name);
18678 /* Initialise per file variables. */
18679 for (i = ARRAY_SIZE (version_info); i--;)
18680 version_info[i] = 0;
18682 for (i = ARRAY_SIZE (dynamic_info); i--;)
18683 dynamic_info[i] = 0;
18684 dynamic_info_DT_GNU_HASH = 0;
18686 /* Process the file. */
18688 printf (_("\nFile: %s\n"), filedata->file_name);
18690 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18691 Note we do this even if cmdline_dump_sects is empty because we
18692 must make sure that the dump_sets array is zeroed out before each
18693 object file is processed. */
18694 if (filedata->num_dump_sects > cmdline.num_dump_sects)
18695 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18697 if (cmdline.num_dump_sects > 0)
18699 if (filedata->num_dump_sects == 0)
18700 /* A sneaky way of allocating the dump_sects array. */
18701 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18703 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18704 memcpy (filedata->dump_sects, cmdline.dump_sects,
18705 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18708 if (! process_file_header (filedata))
18711 if (! process_section_headers (filedata))
18713 /* Without loaded section headers we cannot process lots of things. */
18714 do_unwind = do_version = do_dump = do_arch = FALSE;
18716 if (! do_using_dynamic)
18717 do_syms = do_dyn_syms = do_reloc = FALSE;
18720 if (! process_section_groups (filedata))
18721 /* Without loaded section groups we cannot process unwind. */
18724 if (process_program_headers (filedata))
18725 process_dynamic_section (filedata);
18729 if (! process_relocs (filedata))
18732 if (! process_unwind (filedata))
18735 if (! process_symbol_table (filedata))
18738 if (! process_syminfo (filedata))
18741 if (! process_version_sections (filedata))
18744 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18745 separates = load_separate_debug_file (filedata, filedata->file_name);
18749 if (! process_section_contents (filedata))
18754 if (! process_section_headers (separates))
18756 else if (! process_section_contents (separates))
18760 if (! process_notes (filedata))
18763 if (! process_gnu_liblist (filedata))
18766 if (! process_arch_specific (filedata))
18769 free (filedata->program_headers);
18770 filedata->program_headers = NULL;
18772 free (filedata->section_headers);
18773 filedata->section_headers = NULL;
18775 free (filedata->string_table);
18776 filedata->string_table = NULL;
18777 filedata->string_table_length = 0;
18779 if (dynamic_strings)
18781 free (dynamic_strings);
18782 dynamic_strings = NULL;
18783 dynamic_strings_length = 0;
18786 if (dynamic_symbols)
18788 free (dynamic_symbols);
18789 dynamic_symbols = NULL;
18790 num_dynamic_syms = 0;
18793 if (dynamic_syminfo)
18795 free (dynamic_syminfo);
18796 dynamic_syminfo = NULL;
18799 if (dynamic_section)
18801 free (dynamic_section);
18802 dynamic_section = NULL;
18805 if (section_headers_groups)
18807 free (section_headers_groups);
18808 section_headers_groups = NULL;
18811 if (section_groups)
18813 struct group_list * g;
18814 struct group_list * next;
18816 for (i = 0; i < group_count; i++)
18818 for (g = section_groups [i].root; g != NULL; g = next)
18825 free (section_groups);
18826 section_groups = NULL;
18829 free_debug_memory ();
18834 /* Process an ELF archive.
18835 On entry the file is positioned just after the ARMAG string.
18836 Returns TRUE upon success, FALSE otherwise. */
18839 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18841 struct archive_info arch;
18842 struct archive_info nested_arch;
18844 bfd_boolean ret = TRUE;
18848 /* The ARCH structure is used to hold information about this archive. */
18849 arch.file_name = NULL;
18851 arch.index_array = NULL;
18852 arch.sym_table = NULL;
18853 arch.longnames = NULL;
18855 /* The NESTED_ARCH structure is used as a single-item cache of information
18856 about a nested archive (when members of a thin archive reside within
18857 another regular archive file). */
18858 nested_arch.file_name = NULL;
18859 nested_arch.file = NULL;
18860 nested_arch.index_array = NULL;
18861 nested_arch.sym_table = NULL;
18862 nested_arch.longnames = NULL;
18864 if (setup_archive (&arch, filedata->file_name, filedata->handle,
18865 is_thin_archive, do_archive_index) != 0)
18871 if (do_archive_index)
18873 if (arch.sym_table == NULL)
18874 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18877 unsigned long i, l;
18878 unsigned long current_pos;
18880 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18881 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18883 current_pos = ftell (filedata->handle);
18885 for (i = l = 0; i < arch.index_num; i++)
18887 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18889 char * member_name;
18891 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18893 if (member_name != NULL)
18895 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18897 if (qualified_name != NULL)
18899 printf (_("Contents of binary %s at offset "), qualified_name);
18900 (void) print_vma (arch.index_array[i], PREFIX_HEX);
18902 free (qualified_name);
18907 if (l >= arch.sym_size)
18909 error (_("%s: end of the symbol table reached before the end of the index\n"),
18910 filedata->file_name);
18914 /* PR 17531: file: 0b6630b2. */
18915 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18916 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18919 if (arch.uses_64bit_indicies)
18924 if (l < arch.sym_size)
18926 error (ngettext ("%s: %ld byte remains in the symbol table, "
18927 "but without corresponding entries in "
18928 "the index table\n",
18929 "%s: %ld bytes remain in the symbol table, "
18930 "but without corresponding entries in "
18931 "the index table\n",
18932 arch.sym_size - l),
18933 filedata->file_name, arch.sym_size - l);
18937 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18939 error (_("%s: failed to seek back to start of object files in the archive\n"),
18940 filedata->file_name);
18946 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18947 && !do_segments && !do_header && !do_dump && !do_version
18948 && !do_histogram && !do_debugging && !do_arch && !do_notes
18949 && !do_section_groups && !do_dyn_syms)
18951 ret = TRUE; /* Archive index only. */
18960 char * qualified_name;
18962 /* Read the next archive header. */
18963 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18965 error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18968 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18969 if (got != sizeof arch.arhdr)
18973 error (_("%s: failed to read archive header\n"), filedata->file_name);
18977 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18979 error (_("%s: did not find a valid archive header\n"), arch.file_name);
18984 arch.next_arhdr_offset += sizeof arch.arhdr;
18986 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18987 if (archive_file_size & 01)
18988 ++archive_file_size;
18990 name = get_archive_member_name (&arch, &nested_arch);
18993 error (_("%s: bad archive file name\n"), filedata->file_name);
18997 namelen = strlen (name);
18999 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19000 if (qualified_name == NULL)
19002 error (_("%s: bad archive file name\n"), filedata->file_name);
19007 if (is_thin_archive && arch.nested_member_origin == 0)
19009 /* This is a proxy for an external member of a thin archive. */
19010 Filedata * member_filedata;
19011 char * member_file_name = adjust_relative_path
19012 (filedata->file_name, name, namelen);
19014 if (member_file_name == NULL)
19020 member_filedata = open_file (member_file_name);
19021 if (member_filedata == NULL)
19023 error (_("Input file '%s' is not readable.\n"), member_file_name);
19024 free (member_file_name);
19029 archive_file_offset = arch.nested_member_origin;
19030 member_filedata->file_name = qualified_name;
19032 if (! process_object (member_filedata))
19035 close_file (member_filedata);
19036 free (member_file_name);
19038 else if (is_thin_archive)
19040 Filedata thin_filedata;
19042 memset (&thin_filedata, 0, sizeof (thin_filedata));
19044 /* PR 15140: Allow for corrupt thin archives. */
19045 if (nested_arch.file == NULL)
19047 error (_("%s: contains corrupt thin archive: %s\n"),
19048 filedata->file_name, name);
19053 /* This is a proxy for a member of a nested archive. */
19054 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19056 /* The nested archive file will have been opened and setup by
19057 get_archive_member_name. */
19058 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19060 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19065 thin_filedata.handle = nested_arch.file;
19066 thin_filedata.file_name = qualified_name;
19068 if (! process_object (& thin_filedata))
19073 archive_file_offset = arch.next_arhdr_offset;
19074 arch.next_arhdr_offset += archive_file_size;
19076 filedata->file_name = qualified_name;
19077 if (! process_object (filedata))
19081 if (filedata->dump_sects != NULL)
19083 free (filedata->dump_sects);
19084 filedata->dump_sects = NULL;
19085 filedata->num_dump_sects = 0;
19088 free (qualified_name);
19092 if (nested_arch.file != NULL)
19093 fclose (nested_arch.file);
19094 release_archive (&nested_arch);
19095 release_archive (&arch);
19101 process_file (char * file_name)
19103 Filedata * filedata = NULL;
19104 struct stat statbuf;
19105 char armag[SARMAG];
19106 bfd_boolean ret = TRUE;
19108 if (stat (file_name, &statbuf) < 0)
19110 if (errno == ENOENT)
19111 error (_("'%s': No such file\n"), file_name);
19113 error (_("Could not locate '%s'. System error message: %s\n"),
19114 file_name, strerror (errno));
19118 if (! S_ISREG (statbuf.st_mode))
19120 error (_("'%s' is not an ordinary file\n"), file_name);
19124 filedata = calloc (1, sizeof * filedata);
19125 if (filedata == NULL)
19127 error (_("Out of memory allocating file data structure\n"));
19131 filedata->file_name = file_name;
19132 filedata->handle = fopen (file_name, "rb");
19133 if (filedata->handle == NULL)
19135 error (_("Input file '%s' is not readable.\n"), file_name);
19140 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19142 error (_("%s: Failed to read file's magic number\n"), file_name);
19143 fclose (filedata->handle);
19148 filedata->file_size = (bfd_size_type) statbuf.st_size;
19150 if (memcmp (armag, ARMAG, SARMAG) == 0)
19152 if (! process_archive (filedata, FALSE))
19155 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19157 if ( ! process_archive (filedata, TRUE))
19162 if (do_archive_index)
19163 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19166 rewind (filedata->handle);
19167 archive_file_size = archive_file_offset = 0;
19169 if (! process_object (filedata))
19173 fclose (filedata->handle);
19179 #ifdef SUPPORT_DISASSEMBLY
19180 /* Needed by the i386 disassembler. For extra credit, someone could
19181 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19185 print_address (unsigned int addr, FILE * outfile)
19187 fprintf (outfile,"0x%8.8x", addr);
19190 /* Needed by the i386 disassembler. */
19193 db_task_printsym (unsigned int addr)
19195 print_address (addr, stderr);
19200 main (int argc, char ** argv)
19204 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19205 setlocale (LC_MESSAGES, "");
19207 #if defined (HAVE_SETLOCALE)
19208 setlocale (LC_CTYPE, "");
19210 bindtextdomain (PACKAGE, LOCALEDIR);
19211 textdomain (PACKAGE);
19213 expandargv (&argc, &argv);
19215 cmdline.file_name = "<cmdline>";
19216 parse_args (& cmdline, argc, argv);
19218 if (optind < (argc - 1))
19220 else if (optind >= argc)
19222 warn (_("Nothing to do.\n"));
19227 while (optind < argc)
19228 if (! process_file (argv[optind++]))
19231 if (cmdline.dump_sects != NULL)
19232 free (cmdline.dump_sects);
19234 return err ? EXIT_FAILURE : EXIT_SUCCESS;