1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
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"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name
= "readelf";
168 static unsigned long archive_file_offset
;
169 static unsigned long archive_file_size
;
170 static bfd_size_type current_file_size
;
171 static unsigned long dynamic_addr
;
172 static bfd_size_type dynamic_size
;
173 static size_t dynamic_nent
;
174 static char * dynamic_strings
;
175 static unsigned long dynamic_strings_length
;
176 static char * string_table
;
177 static unsigned long string_table_length
;
178 static unsigned long num_dynamic_syms
;
179 static Elf_Internal_Sym
* dynamic_symbols
;
180 static Elf_Internal_Syminfo
* dynamic_syminfo
;
181 static unsigned long dynamic_syminfo_offset
;
182 static unsigned int dynamic_syminfo_nent
;
183 static char program_interpreter
[PATH_MAX
];
184 static bfd_vma dynamic_info
[DT_ENCODING
];
185 static bfd_vma dynamic_info_DT_GNU_HASH
;
186 static bfd_vma version_info
[16];
187 static Elf_Internal_Ehdr elf_header
;
188 static Elf_Internal_Shdr
* section_headers
;
189 static Elf_Internal_Phdr
* program_headers
;
190 static Elf_Internal_Dyn
* dynamic_section
;
191 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
192 static int show_name
;
193 static int do_dynamic
;
195 static int do_dyn_syms
;
197 static int do_sections
;
198 static int do_section_groups
;
199 static int do_section_details
;
200 static int do_segments
;
201 static int do_unwind
;
202 static int do_using_dynamic
;
203 static int do_header
;
205 static int do_version
;
206 static int do_histogram
;
207 static int do_debugging
;
210 static int do_archive_index
;
211 static int is_32bit_elf
;
212 static int decompress_dumps
;
216 struct group_list
* next
;
217 unsigned int section_index
;
222 struct group_list
* root
;
223 unsigned int group_index
;
226 static size_t group_count
;
227 static struct group
* section_groups
;
228 static struct group
** section_headers_groups
;
231 /* Flag bits indicating particular types of dump. */
232 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
233 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
234 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
235 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
236 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
238 typedef unsigned char dump_type
;
240 /* A linked list of the section names for which dumps were requested. */
241 struct dump_list_entry
245 struct dump_list_entry
* next
;
247 static struct dump_list_entry
* dump_sects_byname
;
249 /* A dynamic array of flags indicating for which sections a dump
250 has been requested via command line switches. */
251 static dump_type
* cmdline_dump_sects
= NULL
;
252 static unsigned int num_cmdline_dump_sects
= 0;
254 /* A dynamic array of flags indicating for which sections a dump of
255 some kind has been requested. It is reset on a per-object file
256 basis and then initialised from the cmdline_dump_sects array,
257 the results of interpreting the -w switch, and the
258 dump_sects_byname list. */
259 static dump_type
* dump_sects
= NULL
;
260 static unsigned int num_dump_sects
= 0;
263 /* How to print a vma value. */
264 typedef enum print_mode
276 /* Versioned symbol info. */
277 enum versioned_symbol_info
284 static const char *get_symbol_version_string
285 (FILE *file
, int is_dynsym
, const char *strtab
,
286 unsigned long int strtab_size
, unsigned int si
,
287 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
288 unsigned short *vna_other
);
292 #define SECTION_NAME(X) \
293 ((X) == NULL ? _("<none>") \
294 : string_table == NULL ? _("<no-name>") \
295 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
296 : string_table + (X)->sh_name))
298 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
300 #define GET_ELF_SYMBOLS(file, section, sym_count) \
301 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
302 : get_64bit_elf_symbols (file, section, sym_count))
304 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
305 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
306 already been called and verified that the string exists. */
307 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
309 #define REMOVE_ARCH_BITS(ADDR) \
312 if (elf_header.e_machine == EM_ARM) \
317 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
318 the offset of the current archive member, if we are examining an archive.
319 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
320 using malloc and fill that. In either case return the pointer to the start of
321 the retrieved data or NULL if something went wrong. If something does go wrong
322 and REASON is not NULL then emit an error message using REASON as part of the
326 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
327 bfd_size_type nmemb
, const char * reason
)
330 bfd_size_type amt
= size
* nmemb
;
332 if (size
== 0 || nmemb
== 0)
335 /* If the size_t type is smaller than the bfd_size_type, eg because
336 you are building a 32-bit tool on a 64-bit host, then make sure
337 that when the sizes are cast to (size_t) no information is lost. */
338 if (sizeof (size_t) < sizeof (bfd_size_type
)
339 && ( (bfd_size_type
) ((size_t) size
) != size
340 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
343 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
344 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
348 /* Check for size overflow. */
352 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
353 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
357 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
358 attempting to allocate memory when the read is bound to fail. */
359 if (amt
> current_file_size
360 || offset
+ archive_file_offset
+ amt
> current_file_size
)
363 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
364 (unsigned long long) amt
, reason
);
368 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
371 error (_("Unable to seek to 0x%lx for %s\n"),
372 (unsigned long) archive_file_offset
+ offset
, reason
);
379 /* Check for overflow. */
380 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
381 /* + 1 so that we can '\0' terminate invalid string table sections. */
382 mvar
= malloc ((size_t) amt
+ 1);
387 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
388 (unsigned long long) amt
, reason
);
392 ((char *) mvar
)[amt
] = '\0';
395 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
398 error (_("Unable to read in 0x%llx bytes of %s\n"),
399 (unsigned long long) amt
, reason
);
408 /* Print a VMA value. */
411 print_vma (bfd_vma vma
, print_mode mode
)
424 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
431 return printf ("%5" BFD_VMA_FMT
"d", vma
);
439 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
442 return printf ("%" BFD_VMA_FMT
"d", vma
);
445 return printf ("%" BFD_VMA_FMT
"u", vma
);
450 /* Display a symbol on stdout. Handles the display of control characters and
451 multibye characters (assuming the host environment supports them).
453 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
455 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
456 padding as necessary.
458 Returns the number of emitted characters. */
461 print_symbol (int width
, const char *symbol
)
463 bfd_boolean extra_padding
= FALSE
;
465 #ifdef HAVE_MBSTATE_T
472 /* Keep the width positive. This also helps. */
474 extra_padding
= TRUE
;
479 /* Set the remaining width to a very large value.
480 This simplifies the code below. */
481 width_remaining
= INT_MAX
;
483 width_remaining
= width
;
485 #ifdef HAVE_MBSTATE_T
486 /* Initialise the multibyte conversion state. */
487 memset (& state
, 0, sizeof (state
));
490 while (width_remaining
)
493 const char c
= *symbol
++;
498 /* Do not print control characters directly as they can affect terminal
499 settings. Such characters usually appear in the names generated
500 by the assembler for local labels. */
503 if (width_remaining
< 2)
506 printf ("^%c", c
+ 0x40);
507 width_remaining
-= 2;
510 else if (ISPRINT (c
))
518 #ifdef HAVE_MBSTATE_T
521 /* Let printf do the hard work of displaying multibyte characters. */
522 printf ("%.1s", symbol
- 1);
526 #ifdef HAVE_MBSTATE_T
527 /* Try to find out how many bytes made up the character that was
528 just printed. Advance the symbol pointer past the bytes that
530 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
534 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
539 if (extra_padding
&& num_printed
< width
)
541 /* Fill in the remaining spaces. */
542 printf ("%-*s", width
- num_printed
, " ");
549 /* Returns a pointer to a static buffer containing a printable version of
550 the given section's name. Like print_symbol, except that it does not try
551 to print multibyte characters, it just interprets them as hex values. */
554 printable_section_name (const Elf_Internal_Shdr
* sec
)
556 #define MAX_PRINT_SEC_NAME_LEN 128
557 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
558 const char * name
= SECTION_NAME (sec
);
559 char * buf
= sec_name_buf
;
561 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
563 while ((c
= * name
++) != 0)
574 else if (ISPRINT (c
))
581 static char hex
[17] = "0123456789ABCDEF";
586 * buf
++ = hex
[(c
& 0xf0) >> 4];
587 * buf
++ = hex
[c
& 0x0f];
601 printable_section_name_from_index (unsigned long ndx
)
603 if (ndx
>= elf_header
.e_shnum
)
604 return _("<corrupt>");
606 return printable_section_name (section_headers
+ ndx
);
609 /* Return a pointer to section NAME, or NULL if no such section exists. */
611 static Elf_Internal_Shdr
*
612 find_section (const char * name
)
616 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
617 if (streq (SECTION_NAME (section_headers
+ i
), name
))
618 return section_headers
+ i
;
623 /* Return a pointer to a section containing ADDR, or NULL if no such
626 static Elf_Internal_Shdr
*
627 find_section_by_address (bfd_vma addr
)
631 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
633 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
634 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
641 static Elf_Internal_Shdr
*
642 find_section_by_type (unsigned int type
)
646 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
648 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
649 if (sec
->sh_type
== type
)
656 /* Return a pointer to section NAME, or NULL if no such section exists,
657 restricted to the list of sections given in SET. */
659 static Elf_Internal_Shdr
*
660 find_section_in_set (const char * name
, unsigned int * set
)
666 while ((i
= *set
++) > 0)
667 if (streq (SECTION_NAME (section_headers
+ i
), name
))
668 return section_headers
+ i
;
671 return find_section (name
);
674 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
677 static inline unsigned long
678 read_uleb128 (unsigned char *data
,
679 unsigned int *length_return
,
680 const unsigned char * const end
)
682 return read_leb128 (data
, length_return
, FALSE
, end
);
685 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
686 This OS has so many departures from the ELF standard that we test it at
692 return elf_header
.e_machine
== EM_IA_64
693 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
696 /* Guess the relocation size commonly used by the specific machines. */
699 guess_is_rela (unsigned int e_machine
)
703 /* Targets that use REL relocations. */
718 /* Targets that use RELA relocations. */
722 case EM_ADAPTEVA_EPIPHANY
:
724 case EM_ALTERA_NIOS2
:
744 case EM_LATTICEMICO32
:
753 case EM_CYGNUS_MN10200
:
755 case EM_CYGNUS_MN10300
:
789 case EM_MICROBLAZE_OLD
:
810 warn (_("Don't know about relocations on this machine architecture\n"));
816 slurp_rela_relocs (FILE * file
,
817 unsigned long rel_offset
,
818 unsigned long rel_size
,
819 Elf_Internal_Rela
** relasp
,
820 unsigned long * nrelasp
)
822 Elf_Internal_Rela
* relas
;
828 Elf32_External_Rela
* erelas
;
830 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
831 rel_size
, _("32-bit relocation data"));
835 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
837 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
838 sizeof (Elf_Internal_Rela
));
843 error (_("out of memory parsing relocs\n"));
847 for (i
= 0; i
< nrelas
; i
++)
849 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
850 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
851 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
858 Elf64_External_Rela
* erelas
;
860 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("64-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
883 /* The #ifdef BFD64 below is to prevent a compile time
884 warning. We know that if we do not have a 64 bit data
885 type that we will never execute this code anyway. */
887 if (elf_header
.e_machine
== EM_MIPS
888 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
890 /* In little-endian objects, r_info isn't really a
891 64-bit little-endian value: it has a 32-bit
892 little-endian symbol index followed by four
893 individual byte fields. Reorder INFO
895 bfd_vma inf
= relas
[i
].r_info
;
896 inf
= (((inf
& 0xffffffff) << 32)
897 | ((inf
>> 56) & 0xff)
898 | ((inf
>> 40) & 0xff00)
899 | ((inf
>> 24) & 0xff0000)
900 | ((inf
>> 8) & 0xff000000));
901 relas
[i
].r_info
= inf
;
914 slurp_rel_relocs (FILE * file
,
915 unsigned long rel_offset
,
916 unsigned long rel_size
,
917 Elf_Internal_Rela
** relsp
,
918 unsigned long * nrelsp
)
920 Elf_Internal_Rela
* rels
;
926 Elf32_External_Rel
* erels
;
928 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
929 rel_size
, _("32-bit relocation data"));
933 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
935 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
940 error (_("out of memory parsing relocs\n"));
944 for (i
= 0; i
< nrels
; i
++)
946 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
947 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
948 rels
[i
].r_addend
= 0;
955 Elf64_External_Rel
* erels
;
957 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
958 rel_size
, _("64-bit relocation data"));
962 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
964 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
969 error (_("out of memory parsing relocs\n"));
973 for (i
= 0; i
< nrels
; i
++)
975 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
976 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
977 rels
[i
].r_addend
= 0;
979 /* The #ifdef BFD64 below is to prevent a compile time
980 warning. We know that if we do not have a 64 bit data
981 type that we will never execute this code anyway. */
983 if (elf_header
.e_machine
== EM_MIPS
984 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
986 /* In little-endian objects, r_info isn't really a
987 64-bit little-endian value: it has a 32-bit
988 little-endian symbol index followed by four
989 individual byte fields. Reorder INFO
991 bfd_vma inf
= rels
[i
].r_info
;
992 inf
= (((inf
& 0xffffffff) << 32)
993 | ((inf
>> 56) & 0xff)
994 | ((inf
>> 40) & 0xff00)
995 | ((inf
>> 24) & 0xff0000)
996 | ((inf
>> 8) & 0xff000000));
997 rels
[i
].r_info
= inf
;
1009 /* Returns the reloc type extracted from the reloc info field. */
1012 get_reloc_type (bfd_vma reloc_info
)
1015 return ELF32_R_TYPE (reloc_info
);
1017 switch (elf_header
.e_machine
)
1020 /* Note: We assume that reloc_info has already been adjusted for us. */
1021 return ELF64_MIPS_R_TYPE (reloc_info
);
1024 return ELF64_R_TYPE_ID (reloc_info
);
1027 return ELF64_R_TYPE (reloc_info
);
1031 /* Return the symbol index extracted from the reloc info field. */
1034 get_reloc_symindex (bfd_vma reloc_info
)
1036 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1039 static inline bfd_boolean
1040 uses_msp430x_relocs (void)
1043 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1044 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1045 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1046 /* TI compiler uses ELFOSABI_NONE. */
1047 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1050 /* Display the contents of the relocation data found at the specified
1054 dump_relocations (FILE * file
,
1055 unsigned long rel_offset
,
1056 unsigned long rel_size
,
1057 Elf_Internal_Sym
* symtab
,
1058 unsigned long nsyms
,
1060 unsigned long strtablen
,
1065 Elf_Internal_Rela
* rels
;
1067 if (is_rela
== UNKNOWN
)
1068 is_rela
= guess_is_rela (elf_header
.e_machine
);
1072 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1077 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1086 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1088 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1093 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1095 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1103 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1105 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1110 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1112 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1116 for (i
= 0; i
< rel_size
; i
++)
1121 bfd_vma symtab_index
;
1124 offset
= rels
[i
].r_offset
;
1125 inf
= rels
[i
].r_info
;
1127 type
= get_reloc_type (inf
);
1128 symtab_index
= get_reloc_symindex (inf
);
1132 printf ("%8.8lx %8.8lx ",
1133 (unsigned long) offset
& 0xffffffff,
1134 (unsigned long) inf
& 0xffffffff);
1138 #if BFD_HOST_64BIT_LONG
1140 ? "%16.16lx %16.16lx "
1141 : "%12.12lx %12.12lx ",
1143 #elif BFD_HOST_64BIT_LONG_LONG
1146 ? "%16.16llx %16.16llx "
1147 : "%12.12llx %12.12llx ",
1151 ? "%16.16I64x %16.16I64x "
1152 : "%12.12I64x %12.12I64x ",
1157 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1158 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1159 _bfd_int64_high (offset
),
1160 _bfd_int64_low (offset
),
1161 _bfd_int64_high (inf
),
1162 _bfd_int64_low (inf
));
1166 switch (elf_header
.e_machine
)
1173 rtype
= elf_aarch64_reloc_type (type
);
1177 case EM_CYGNUS_M32R
:
1178 rtype
= elf_m32r_reloc_type (type
);
1183 rtype
= elf_i386_reloc_type (type
);
1188 rtype
= elf_m68hc11_reloc_type (type
);
1192 rtype
= elf_m68k_reloc_type (type
);
1196 rtype
= elf_i960_reloc_type (type
);
1201 rtype
= elf_avr_reloc_type (type
);
1204 case EM_OLD_SPARCV9
:
1205 case EM_SPARC32PLUS
:
1208 rtype
= elf_sparc_reloc_type (type
);
1212 rtype
= elf_spu_reloc_type (type
);
1216 rtype
= v800_reloc_type (type
);
1219 case EM_CYGNUS_V850
:
1220 rtype
= v850_reloc_type (type
);
1224 case EM_CYGNUS_D10V
:
1225 rtype
= elf_d10v_reloc_type (type
);
1229 case EM_CYGNUS_D30V
:
1230 rtype
= elf_d30v_reloc_type (type
);
1234 rtype
= elf_dlx_reloc_type (type
);
1238 rtype
= elf_sh_reloc_type (type
);
1242 case EM_CYGNUS_MN10300
:
1243 rtype
= elf_mn10300_reloc_type (type
);
1247 case EM_CYGNUS_MN10200
:
1248 rtype
= elf_mn10200_reloc_type (type
);
1252 case EM_CYGNUS_FR30
:
1253 rtype
= elf_fr30_reloc_type (type
);
1257 rtype
= elf_frv_reloc_type (type
);
1261 rtype
= elf_ft32_reloc_type (type
);
1265 rtype
= elf_mcore_reloc_type (type
);
1269 rtype
= elf_mmix_reloc_type (type
);
1273 rtype
= elf_moxie_reloc_type (type
);
1277 if (uses_msp430x_relocs ())
1279 rtype
= elf_msp430x_reloc_type (type
);
1283 rtype
= elf_msp430_reloc_type (type
);
1287 rtype
= elf_nds32_reloc_type (type
);
1291 rtype
= elf_ppc_reloc_type (type
);
1295 rtype
= elf_ppc64_reloc_type (type
);
1299 case EM_MIPS_RS3_LE
:
1300 rtype
= elf_mips_reloc_type (type
);
1304 rtype
= elf_alpha_reloc_type (type
);
1308 rtype
= elf_arm_reloc_type (type
);
1312 rtype
= elf_arc_reloc_type (type
);
1316 rtype
= elf_hppa_reloc_type (type
);
1322 rtype
= elf_h8_reloc_type (type
);
1326 rtype
= elf_or1k_reloc_type (type
);
1331 rtype
= elf_pj_reloc_type (type
);
1334 rtype
= elf_ia64_reloc_type (type
);
1338 rtype
= elf_cris_reloc_type (type
);
1342 rtype
= elf_i860_reloc_type (type
);
1348 rtype
= elf_x86_64_reloc_type (type
);
1352 rtype
= i370_reloc_type (type
);
1357 rtype
= elf_s390_reloc_type (type
);
1361 rtype
= elf_score_reloc_type (type
);
1365 rtype
= elf_xstormy16_reloc_type (type
);
1369 rtype
= elf_crx_reloc_type (type
);
1373 rtype
= elf_vax_reloc_type (type
);
1377 rtype
= elf_visium_reloc_type (type
);
1380 case EM_ADAPTEVA_EPIPHANY
:
1381 rtype
= elf_epiphany_reloc_type (type
);
1386 rtype
= elf_ip2k_reloc_type (type
);
1390 rtype
= elf_iq2000_reloc_type (type
);
1395 rtype
= elf_xtensa_reloc_type (type
);
1398 case EM_LATTICEMICO32
:
1399 rtype
= elf_lm32_reloc_type (type
);
1404 rtype
= elf_m32c_reloc_type (type
);
1408 rtype
= elf_mt_reloc_type (type
);
1412 rtype
= elf_bfin_reloc_type (type
);
1416 rtype
= elf_mep_reloc_type (type
);
1420 rtype
= elf_cr16_reloc_type (type
);
1424 case EM_MICROBLAZE_OLD
:
1425 rtype
= elf_microblaze_reloc_type (type
);
1429 rtype
= elf_rl78_reloc_type (type
);
1433 rtype
= elf_rx_reloc_type (type
);
1437 rtype
= elf_metag_reloc_type (type
);
1442 rtype
= elf_xc16x_reloc_type (type
);
1446 rtype
= elf_tic6x_reloc_type (type
);
1450 rtype
= elf_tilegx_reloc_type (type
);
1454 rtype
= elf_tilepro_reloc_type (type
);
1458 rtype
= elf_xgate_reloc_type (type
);
1461 case EM_ALTERA_NIOS2
:
1462 rtype
= elf_nios2_reloc_type (type
);
1467 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1469 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1471 if (elf_header
.e_machine
== EM_ALPHA
1473 && streq (rtype
, "R_ALPHA_LITUSE")
1476 switch (rels
[i
].r_addend
)
1478 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1479 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1480 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1481 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1482 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1483 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1484 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1485 default: rtype
= NULL
;
1488 printf (" (%s)", rtype
);
1492 printf (_("<unknown addend: %lx>"),
1493 (unsigned long) rels
[i
].r_addend
);
1496 else if (symtab_index
)
1498 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1499 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1502 Elf_Internal_Sym
* psym
;
1503 const char * version_string
;
1504 enum versioned_symbol_info sym_info
;
1505 unsigned short vna_other
;
1507 psym
= symtab
+ symtab_index
;
1510 = get_symbol_version_string (file
, is_dynsym
,
1519 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1523 unsigned int width
= is_32bit_elf
? 8 : 14;
1525 /* Relocations against GNU_IFUNC symbols do not use the value
1526 of the symbol as the address to relocate against. Instead
1527 they invoke the function named by the symbol and use its
1528 result as the address for relocation.
1530 To indicate this to the user, do not display the value of
1531 the symbol in the "Symbols's Value" field. Instead show
1532 its name followed by () as a hint that the symbol is
1536 || psym
->st_name
== 0
1537 || psym
->st_name
>= strtablen
)
1540 name
= strtab
+ psym
->st_name
;
1542 len
= print_symbol (width
, name
);
1544 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1546 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1550 print_vma (psym
->st_value
, LONG_HEX
);
1552 printf (is_32bit_elf
? " " : " ");
1555 if (psym
->st_name
== 0)
1557 const char * sec_name
= "<null>";
1560 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1562 if (psym
->st_shndx
< elf_header
.e_shnum
)
1563 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1564 else if (psym
->st_shndx
== SHN_ABS
)
1566 else if (psym
->st_shndx
== SHN_COMMON
)
1567 sec_name
= "COMMON";
1568 else if ((elf_header
.e_machine
== EM_MIPS
1569 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1570 || (elf_header
.e_machine
== EM_TI_C6000
1571 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1572 sec_name
= "SCOMMON";
1573 else if (elf_header
.e_machine
== EM_MIPS
1574 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1575 sec_name
= "SUNDEF";
1576 else if ((elf_header
.e_machine
== EM_X86_64
1577 || elf_header
.e_machine
== EM_L1OM
1578 || elf_header
.e_machine
== EM_K1OM
)
1579 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1580 sec_name
= "LARGE_COMMON";
1581 else if (elf_header
.e_machine
== EM_IA_64
1582 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1583 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1584 sec_name
= "ANSI_COM";
1585 else if (is_ia64_vms ()
1586 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1587 sec_name
= "VMS_SYMVEC";
1590 sprintf (name_buf
, "<section 0x%x>",
1591 (unsigned int) psym
->st_shndx
);
1592 sec_name
= name_buf
;
1595 print_symbol (22, sec_name
);
1597 else if (strtab
== NULL
)
1598 printf (_("<string table index: %3ld>"), psym
->st_name
);
1599 else if (psym
->st_name
>= strtablen
)
1600 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1603 print_symbol (22, strtab
+ psym
->st_name
);
1605 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1611 bfd_vma off
= rels
[i
].r_addend
;
1613 if ((bfd_signed_vma
) off
< 0)
1614 printf (" - %" BFD_VMA_FMT
"x", - off
);
1616 printf (" + %" BFD_VMA_FMT
"x", off
);
1622 bfd_vma off
= rels
[i
].r_addend
;
1624 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1625 if ((bfd_signed_vma
) off
< 0)
1626 printf ("-%" BFD_VMA_FMT
"x", - off
);
1628 printf ("%" BFD_VMA_FMT
"x", off
);
1631 if (elf_header
.e_machine
== EM_SPARCV9
1633 && streq (rtype
, "R_SPARC_OLO10"))
1634 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1639 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1641 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1642 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1643 const char * rtype2
= elf_mips_reloc_type (type2
);
1644 const char * rtype3
= elf_mips_reloc_type (type3
);
1646 printf (" Type2: ");
1649 printf (_("unrecognized: %-7lx"),
1650 (unsigned long) type2
& 0xffffffff);
1652 printf ("%-17.17s", rtype2
);
1654 printf ("\n Type3: ");
1657 printf (_("unrecognized: %-7lx"),
1658 (unsigned long) type3
& 0xffffffff);
1660 printf ("%-17.17s", rtype3
);
1671 get_mips_dynamic_type (unsigned long type
)
1675 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1676 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1677 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1678 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1679 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1680 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1681 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1682 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1683 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1684 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1685 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1686 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1687 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1688 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1689 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1690 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1691 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1692 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1693 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1694 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1695 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1696 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1697 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1698 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1699 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1700 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1701 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1702 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1703 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1704 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1705 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1706 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1707 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1708 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1709 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1710 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1711 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1712 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1713 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1714 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1715 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1716 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1717 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1718 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1719 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1720 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1727 get_sparc64_dynamic_type (unsigned long type
)
1731 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1738 get_ppc_dynamic_type (unsigned long type
)
1742 case DT_PPC_GOT
: return "PPC_GOT";
1743 case DT_PPC_OPT
: return "PPC_OPT";
1750 get_ppc64_dynamic_type (unsigned long type
)
1754 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1755 case DT_PPC64_OPD
: return "PPC64_OPD";
1756 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1757 case DT_PPC64_OPT
: return "PPC64_OPT";
1764 get_parisc_dynamic_type (unsigned long type
)
1768 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1769 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1770 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1771 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1772 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1773 case DT_HP_PREINIT
: return "HP_PREINIT";
1774 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1775 case DT_HP_NEEDED
: return "HP_NEEDED";
1776 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1777 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1778 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1779 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1780 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1781 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1782 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1783 case DT_HP_FILTERED
: return "HP_FILTERED";
1784 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1785 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1786 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1787 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1788 case DT_PLT
: return "PLT";
1789 case DT_PLT_SIZE
: return "PLT_SIZE";
1790 case DT_DLT
: return "DLT";
1791 case DT_DLT_SIZE
: return "DLT_SIZE";
1798 get_ia64_dynamic_type (unsigned long type
)
1802 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1803 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1804 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1805 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1806 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1807 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1808 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1809 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1810 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1811 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1812 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1813 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1814 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1815 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1816 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1817 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1818 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1819 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1820 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1821 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1822 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1823 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1824 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1825 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1826 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1827 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1828 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1829 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1830 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1831 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1832 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1839 get_alpha_dynamic_type (unsigned long type
)
1843 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1850 get_score_dynamic_type (unsigned long type
)
1854 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1855 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1856 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1857 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1858 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1859 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1866 get_tic6x_dynamic_type (unsigned long type
)
1870 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1871 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1872 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1873 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1874 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1875 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1882 get_nios2_dynamic_type (unsigned long type
)
1886 case DT_NIOS2_GP
: return "NIOS2_GP";
1893 get_dynamic_type (unsigned long type
)
1895 static char buff
[64];
1899 case DT_NULL
: return "NULL";
1900 case DT_NEEDED
: return "NEEDED";
1901 case DT_PLTRELSZ
: return "PLTRELSZ";
1902 case DT_PLTGOT
: return "PLTGOT";
1903 case DT_HASH
: return "HASH";
1904 case DT_STRTAB
: return "STRTAB";
1905 case DT_SYMTAB
: return "SYMTAB";
1906 case DT_RELA
: return "RELA";
1907 case DT_RELASZ
: return "RELASZ";
1908 case DT_RELAENT
: return "RELAENT";
1909 case DT_STRSZ
: return "STRSZ";
1910 case DT_SYMENT
: return "SYMENT";
1911 case DT_INIT
: return "INIT";
1912 case DT_FINI
: return "FINI";
1913 case DT_SONAME
: return "SONAME";
1914 case DT_RPATH
: return "RPATH";
1915 case DT_SYMBOLIC
: return "SYMBOLIC";
1916 case DT_REL
: return "REL";
1917 case DT_RELSZ
: return "RELSZ";
1918 case DT_RELENT
: return "RELENT";
1919 case DT_PLTREL
: return "PLTREL";
1920 case DT_DEBUG
: return "DEBUG";
1921 case DT_TEXTREL
: return "TEXTREL";
1922 case DT_JMPREL
: return "JMPREL";
1923 case DT_BIND_NOW
: return "BIND_NOW";
1924 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1925 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1926 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1927 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1928 case DT_RUNPATH
: return "RUNPATH";
1929 case DT_FLAGS
: return "FLAGS";
1931 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1932 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1934 case DT_CHECKSUM
: return "CHECKSUM";
1935 case DT_PLTPADSZ
: return "PLTPADSZ";
1936 case DT_MOVEENT
: return "MOVEENT";
1937 case DT_MOVESZ
: return "MOVESZ";
1938 case DT_FEATURE
: return "FEATURE";
1939 case DT_POSFLAG_1
: return "POSFLAG_1";
1940 case DT_SYMINSZ
: return "SYMINSZ";
1941 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1943 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1944 case DT_CONFIG
: return "CONFIG";
1945 case DT_DEPAUDIT
: return "DEPAUDIT";
1946 case DT_AUDIT
: return "AUDIT";
1947 case DT_PLTPAD
: return "PLTPAD";
1948 case DT_MOVETAB
: return "MOVETAB";
1949 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1951 case DT_VERSYM
: return "VERSYM";
1953 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1954 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1955 case DT_RELACOUNT
: return "RELACOUNT";
1956 case DT_RELCOUNT
: return "RELCOUNT";
1957 case DT_FLAGS_1
: return "FLAGS_1";
1958 case DT_VERDEF
: return "VERDEF";
1959 case DT_VERDEFNUM
: return "VERDEFNUM";
1960 case DT_VERNEED
: return "VERNEED";
1961 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1963 case DT_AUXILIARY
: return "AUXILIARY";
1964 case DT_USED
: return "USED";
1965 case DT_FILTER
: return "FILTER";
1967 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1968 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1969 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1970 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1971 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1972 case DT_GNU_HASH
: return "GNU_HASH";
1975 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1977 const char * result
;
1979 switch (elf_header
.e_machine
)
1982 case EM_MIPS_RS3_LE
:
1983 result
= get_mips_dynamic_type (type
);
1986 result
= get_sparc64_dynamic_type (type
);
1989 result
= get_ppc_dynamic_type (type
);
1992 result
= get_ppc64_dynamic_type (type
);
1995 result
= get_ia64_dynamic_type (type
);
1998 result
= get_alpha_dynamic_type (type
);
2001 result
= get_score_dynamic_type (type
);
2004 result
= get_tic6x_dynamic_type (type
);
2006 case EM_ALTERA_NIOS2
:
2007 result
= get_nios2_dynamic_type (type
);
2017 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2019 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2020 || (elf_header
.e_machine
== EM_PARISC
2021 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2023 const char * result
;
2025 switch (elf_header
.e_machine
)
2028 result
= get_parisc_dynamic_type (type
);
2031 result
= get_ia64_dynamic_type (type
);
2041 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2045 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2052 get_file_type (unsigned e_type
)
2054 static char buff
[32];
2058 case ET_NONE
: return _("NONE (None)");
2059 case ET_REL
: return _("REL (Relocatable file)");
2060 case ET_EXEC
: return _("EXEC (Executable file)");
2061 case ET_DYN
: return _("DYN (Shared object file)");
2062 case ET_CORE
: return _("CORE (Core file)");
2065 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2066 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2067 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2068 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2070 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2076 get_machine_name (unsigned e_machine
)
2078 static char buff
[64]; /* XXX */
2082 case EM_NONE
: return _("None");
2083 case EM_AARCH64
: return "AArch64";
2084 case EM_M32
: return "WE32100";
2085 case EM_SPARC
: return "Sparc";
2086 case EM_SPU
: return "SPU";
2087 case EM_386
: return "Intel 80386";
2088 case EM_68K
: return "MC68000";
2089 case EM_88K
: return "MC88000";
2090 case EM_IAMCU
: return "Intel MCU";
2091 case EM_860
: return "Intel 80860";
2092 case EM_MIPS
: return "MIPS R3000";
2093 case EM_S370
: return "IBM System/370";
2094 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2095 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2096 case EM_PARISC
: return "HPPA";
2097 case EM_PPC_OLD
: return "Power PC (old)";
2098 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2099 case EM_960
: return "Intel 90860";
2100 case EM_PPC
: return "PowerPC";
2101 case EM_PPC64
: return "PowerPC64";
2102 case EM_FR20
: return "Fujitsu FR20";
2103 case EM_FT32
: return "FTDI FT32";
2104 case EM_RH32
: return "TRW RH32";
2105 case EM_MCORE
: return "MCORE";
2106 case EM_ARM
: return "ARM";
2107 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2108 case EM_SH
: return "Renesas / SuperH SH";
2109 case EM_SPARCV9
: return "Sparc v9";
2110 case EM_TRICORE
: return "Siemens Tricore";
2111 case EM_ARC
: return "ARC";
2112 case EM_H8_300
: return "Renesas H8/300";
2113 case EM_H8_300H
: return "Renesas H8/300H";
2114 case EM_H8S
: return "Renesas H8S";
2115 case EM_H8_500
: return "Renesas H8/500";
2116 case EM_IA_64
: return "Intel IA-64";
2117 case EM_MIPS_X
: return "Stanford MIPS-X";
2118 case EM_COLDFIRE
: return "Motorola Coldfire";
2119 case EM_ALPHA
: return "Alpha";
2120 case EM_CYGNUS_D10V
:
2121 case EM_D10V
: return "d10v";
2122 case EM_CYGNUS_D30V
:
2123 case EM_D30V
: return "d30v";
2124 case EM_CYGNUS_M32R
:
2125 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2126 case EM_CYGNUS_V850
:
2127 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2128 case EM_V850
: return "Renesas V850";
2129 case EM_CYGNUS_MN10300
:
2130 case EM_MN10300
: return "mn10300";
2131 case EM_CYGNUS_MN10200
:
2132 case EM_MN10200
: return "mn10200";
2133 case EM_MOXIE
: return "Moxie";
2134 case EM_CYGNUS_FR30
:
2135 case EM_FR30
: return "Fujitsu FR30";
2136 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2138 case EM_PJ
: return "picoJava";
2139 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2140 case EM_PCP
: return "Siemens PCP";
2141 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2142 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2143 case EM_STARCORE
: return "Motorola Star*Core processor";
2144 case EM_ME16
: return "Toyota ME16 processor";
2145 case EM_ST100
: return "STMicroelectronics ST100 processor";
2146 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2147 case EM_PDSP
: return "Sony DSP processor";
2148 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2149 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2150 case EM_FX66
: return "Siemens FX66 microcontroller";
2151 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2152 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2153 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2154 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2155 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2156 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2157 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2158 case EM_SVX
: return "Silicon Graphics SVx";
2159 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2160 case EM_VAX
: return "Digital VAX";
2161 case EM_VISIUM
: return "CDS VISIUMcore processor";
2163 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2164 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2165 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2166 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2167 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2168 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2169 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2170 case EM_PRISM
: return "Vitesse Prism";
2171 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2172 case EM_L1OM
: return "Intel L1OM";
2173 case EM_K1OM
: return "Intel K1OM";
2175 case EM_S390
: return "IBM S/390";
2176 case EM_SCORE
: return "SUNPLUS S+Core";
2177 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2178 case EM_OR1K
: return "OpenRISC 1000";
2179 case EM_ARC_A5
: return "ARC International ARCompact processor";
2180 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2181 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2182 case EM_DLX
: return "OpenDLX";
2184 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2185 case EM_IQ2000
: return "Vitesse IQ2000";
2187 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2188 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2189 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2190 case EM_NS32K
: return "National Semiconductor 32000 series";
2191 case EM_TPC
: return "Tenor Network TPC processor";
2192 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2193 case EM_MAX
: return "MAX Processor";
2194 case EM_CR
: return "National Semiconductor CompactRISC";
2195 case EM_F2MC16
: return "Fujitsu F2MC16";
2196 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2197 case EM_LATTICEMICO32
: return "Lattice Mico32";
2199 case EM_M32C
: return "Renesas M32c";
2200 case EM_MT
: return "Morpho Techologies MT processor";
2201 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2202 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2203 case EM_SEP
: return "Sharp embedded microprocessor";
2204 case EM_ARCA
: return "Arca RISC microprocessor";
2205 case EM_UNICORE
: return "Unicore";
2206 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2207 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2208 case EM_NIOS32
: return "Altera Nios";
2209 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2211 case EM_XC16X
: return "Infineon Technologies xc16x";
2212 case EM_M16C
: return "Renesas M16C series microprocessors";
2213 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2214 case EM_CE
: return "Freescale Communication Engine RISC core";
2215 case EM_TSK3000
: return "Altium TSK3000 core";
2216 case EM_RS08
: return "Freescale RS08 embedded processor";
2217 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2218 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2219 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2220 case EM_SE_C17
: return "Seiko Epson C17 family";
2221 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2222 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2223 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2224 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2225 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2226 case EM_R32C
: return "Renesas R32C series microprocessors";
2227 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2228 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2229 case EM_8051
: return "Intel 8051 and variants";
2230 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2231 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2232 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2233 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2234 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2235 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2236 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2237 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2240 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2241 case EM_RL78
: return "Renesas RL78";
2242 case EM_RX
: return "Renesas RX";
2243 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2244 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2245 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2246 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2247 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2248 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2249 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2250 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2251 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2252 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2253 case EM_CUDA
: return "NVIDIA CUDA architecture";
2254 case EM_XGATE
: return "Motorola XGATE embedded processor";
2256 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2262 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2267 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2268 e_flags
&= ~ EF_ARM_EABIMASK
;
2270 /* Handle "generic" ARM flags. */
2271 if (e_flags
& EF_ARM_RELEXEC
)
2273 strcat (buf
, ", relocatable executable");
2274 e_flags
&= ~ EF_ARM_RELEXEC
;
2277 /* Now handle EABI specific flags. */
2281 strcat (buf
, ", <unrecognized EABI>");
2286 case EF_ARM_EABI_VER1
:
2287 strcat (buf
, ", Version1 EABI");
2292 /* Process flags one bit at a time. */
2293 flag
= e_flags
& - e_flags
;
2298 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2299 strcat (buf
, ", sorted symbol tables");
2309 case EF_ARM_EABI_VER2
:
2310 strcat (buf
, ", Version2 EABI");
2315 /* Process flags one bit at a time. */
2316 flag
= e_flags
& - e_flags
;
2321 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2322 strcat (buf
, ", sorted symbol tables");
2325 case EF_ARM_DYNSYMSUSESEGIDX
:
2326 strcat (buf
, ", dynamic symbols use segment index");
2329 case EF_ARM_MAPSYMSFIRST
:
2330 strcat (buf
, ", mapping symbols precede others");
2340 case EF_ARM_EABI_VER3
:
2341 strcat (buf
, ", Version3 EABI");
2344 case EF_ARM_EABI_VER4
:
2345 strcat (buf
, ", Version4 EABI");
2350 /* Process flags one bit at a time. */
2351 flag
= e_flags
& - e_flags
;
2357 strcat (buf
, ", BE8");
2361 strcat (buf
, ", LE8");
2372 case EF_ARM_EABI_VER5
:
2373 strcat (buf
, ", Version5 EABI");
2378 /* Process flags one bit at a time. */
2379 flag
= e_flags
& - e_flags
;
2385 strcat (buf
, ", BE8");
2389 strcat (buf
, ", LE8");
2392 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2393 strcat (buf
, ", soft-float ABI");
2396 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2397 strcat (buf
, ", hard-float ABI");
2407 case EF_ARM_EABI_UNKNOWN
:
2408 strcat (buf
, ", GNU EABI");
2413 /* Process flags one bit at a time. */
2414 flag
= e_flags
& - e_flags
;
2419 case EF_ARM_INTERWORK
:
2420 strcat (buf
, ", interworking enabled");
2423 case EF_ARM_APCS_26
:
2424 strcat (buf
, ", uses APCS/26");
2427 case EF_ARM_APCS_FLOAT
:
2428 strcat (buf
, ", uses APCS/float");
2432 strcat (buf
, ", position independent");
2436 strcat (buf
, ", 8 bit structure alignment");
2439 case EF_ARM_NEW_ABI
:
2440 strcat (buf
, ", uses new ABI");
2443 case EF_ARM_OLD_ABI
:
2444 strcat (buf
, ", uses old ABI");
2447 case EF_ARM_SOFT_FLOAT
:
2448 strcat (buf
, ", software FP");
2451 case EF_ARM_VFP_FLOAT
:
2452 strcat (buf
, ", VFP");
2455 case EF_ARM_MAVERICK_FLOAT
:
2456 strcat (buf
, ", Maverick FP");
2467 strcat (buf
,_(", <unknown>"));
2471 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2473 --size
; /* Leave space for null terminator. */
2475 switch (e_flags
& EF_AVR_MACH
)
2477 case E_AVR_MACH_AVR1
:
2478 strncat (buf
, ", avr:1", size
);
2480 case E_AVR_MACH_AVR2
:
2481 strncat (buf
, ", avr:2", size
);
2483 case E_AVR_MACH_AVR25
:
2484 strncat (buf
, ", avr:25", size
);
2486 case E_AVR_MACH_AVR3
:
2487 strncat (buf
, ", avr:3", size
);
2489 case E_AVR_MACH_AVR31
:
2490 strncat (buf
, ", avr:31", size
);
2492 case E_AVR_MACH_AVR35
:
2493 strncat (buf
, ", avr:35", size
);
2495 case E_AVR_MACH_AVR4
:
2496 strncat (buf
, ", avr:4", size
);
2498 case E_AVR_MACH_AVR5
:
2499 strncat (buf
, ", avr:5", size
);
2501 case E_AVR_MACH_AVR51
:
2502 strncat (buf
, ", avr:51", size
);
2504 case E_AVR_MACH_AVR6
:
2505 strncat (buf
, ", avr:6", size
);
2507 case E_AVR_MACH_AVRTINY
:
2508 strncat (buf
, ", avr:100", size
);
2510 case E_AVR_MACH_XMEGA1
:
2511 strncat (buf
, ", avr:101", size
);
2513 case E_AVR_MACH_XMEGA2
:
2514 strncat (buf
, ", avr:102", size
);
2516 case E_AVR_MACH_XMEGA3
:
2517 strncat (buf
, ", avr:103", size
);
2519 case E_AVR_MACH_XMEGA4
:
2520 strncat (buf
, ", avr:104", size
);
2522 case E_AVR_MACH_XMEGA5
:
2523 strncat (buf
, ", avr:105", size
);
2525 case E_AVR_MACH_XMEGA6
:
2526 strncat (buf
, ", avr:106", size
);
2528 case E_AVR_MACH_XMEGA7
:
2529 strncat (buf
, ", avr:107", size
);
2532 strncat (buf
, ", avr:<unknown>", size
);
2536 size
-= strlen (buf
);
2537 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2538 strncat (buf
, ", link-relax", size
);
2542 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2551 static const char *ABI_STRINGS
[] =
2553 "ABI v0", /* use r5 as return register; only used in N1213HC */
2554 "ABI v1", /* use r0 as return register */
2555 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2556 "ABI v2fp", /* for FPU */
2560 static const char *VER_STRINGS
[] =
2562 "Andes ELF V1.3 or older",
2566 static const char *ARCH_STRINGS
[] =
2575 abi
= EF_NDS_ABI
& e_flags
;
2576 arch
= EF_NDS_ARCH
& e_flags
;
2577 config
= EF_NDS_INST
& e_flags
;
2578 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2580 memset (buf
, 0, size
);
2587 case E_NDS_ABI_V2FP
:
2588 case E_NDS_ABI_AABI
:
2589 case E_NDS_ABI_V2FP_PLUS
:
2590 /* In case there are holes in the array. */
2591 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2595 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2601 case E_NDS32_ELF_VER_1_2
:
2602 case E_NDS32_ELF_VER_1_3
:
2603 case E_NDS32_ELF_VER_1_4
:
2604 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2608 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2612 if (E_NDS_ABI_V0
== abi
)
2614 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2615 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2616 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2617 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2623 case E_NDS_ARCH_STAR_V1_0
:
2624 case E_NDS_ARCH_STAR_V2_0
:
2625 case E_NDS_ARCH_STAR_V3_0
:
2626 case E_NDS_ARCH_STAR_V3_M
:
2627 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2631 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2632 /* ARCH version determines how the e_flags are interpreted.
2633 If it is unknown, we cannot proceed. */
2637 /* Newer ABI; Now handle architecture specific flags. */
2638 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2640 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2641 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2643 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2644 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2646 if (config
& E_NDS32_HAS_DIV_INST
)
2647 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2649 if (config
& E_NDS32_HAS_16BIT_INST
)
2650 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2654 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2656 if (version
<= E_NDS32_ELF_VER_1_3
)
2657 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2659 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2662 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2663 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2665 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2666 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2668 if (config
& E_NDS32_HAS_16BIT_INST
)
2670 if (version
<= E_NDS32_ELF_VER_1_3
)
2671 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2673 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2677 if (config
& E_NDS32_HAS_EXT_INST
)
2678 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2680 if (config
& E_NDS32_HAS_EXT2_INST
)
2681 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2683 if (config
& E_NDS32_HAS_FPU_INST
)
2686 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2689 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2692 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2695 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2703 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2705 case E_NDS32_FPU_REG_8SP_4DP
:
2706 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2708 case E_NDS32_FPU_REG_16SP_8DP
:
2709 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2711 case E_NDS32_FPU_REG_32SP_16DP
:
2712 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2714 case E_NDS32_FPU_REG_32SP_32DP
:
2715 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2720 if (config
& E_NDS32_HAS_AUDIO_INST
)
2721 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2723 if (config
& E_NDS32_HAS_STRING_INST
)
2724 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2726 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2727 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2729 if (config
& E_NDS32_HAS_VIDEO_INST
)
2731 if (version
<= E_NDS32_ELF_VER_1_3
)
2732 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2734 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2737 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2738 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2740 if (config
& E_NDS32_HAS_L2C_INST
)
2741 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2745 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2747 static char buf
[1024];
2759 decode_ARM_machine_flags (e_flags
, buf
);
2763 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2767 if (e_flags
& EF_BFIN_PIC
)
2768 strcat (buf
, ", PIC");
2770 if (e_flags
& EF_BFIN_FDPIC
)
2771 strcat (buf
, ", FDPIC");
2773 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2774 strcat (buf
, ", code in L1");
2776 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2777 strcat (buf
, ", data in L1");
2782 switch (e_flags
& EF_FRV_CPU_MASK
)
2784 case EF_FRV_CPU_GENERIC
:
2788 strcat (buf
, ", fr???");
2791 case EF_FRV_CPU_FR300
:
2792 strcat (buf
, ", fr300");
2795 case EF_FRV_CPU_FR400
:
2796 strcat (buf
, ", fr400");
2798 case EF_FRV_CPU_FR405
:
2799 strcat (buf
, ", fr405");
2802 case EF_FRV_CPU_FR450
:
2803 strcat (buf
, ", fr450");
2806 case EF_FRV_CPU_FR500
:
2807 strcat (buf
, ", fr500");
2809 case EF_FRV_CPU_FR550
:
2810 strcat (buf
, ", fr550");
2813 case EF_FRV_CPU_SIMPLE
:
2814 strcat (buf
, ", simple");
2816 case EF_FRV_CPU_TOMCAT
:
2817 strcat (buf
, ", tomcat");
2823 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2824 strcat (buf
, ", m68000");
2825 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2826 strcat (buf
, ", cpu32");
2827 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2828 strcat (buf
, ", fido_a");
2831 char const * isa
= _("unknown");
2832 char const * mac
= _("unknown mac");
2833 char const * additional
= NULL
;
2835 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2837 case EF_M68K_CF_ISA_A_NODIV
:
2839 additional
= ", nodiv";
2841 case EF_M68K_CF_ISA_A
:
2844 case EF_M68K_CF_ISA_A_PLUS
:
2847 case EF_M68K_CF_ISA_B_NOUSP
:
2849 additional
= ", nousp";
2851 case EF_M68K_CF_ISA_B
:
2854 case EF_M68K_CF_ISA_C
:
2857 case EF_M68K_CF_ISA_C_NODIV
:
2859 additional
= ", nodiv";
2862 strcat (buf
, ", cf, isa ");
2865 strcat (buf
, additional
);
2866 if (e_flags
& EF_M68K_CF_FLOAT
)
2867 strcat (buf
, ", float");
2868 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2873 case EF_M68K_CF_MAC
:
2876 case EF_M68K_CF_EMAC
:
2879 case EF_M68K_CF_EMAC_B
:
2892 switch (e_flags
& EF_MEP_CPU_MASK
)
2894 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2895 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2896 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2897 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2898 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2899 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2900 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2903 switch (e_flags
& EF_MEP_COP_MASK
)
2905 case EF_MEP_COP_NONE
: break;
2906 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2907 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2908 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
2909 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
2910 default: strcat (buf
, _("<unknown MeP copro type>")); break;
2913 if (e_flags
& EF_MEP_LIBRARY
)
2914 strcat (buf
, ", Built for Library");
2916 if (e_flags
& EF_MEP_INDEX_MASK
)
2917 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
2918 e_flags
& EF_MEP_INDEX_MASK
);
2920 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
2921 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
2922 e_flags
& ~ EF_MEP_ALL_FLAGS
);
2926 if (e_flags
& EF_PPC_EMB
)
2927 strcat (buf
, ", emb");
2929 if (e_flags
& EF_PPC_RELOCATABLE
)
2930 strcat (buf
, _(", relocatable"));
2932 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2933 strcat (buf
, _(", relocatable-lib"));
2937 if (e_flags
& EF_PPC64_ABI
)
2939 char abi
[] = ", abiv0";
2941 abi
[6] += e_flags
& EF_PPC64_ABI
;
2947 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2948 strcat (buf
, ", RH850 ABI");
2950 if (e_flags
& EF_V800_850E3
)
2951 strcat (buf
, ", V3 architecture");
2953 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2954 strcat (buf
, ", FPU not used");
2956 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2957 strcat (buf
, ", regmode: COMMON");
2959 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2960 strcat (buf
, ", r4 not used");
2962 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2963 strcat (buf
, ", r30 not used");
2965 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2966 strcat (buf
, ", r5 not used");
2968 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2969 strcat (buf
, ", r2 not used");
2971 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2973 switch (e_flags
& - e_flags
)
2975 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2976 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2977 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2978 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2979 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2980 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2981 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2982 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2983 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2984 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2985 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2986 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2993 case EM_CYGNUS_V850
:
2994 switch (e_flags
& EF_V850_ARCH
)
2996 case E_V850E3V5_ARCH
:
2997 strcat (buf
, ", v850e3v5");
2999 case E_V850E2V3_ARCH
:
3000 strcat (buf
, ", v850e2v3");
3003 strcat (buf
, ", v850e2");
3006 strcat (buf
, ", v850e1");
3009 strcat (buf
, ", v850e");
3012 strcat (buf
, ", v850");
3015 strcat (buf
, _(", unknown v850 architecture variant"));
3021 case EM_CYGNUS_M32R
:
3022 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3023 strcat (buf
, ", m32r");
3027 case EM_MIPS_RS3_LE
:
3028 if (e_flags
& EF_MIPS_NOREORDER
)
3029 strcat (buf
, ", noreorder");
3031 if (e_flags
& EF_MIPS_PIC
)
3032 strcat (buf
, ", pic");
3034 if (e_flags
& EF_MIPS_CPIC
)
3035 strcat (buf
, ", cpic");
3037 if (e_flags
& EF_MIPS_UCODE
)
3038 strcat (buf
, ", ugen_reserved");
3040 if (e_flags
& EF_MIPS_ABI2
)
3041 strcat (buf
, ", abi2");
3043 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3044 strcat (buf
, ", odk first");
3046 if (e_flags
& EF_MIPS_32BITMODE
)
3047 strcat (buf
, ", 32bitmode");
3049 if (e_flags
& EF_MIPS_NAN2008
)
3050 strcat (buf
, ", nan2008");
3052 if (e_flags
& EF_MIPS_FP64
)
3053 strcat (buf
, ", fp64");
3055 switch ((e_flags
& EF_MIPS_MACH
))
3057 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3058 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3059 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3060 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3061 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3062 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3063 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3064 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3065 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3066 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3067 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3068 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3069 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3070 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3071 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3072 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3073 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3075 /* We simply ignore the field in this case to avoid confusion:
3076 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3079 default: strcat (buf
, _(", unknown CPU")); break;
3082 switch ((e_flags
& EF_MIPS_ABI
))
3084 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3085 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3086 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3087 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3089 /* We simply ignore the field in this case to avoid confusion:
3090 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3091 This means it is likely to be an o32 file, but not for
3094 default: strcat (buf
, _(", unknown ABI")); break;
3097 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3098 strcat (buf
, ", mdmx");
3100 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3101 strcat (buf
, ", mips16");
3103 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3104 strcat (buf
, ", micromips");
3106 switch ((e_flags
& EF_MIPS_ARCH
))
3108 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3109 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3110 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3111 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3112 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3113 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3114 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3115 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3116 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3117 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3118 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3119 default: strcat (buf
, _(", unknown ISA")); break;
3124 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3128 switch ((e_flags
& EF_SH_MACH_MASK
))
3130 case EF_SH1
: strcat (buf
, ", sh1"); break;
3131 case EF_SH2
: strcat (buf
, ", sh2"); break;
3132 case EF_SH3
: strcat (buf
, ", sh3"); break;
3133 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3134 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3135 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3136 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3137 case EF_SH4
: strcat (buf
, ", sh4"); break;
3138 case EF_SH5
: strcat (buf
, ", sh5"); break;
3139 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3140 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3141 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3142 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3143 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3144 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3145 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3146 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3147 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3148 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3149 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3150 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3151 default: strcat (buf
, _(", unknown ISA")); break;
3154 if (e_flags
& EF_SH_PIC
)
3155 strcat (buf
, ", pic");
3157 if (e_flags
& EF_SH_FDPIC
)
3158 strcat (buf
, ", fdpic");
3162 if (e_flags
& EF_OR1K_NODELAY
)
3163 strcat (buf
, ", no delay");
3167 if (e_flags
& EF_SPARC_32PLUS
)
3168 strcat (buf
, ", v8+");
3170 if (e_flags
& EF_SPARC_SUN_US1
)
3171 strcat (buf
, ", ultrasparcI");
3173 if (e_flags
& EF_SPARC_SUN_US3
)
3174 strcat (buf
, ", ultrasparcIII");
3176 if (e_flags
& EF_SPARC_HAL_R1
)
3177 strcat (buf
, ", halr1");
3179 if (e_flags
& EF_SPARC_LEDATA
)
3180 strcat (buf
, ", ledata");
3182 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3183 strcat (buf
, ", tso");
3185 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3186 strcat (buf
, ", pso");
3188 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3189 strcat (buf
, ", rmo");
3193 switch (e_flags
& EF_PARISC_ARCH
)
3195 case EFA_PARISC_1_0
:
3196 strcpy (buf
, ", PA-RISC 1.0");
3198 case EFA_PARISC_1_1
:
3199 strcpy (buf
, ", PA-RISC 1.1");
3201 case EFA_PARISC_2_0
:
3202 strcpy (buf
, ", PA-RISC 2.0");
3207 if (e_flags
& EF_PARISC_TRAPNIL
)
3208 strcat (buf
, ", trapnil");
3209 if (e_flags
& EF_PARISC_EXT
)
3210 strcat (buf
, ", ext");
3211 if (e_flags
& EF_PARISC_LSB
)
3212 strcat (buf
, ", lsb");
3213 if (e_flags
& EF_PARISC_WIDE
)
3214 strcat (buf
, ", wide");
3215 if (e_flags
& EF_PARISC_NO_KABP
)
3216 strcat (buf
, ", no kabp");
3217 if (e_flags
& EF_PARISC_LAZYSWAP
)
3218 strcat (buf
, ", lazyswap");
3223 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3224 strcat (buf
, ", new calling convention");
3226 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3227 strcat (buf
, ", gnu calling convention");
3231 if ((e_flags
& EF_IA_64_ABI64
))
3232 strcat (buf
, ", 64-bit");
3234 strcat (buf
, ", 32-bit");
3235 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3236 strcat (buf
, ", reduced fp model");
3237 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3238 strcat (buf
, ", no function descriptors, constant gp");
3239 else if ((e_flags
& EF_IA_64_CONS_GP
))
3240 strcat (buf
, ", constant gp");
3241 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3242 strcat (buf
, ", absolute");
3243 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3245 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3246 strcat (buf
, ", vms_linkages");
3247 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3249 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3251 case EF_IA_64_VMS_COMCOD_WARNING
:
3252 strcat (buf
, ", warning");
3254 case EF_IA_64_VMS_COMCOD_ERROR
:
3255 strcat (buf
, ", error");
3257 case EF_IA_64_VMS_COMCOD_ABORT
:
3258 strcat (buf
, ", abort");
3261 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3262 e_flags
& EF_IA_64_VMS_COMCOD
);
3263 strcat (buf
, ", <unknown>");
3269 if ((e_flags
& EF_VAX_NONPIC
))
3270 strcat (buf
, ", non-PIC");
3271 if ((e_flags
& EF_VAX_DFLOAT
))
3272 strcat (buf
, ", D-Float");
3273 if ((e_flags
& EF_VAX_GFLOAT
))
3274 strcat (buf
, ", G-Float");
3278 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3279 strcat (buf
, ", mcm");
3280 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3281 strcat (buf
, ", mcm24");
3282 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3283 strcat (buf
, ", gr6");
3287 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3289 case E_FLAG_RL78_ANY_CPU
: break;
3290 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3291 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3292 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3294 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3295 strcat (buf
, ", 64-bit doubles");
3299 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3300 strcat (buf
, ", 64-bit doubles");
3301 if (e_flags
& E_FLAG_RX_DSP
)
3302 strcat (buf
, ", dsp");
3303 if (e_flags
& E_FLAG_RX_PID
)
3304 strcat (buf
, ", pid");
3305 if (e_flags
& E_FLAG_RX_ABI
)
3306 strcat (buf
, ", RX ABI");
3307 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3308 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3309 ? ", uses String instructions" : ", bans String instructions");
3313 if (e_flags
& EF_S390_HIGH_GPRS
)
3314 strcat (buf
, ", highgprs");
3318 if ((e_flags
& EF_C6000_REL
))
3319 strcat (buf
, ", relocatable module");
3323 strcat (buf
, _(": architecture variant: "));
3324 switch (e_flags
& EF_MSP430_MACH
)
3326 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3327 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3328 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3329 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3330 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3331 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3332 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3333 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3334 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3335 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3336 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3337 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3338 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3339 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3340 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3342 strcat (buf
, _(": unknown")); break;
3345 if (e_flags
& ~ EF_MSP430_MACH
)
3346 strcat (buf
, _(": unknown extra flag bits also present"));
3354 get_osabi_name (unsigned int osabi
)
3356 static char buff
[32];
3360 case ELFOSABI_NONE
: return "UNIX - System V";
3361 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3362 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3363 case ELFOSABI_GNU
: return "UNIX - GNU";
3364 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3365 case ELFOSABI_AIX
: return "UNIX - AIX";
3366 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3367 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3368 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3369 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3370 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3371 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3372 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3373 case ELFOSABI_AROS
: return "AROS";
3374 case ELFOSABI_FENIXOS
: return "FenixOS";
3377 switch (elf_header
.e_machine
)
3382 case ELFOSABI_ARM
: return "ARM";
3393 case ELFOSABI_STANDALONE
: return _("Standalone App");
3402 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3403 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3412 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3418 get_aarch64_segment_type (unsigned long type
)
3422 case PT_AARCH64_ARCHEXT
:
3423 return "AARCH64_ARCHEXT";
3432 get_arm_segment_type (unsigned long type
)
3446 get_mips_segment_type (unsigned long type
)
3450 case PT_MIPS_REGINFO
:
3452 case PT_MIPS_RTPROC
:
3454 case PT_MIPS_OPTIONS
:
3456 case PT_MIPS_ABIFLAGS
:
3466 get_parisc_segment_type (unsigned long type
)
3470 case PT_HP_TLS
: return "HP_TLS";
3471 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3472 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3473 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3474 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3475 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3476 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3477 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3478 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3479 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3480 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3481 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3482 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3483 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3484 case PT_HP_STACK
: return "HP_STACK";
3485 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3486 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3487 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3488 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3497 get_ia64_segment_type (unsigned long type
)
3501 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3502 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3503 case PT_HP_TLS
: return "HP_TLS";
3504 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3505 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3506 case PT_IA_64_HP_STACK
: return "HP_STACK";
3515 get_tic6x_segment_type (unsigned long type
)
3519 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3528 get_segment_type (unsigned long p_type
)
3530 static char buff
[32];
3534 case PT_NULL
: return "NULL";
3535 case PT_LOAD
: return "LOAD";
3536 case PT_DYNAMIC
: return "DYNAMIC";
3537 case PT_INTERP
: return "INTERP";
3538 case PT_NOTE
: return "NOTE";
3539 case PT_SHLIB
: return "SHLIB";
3540 case PT_PHDR
: return "PHDR";
3541 case PT_TLS
: return "TLS";
3543 case PT_GNU_EH_FRAME
:
3544 return "GNU_EH_FRAME";
3545 case PT_GNU_STACK
: return "GNU_STACK";
3546 case PT_GNU_RELRO
: return "GNU_RELRO";
3549 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3551 const char * result
;
3553 switch (elf_header
.e_machine
)
3556 result
= get_aarch64_segment_type (p_type
);
3559 result
= get_arm_segment_type (p_type
);
3562 case EM_MIPS_RS3_LE
:
3563 result
= get_mips_segment_type (p_type
);
3566 result
= get_parisc_segment_type (p_type
);
3569 result
= get_ia64_segment_type (p_type
);
3572 result
= get_tic6x_segment_type (p_type
);
3582 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3584 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3586 const char * result
;
3588 switch (elf_header
.e_machine
)
3591 result
= get_parisc_segment_type (p_type
);
3594 result
= get_ia64_segment_type (p_type
);
3604 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3607 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3614 get_mips_section_type_name (unsigned int sh_type
)
3618 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3619 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3620 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3621 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3622 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3623 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3624 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3625 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3626 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3627 case SHT_MIPS_RELD
: return "MIPS_RELD";
3628 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3629 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3630 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3631 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3632 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3633 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3634 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3635 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3636 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3637 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3638 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3639 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3640 case SHT_MIPS_LINE
: return "MIPS_LINE";
3641 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3642 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3643 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3644 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3645 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3646 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3647 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3648 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3649 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3650 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3651 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3652 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3653 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3654 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3655 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3656 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3657 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3665 get_parisc_section_type_name (unsigned int sh_type
)
3669 case SHT_PARISC_EXT
: return "PARISC_EXT";
3670 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3671 case SHT_PARISC_DOC
: return "PARISC_DOC";
3672 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3673 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3674 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3675 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3683 get_ia64_section_type_name (unsigned int sh_type
)
3685 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3686 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3687 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3691 case SHT_IA_64_EXT
: return "IA_64_EXT";
3692 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3693 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3694 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3695 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3696 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3697 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3698 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3699 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3700 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3708 get_x86_64_section_type_name (unsigned int sh_type
)
3712 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3720 get_aarch64_section_type_name (unsigned int sh_type
)
3724 case SHT_AARCH64_ATTRIBUTES
:
3725 return "AARCH64_ATTRIBUTES";
3733 get_arm_section_type_name (unsigned int sh_type
)
3737 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3738 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3739 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3740 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3741 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3749 get_tic6x_section_type_name (unsigned int sh_type
)
3753 case SHT_C6000_UNWIND
:
3754 return "C6000_UNWIND";
3755 case SHT_C6000_PREEMPTMAP
:
3756 return "C6000_PREEMPTMAP";
3757 case SHT_C6000_ATTRIBUTES
:
3758 return "C6000_ATTRIBUTES";
3763 case SHT_TI_HANDLER
:
3764 return "TI_HANDLER";
3765 case SHT_TI_INITINFO
:
3766 return "TI_INITINFO";
3767 case SHT_TI_PHATTRS
:
3768 return "TI_PHATTRS";
3776 get_msp430x_section_type_name (unsigned int sh_type
)
3780 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3781 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3782 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3783 default: return NULL
;
3788 get_v850_section_type_name (unsigned int sh_type
)
3792 case SHT_V850_SCOMMON
: return "V850 Small Common";
3793 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3794 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3795 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3796 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3797 default: return NULL
;
3802 get_section_type_name (unsigned int sh_type
)
3804 static char buff
[32];
3808 case SHT_NULL
: return "NULL";
3809 case SHT_PROGBITS
: return "PROGBITS";
3810 case SHT_SYMTAB
: return "SYMTAB";
3811 case SHT_STRTAB
: return "STRTAB";
3812 case SHT_RELA
: return "RELA";
3813 case SHT_HASH
: return "HASH";
3814 case SHT_DYNAMIC
: return "DYNAMIC";
3815 case SHT_NOTE
: return "NOTE";
3816 case SHT_NOBITS
: return "NOBITS";
3817 case SHT_REL
: return "REL";
3818 case SHT_SHLIB
: return "SHLIB";
3819 case SHT_DYNSYM
: return "DYNSYM";
3820 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3821 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3822 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3823 case SHT_GNU_HASH
: return "GNU_HASH";
3824 case SHT_GROUP
: return "GROUP";
3825 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3826 case SHT_GNU_verdef
: return "VERDEF";
3827 case SHT_GNU_verneed
: return "VERNEED";
3828 case SHT_GNU_versym
: return "VERSYM";
3829 case 0x6ffffff0: return "VERSYM";
3830 case 0x6ffffffc: return "VERDEF";
3831 case 0x7ffffffd: return "AUXILIARY";
3832 case 0x7fffffff: return "FILTER";
3833 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3836 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3838 const char * result
;
3840 switch (elf_header
.e_machine
)
3843 case EM_MIPS_RS3_LE
:
3844 result
= get_mips_section_type_name (sh_type
);
3847 result
= get_parisc_section_type_name (sh_type
);
3850 result
= get_ia64_section_type_name (sh_type
);
3855 result
= get_x86_64_section_type_name (sh_type
);
3858 result
= get_aarch64_section_type_name (sh_type
);
3861 result
= get_arm_section_type_name (sh_type
);
3864 result
= get_tic6x_section_type_name (sh_type
);
3867 result
= get_msp430x_section_type_name (sh_type
);
3871 case EM_CYGNUS_V850
:
3872 result
= get_v850_section_type_name (sh_type
);
3882 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3884 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3886 const char * result
;
3888 switch (elf_header
.e_machine
)
3891 result
= get_ia64_section_type_name (sh_type
);
3901 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3903 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3905 switch (elf_header
.e_machine
)
3909 case EM_CYGNUS_V850
:
3910 return get_v850_section_type_name (sh_type
);
3915 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3918 /* This message is probably going to be displayed in a 15
3919 character wide field, so put the hex value first. */
3920 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3926 #define OPTION_DEBUG_DUMP 512
3927 #define OPTION_DYN_SYMS 513
3928 #define OPTION_DWARF_DEPTH 514
3929 #define OPTION_DWARF_START 515
3930 #define OPTION_DWARF_CHECK 516
3932 static struct option options
[] =
3934 {"all", no_argument
, 0, 'a'},
3935 {"file-header", no_argument
, 0, 'h'},
3936 {"program-headers", no_argument
, 0, 'l'},
3937 {"headers", no_argument
, 0, 'e'},
3938 {"histogram", no_argument
, 0, 'I'},
3939 {"segments", no_argument
, 0, 'l'},
3940 {"sections", no_argument
, 0, 'S'},
3941 {"section-headers", no_argument
, 0, 'S'},
3942 {"section-groups", no_argument
, 0, 'g'},
3943 {"section-details", no_argument
, 0, 't'},
3944 {"full-section-name",no_argument
, 0, 'N'},
3945 {"symbols", no_argument
, 0, 's'},
3946 {"syms", no_argument
, 0, 's'},
3947 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3948 {"relocs", no_argument
, 0, 'r'},
3949 {"notes", no_argument
, 0, 'n'},
3950 {"dynamic", no_argument
, 0, 'd'},
3951 {"arch-specific", no_argument
, 0, 'A'},
3952 {"version-info", no_argument
, 0, 'V'},
3953 {"use-dynamic", no_argument
, 0, 'D'},
3954 {"unwind", no_argument
, 0, 'u'},
3955 {"archive-index", no_argument
, 0, 'c'},
3956 {"hex-dump", required_argument
, 0, 'x'},
3957 {"relocated-dump", required_argument
, 0, 'R'},
3958 {"string-dump", required_argument
, 0, 'p'},
3959 {"decompress", no_argument
, 0, 'z'},
3960 #ifdef SUPPORT_DISASSEMBLY
3961 {"instruction-dump", required_argument
, 0, 'i'},
3963 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3965 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3966 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3967 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3969 {"version", no_argument
, 0, 'v'},
3970 {"wide", no_argument
, 0, 'W'},
3971 {"help", no_argument
, 0, 'H'},
3972 {0, no_argument
, 0, 0}
3976 usage (FILE * stream
)
3978 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3979 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3980 fprintf (stream
, _(" Options are:\n\
3981 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3982 -h --file-header Display the ELF file header\n\
3983 -l --program-headers Display the program headers\n\
3984 --segments An alias for --program-headers\n\
3985 -S --section-headers Display the sections' header\n\
3986 --sections An alias for --section-headers\n\
3987 -g --section-groups Display the section groups\n\
3988 -t --section-details Display the section details\n\
3989 -e --headers Equivalent to: -h -l -S\n\
3990 -s --syms Display the symbol table\n\
3991 --symbols An alias for --syms\n\
3992 --dyn-syms Display the dynamic symbol table\n\
3993 -n --notes Display the core notes (if present)\n\
3994 -r --relocs Display the relocations (if present)\n\
3995 -u --unwind Display the unwind info (if present)\n\
3996 -d --dynamic Display the dynamic section (if present)\n\
3997 -V --version-info Display the version sections (if present)\n\
3998 -A --arch-specific Display architecture specific information (if any)\n\
3999 -c --archive-index Display the symbol/file index in an archive\n\
4000 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4001 -x --hex-dump=<number|name>\n\
4002 Dump the contents of section <number|name> as bytes\n\
4003 -p --string-dump=<number|name>\n\
4004 Dump the contents of section <number|name> as strings\n\
4005 -R --relocated-dump=<number|name>\n\
4006 Dump the contents of section <number|name> as relocated bytes\n\
4007 -z --decompress Decompress section before dumping it\n\
4008 -w[lLiaprmfFsoRt] or\n\
4009 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4010 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4011 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4013 Display the contents of DWARF2 debug sections\n"));
4014 fprintf (stream
, _("\
4015 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4016 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4018 #ifdef SUPPORT_DISASSEMBLY
4019 fprintf (stream
, _("\
4020 -i --instruction-dump=<number|name>\n\
4021 Disassemble the contents of section <number|name>\n"));
4023 fprintf (stream
, _("\
4024 -I --histogram Display histogram of bucket list lengths\n\
4025 -W --wide Allow output width to exceed 80 characters\n\
4026 @<file> Read options from <file>\n\
4027 -H --help Display this information\n\
4028 -v --version Display the version number of readelf\n"));
4030 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4031 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4033 exit (stream
== stdout
? 0 : 1);
4036 /* Record the fact that the user wants the contents of section number
4037 SECTION to be displayed using the method(s) encoded as flags bits
4038 in TYPE. Note, TYPE can be zero if we are creating the array for
4042 request_dump_bynumber (unsigned int section
, dump_type type
)
4044 if (section
>= num_dump_sects
)
4046 dump_type
* new_dump_sects
;
4048 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4049 sizeof (* dump_sects
));
4051 if (new_dump_sects
== NULL
)
4052 error (_("Out of memory allocating dump request table.\n"));
4055 /* Copy current flag settings. */
4056 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4060 dump_sects
= new_dump_sects
;
4061 num_dump_sects
= section
+ 1;
4066 dump_sects
[section
] |= type
;
4071 /* Request a dump by section name. */
4074 request_dump_byname (const char * section
, dump_type type
)
4076 struct dump_list_entry
* new_request
;
4078 new_request
= (struct dump_list_entry
*)
4079 malloc (sizeof (struct dump_list_entry
));
4081 error (_("Out of memory allocating dump request table.\n"));
4083 new_request
->name
= strdup (section
);
4084 if (!new_request
->name
)
4085 error (_("Out of memory allocating dump request table.\n"));
4087 new_request
->type
= type
;
4089 new_request
->next
= dump_sects_byname
;
4090 dump_sects_byname
= new_request
;
4094 request_dump (dump_type type
)
4100 section
= strtoul (optarg
, & cp
, 0);
4102 if (! *cp
&& section
>= 0)
4103 request_dump_bynumber (section
, type
);
4105 request_dump_byname (optarg
, type
);
4110 parse_args (int argc
, char ** argv
)
4117 while ((c
= getopt_long
4118 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4136 do_section_groups
++;
4144 do_section_groups
++;
4149 do_section_details
++;
4193 request_dump (HEX_DUMP
);
4196 request_dump (STRING_DUMP
);
4199 request_dump (RELOC_DUMP
);
4209 dwarf_select_sections_all ();
4214 dwarf_select_sections_by_letters (optarg
);
4217 case OPTION_DEBUG_DUMP
:
4224 dwarf_select_sections_by_names (optarg
);
4227 case OPTION_DWARF_DEPTH
:
4231 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4234 case OPTION_DWARF_START
:
4238 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4241 case OPTION_DWARF_CHECK
:
4244 case OPTION_DYN_SYMS
:
4247 #ifdef SUPPORT_DISASSEMBLY
4249 request_dump (DISASS_DUMP
);
4253 print_version (program_name
);
4262 /* xgettext:c-format */
4263 error (_("Invalid option '-%c'\n"), c
);
4270 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4271 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4272 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4273 && !do_section_groups
&& !do_archive_index
4279 get_elf_class (unsigned int elf_class
)
4281 static char buff
[32];
4285 case ELFCLASSNONE
: return _("none");
4286 case ELFCLASS32
: return "ELF32";
4287 case ELFCLASS64
: return "ELF64";
4289 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4295 get_data_encoding (unsigned int encoding
)
4297 static char buff
[32];
4301 case ELFDATANONE
: return _("none");
4302 case ELFDATA2LSB
: return _("2's complement, little endian");
4303 case ELFDATA2MSB
: return _("2's complement, big endian");
4305 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4310 /* Decode the data held in 'elf_header'. */
4313 process_file_header (void)
4315 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4316 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4317 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4318 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4321 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4325 init_dwarf_regnames (elf_header
.e_machine
);
4331 printf (_("ELF Header:\n"));
4332 printf (_(" Magic: "));
4333 for (i
= 0; i
< EI_NIDENT
; i
++)
4334 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4336 printf (_(" Class: %s\n"),
4337 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4338 printf (_(" Data: %s\n"),
4339 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4340 printf (_(" Version: %d %s\n"),
4341 elf_header
.e_ident
[EI_VERSION
],
4342 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4344 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4345 ? _("<unknown: %lx>")
4347 printf (_(" OS/ABI: %s\n"),
4348 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4349 printf (_(" ABI Version: %d\n"),
4350 elf_header
.e_ident
[EI_ABIVERSION
]);
4351 printf (_(" Type: %s\n"),
4352 get_file_type (elf_header
.e_type
));
4353 printf (_(" Machine: %s\n"),
4354 get_machine_name (elf_header
.e_machine
));
4355 printf (_(" Version: 0x%lx\n"),
4356 (unsigned long) elf_header
.e_version
);
4358 printf (_(" Entry point address: "));
4359 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4360 printf (_("\n Start of program headers: "));
4361 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4362 printf (_(" (bytes into file)\n Start of section headers: "));
4363 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4364 printf (_(" (bytes into file)\n"));
4366 printf (_(" Flags: 0x%lx%s\n"),
4367 (unsigned long) elf_header
.e_flags
,
4368 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4369 printf (_(" Size of this header: %ld (bytes)\n"),
4370 (long) elf_header
.e_ehsize
);
4371 printf (_(" Size of program headers: %ld (bytes)\n"),
4372 (long) elf_header
.e_phentsize
);
4373 printf (_(" Number of program headers: %ld"),
4374 (long) elf_header
.e_phnum
);
4375 if (section_headers
!= NULL
4376 && elf_header
.e_phnum
== PN_XNUM
4377 && section_headers
[0].sh_info
!= 0)
4378 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4379 putc ('\n', stdout
);
4380 printf (_(" Size of section headers: %ld (bytes)\n"),
4381 (long) elf_header
.e_shentsize
);
4382 printf (_(" Number of section headers: %ld"),
4383 (long) elf_header
.e_shnum
);
4384 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4385 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4386 putc ('\n', stdout
);
4387 printf (_(" Section header string table index: %ld"),
4388 (long) elf_header
.e_shstrndx
);
4389 if (section_headers
!= NULL
4390 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4391 printf (" (%u)", section_headers
[0].sh_link
);
4392 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4393 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4394 printf (_(" <corrupt: out of range>"));
4395 putc ('\n', stdout
);
4398 if (section_headers
!= NULL
)
4400 if (elf_header
.e_phnum
== PN_XNUM
4401 && section_headers
[0].sh_info
!= 0)
4402 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4403 if (elf_header
.e_shnum
== SHN_UNDEF
)
4404 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4405 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4406 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4407 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4408 elf_header
.e_shstrndx
= SHN_UNDEF
;
4409 free (section_headers
);
4410 section_headers
= NULL
;
4417 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4419 Elf32_External_Phdr
* phdrs
;
4420 Elf32_External_Phdr
* external
;
4421 Elf_Internal_Phdr
* internal
;
4423 unsigned int size
= elf_header
.e_phentsize
;
4424 unsigned int num
= elf_header
.e_phnum
;
4426 /* PR binutils/17531: Cope with unexpected section header sizes. */
4427 if (size
== 0 || num
== 0)
4429 if (size
< sizeof * phdrs
)
4431 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4434 if (size
> sizeof * phdrs
)
4435 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4437 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4438 size
, num
, _("program headers"));
4442 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4443 i
< elf_header
.e_phnum
;
4444 i
++, internal
++, external
++)
4446 internal
->p_type
= BYTE_GET (external
->p_type
);
4447 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4448 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4449 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4450 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4451 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4452 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4453 internal
->p_align
= BYTE_GET (external
->p_align
);
4461 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4463 Elf64_External_Phdr
* phdrs
;
4464 Elf64_External_Phdr
* external
;
4465 Elf_Internal_Phdr
* internal
;
4467 unsigned int size
= elf_header
.e_phentsize
;
4468 unsigned int num
= elf_header
.e_phnum
;
4470 /* PR binutils/17531: Cope with unexpected section header sizes. */
4471 if (size
== 0 || num
== 0)
4473 if (size
< sizeof * phdrs
)
4475 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4478 if (size
> sizeof * phdrs
)
4479 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4481 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4482 size
, num
, _("program headers"));
4486 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4487 i
< elf_header
.e_phnum
;
4488 i
++, internal
++, external
++)
4490 internal
->p_type
= BYTE_GET (external
->p_type
);
4491 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4492 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4493 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4494 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4495 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4496 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4497 internal
->p_align
= BYTE_GET (external
->p_align
);
4504 /* Returns 1 if the program headers were read into `program_headers'. */
4507 get_program_headers (FILE * file
)
4509 Elf_Internal_Phdr
* phdrs
;
4511 /* Check cache of prior read. */
4512 if (program_headers
!= NULL
)
4515 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4516 sizeof (Elf_Internal_Phdr
));
4520 error (_("Out of memory reading %u program headers\n"),
4521 elf_header
.e_phnum
);
4526 ? get_32bit_program_headers (file
, phdrs
)
4527 : get_64bit_program_headers (file
, phdrs
))
4529 program_headers
= phdrs
;
4537 /* Returns 1 if the program headers were loaded. */
4540 process_program_headers (FILE * file
)
4542 Elf_Internal_Phdr
* segment
;
4545 if (elf_header
.e_phnum
== 0)
4547 /* PR binutils/12467. */
4548 if (elf_header
.e_phoff
!= 0)
4549 warn (_("possibly corrupt ELF header - it has a non-zero program"
4550 " header offset, but no program headers\n"));
4551 else if (do_segments
)
4552 printf (_("\nThere are no program headers in this file.\n"));
4556 if (do_segments
&& !do_header
)
4558 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4559 printf (_("Entry point "));
4560 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4561 printf (_("\nThere are %d program headers, starting at offset "),
4562 elf_header
.e_phnum
);
4563 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4567 if (! get_program_headers (file
))
4572 if (elf_header
.e_phnum
> 1)
4573 printf (_("\nProgram Headers:\n"));
4575 printf (_("\nProgram Headers:\n"));
4579 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4582 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4586 (_(" Type Offset VirtAddr PhysAddr\n"));
4588 (_(" FileSiz MemSiz Flags Align\n"));
4595 for (i
= 0, segment
= program_headers
;
4596 i
< elf_header
.e_phnum
;
4601 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4605 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4606 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4607 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4608 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4609 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4611 (segment
->p_flags
& PF_R
? 'R' : ' '),
4612 (segment
->p_flags
& PF_W
? 'W' : ' '),
4613 (segment
->p_flags
& PF_X
? 'E' : ' '));
4614 printf ("%#lx", (unsigned long) segment
->p_align
);
4618 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4619 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4622 print_vma (segment
->p_offset
, FULL_HEX
);
4626 print_vma (segment
->p_vaddr
, FULL_HEX
);
4628 print_vma (segment
->p_paddr
, FULL_HEX
);
4631 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4632 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4635 print_vma (segment
->p_filesz
, FULL_HEX
);
4639 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4640 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4643 print_vma (segment
->p_memsz
, FULL_HEX
);
4647 (segment
->p_flags
& PF_R
? 'R' : ' '),
4648 (segment
->p_flags
& PF_W
? 'W' : ' '),
4649 (segment
->p_flags
& PF_X
? 'E' : ' '));
4651 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4652 printf ("%#lx", (unsigned long) segment
->p_align
);
4655 print_vma (segment
->p_align
, PREFIX_HEX
);
4660 print_vma (segment
->p_offset
, FULL_HEX
);
4662 print_vma (segment
->p_vaddr
, FULL_HEX
);
4664 print_vma (segment
->p_paddr
, FULL_HEX
);
4666 print_vma (segment
->p_filesz
, FULL_HEX
);
4668 print_vma (segment
->p_memsz
, FULL_HEX
);
4670 (segment
->p_flags
& PF_R
? 'R' : ' '),
4671 (segment
->p_flags
& PF_W
? 'W' : ' '),
4672 (segment
->p_flags
& PF_X
? 'E' : ' '));
4673 print_vma (segment
->p_align
, HEX
);
4678 putc ('\n', stdout
);
4680 switch (segment
->p_type
)
4684 error (_("more than one dynamic segment\n"));
4686 /* By default, assume that the .dynamic section is the first
4687 section in the DYNAMIC segment. */
4688 dynamic_addr
= segment
->p_offset
;
4689 dynamic_size
= segment
->p_filesz
;
4690 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4691 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4693 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4694 dynamic_addr
= dynamic_size
= 0;
4697 /* Try to locate the .dynamic section. If there is
4698 a section header table, we can easily locate it. */
4699 if (section_headers
!= NULL
)
4701 Elf_Internal_Shdr
* sec
;
4703 sec
= find_section (".dynamic");
4704 if (sec
== NULL
|| sec
->sh_size
== 0)
4706 /* A corresponding .dynamic section is expected, but on
4707 IA-64/OpenVMS it is OK for it to be missing. */
4708 if (!is_ia64_vms ())
4709 error (_("no .dynamic section in the dynamic segment\n"));
4713 if (sec
->sh_type
== SHT_NOBITS
)
4719 dynamic_addr
= sec
->sh_offset
;
4720 dynamic_size
= sec
->sh_size
;
4722 if (dynamic_addr
< segment
->p_offset
4723 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4724 warn (_("the .dynamic section is not contained"
4725 " within the dynamic segment\n"));
4726 else if (dynamic_addr
> segment
->p_offset
)
4727 warn (_("the .dynamic section is not the first section"
4728 " in the dynamic segment.\n"));
4733 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4735 error (_("Unable to find program interpreter name\n"));
4739 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4741 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4742 error (_("Internal error: failed to create format string to display program interpreter\n"));
4744 program_interpreter
[0] = 0;
4745 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4746 error (_("Unable to read program interpreter name\n"));
4749 printf (_(" [Requesting program interpreter: %s]\n"),
4750 program_interpreter
);
4756 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4758 printf (_("\n Section to Segment mapping:\n"));
4759 printf (_(" Segment Sections...\n"));
4761 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4764 Elf_Internal_Shdr
* section
;
4766 segment
= program_headers
+ i
;
4767 section
= section_headers
+ 1;
4769 printf (" %2.2d ", i
);
4771 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4773 if (!ELF_TBSS_SPECIAL (section
, segment
)
4774 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4775 printf ("%s ", printable_section_name (section
));
4786 /* Find the file offset corresponding to VMA by using the program headers. */
4789 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4791 Elf_Internal_Phdr
* seg
;
4793 if (! get_program_headers (file
))
4795 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4799 for (seg
= program_headers
;
4800 seg
< program_headers
+ elf_header
.e_phnum
;
4803 if (seg
->p_type
!= PT_LOAD
)
4806 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4807 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4808 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4811 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4812 (unsigned long) vma
);
4817 /* Allocate memory and load the sections headers into the global pointer
4818 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4819 generate any error messages if the load fails. */
4822 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4824 Elf32_External_Shdr
* shdrs
;
4825 Elf_Internal_Shdr
* internal
;
4827 unsigned int size
= elf_header
.e_shentsize
;
4828 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4830 /* PR binutils/17531: Cope with unexpected section header sizes. */
4831 if (size
== 0 || num
== 0)
4833 if (size
< sizeof * shdrs
)
4836 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4839 if (!probe
&& size
> sizeof * shdrs
)
4840 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4842 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4844 probe
? NULL
: _("section headers"));
4848 if (section_headers
!= NULL
)
4849 free (section_headers
);
4850 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4851 sizeof (Elf_Internal_Shdr
));
4852 if (section_headers
== NULL
)
4855 error (_("Out of memory reading %u section headers\n"), num
);
4859 for (i
= 0, internal
= section_headers
;
4863 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4864 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4865 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4866 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4867 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4868 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4869 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4870 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4871 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4872 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4880 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4882 Elf64_External_Shdr
* shdrs
;
4883 Elf_Internal_Shdr
* internal
;
4885 unsigned int size
= elf_header
.e_shentsize
;
4886 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4888 /* PR binutils/17531: Cope with unexpected section header sizes. */
4889 if (size
== 0 || num
== 0)
4891 if (size
< sizeof * shdrs
)
4894 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4897 if (! probe
&& size
> sizeof * shdrs
)
4898 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4900 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4902 probe
? NULL
: _("section headers"));
4906 if (section_headers
!= NULL
)
4907 free (section_headers
);
4908 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4909 sizeof (Elf_Internal_Shdr
));
4910 if (section_headers
== NULL
)
4913 error (_("Out of memory reading %u section headers\n"), num
);
4917 for (i
= 0, internal
= section_headers
;
4921 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4922 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4923 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4924 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4925 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4926 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4927 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4928 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4929 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4930 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4937 static Elf_Internal_Sym
*
4938 get_32bit_elf_symbols (FILE * file
,
4939 Elf_Internal_Shdr
* section
,
4940 unsigned long * num_syms_return
)
4942 unsigned long number
= 0;
4943 Elf32_External_Sym
* esyms
= NULL
;
4944 Elf_External_Sym_Shndx
* shndx
= NULL
;
4945 Elf_Internal_Sym
* isyms
= NULL
;
4946 Elf_Internal_Sym
* psym
;
4949 if (section
->sh_size
== 0)
4951 if (num_syms_return
!= NULL
)
4952 * num_syms_return
= 0;
4956 /* Run some sanity checks first. */
4957 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4959 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4960 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4964 if (section
->sh_size
> current_file_size
)
4966 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4967 printable_section_name (section
), (unsigned long) section
->sh_size
);
4971 number
= section
->sh_size
/ section
->sh_entsize
;
4973 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4975 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4976 (unsigned long) section
->sh_size
,
4977 printable_section_name (section
),
4978 (unsigned long) section
->sh_entsize
);
4982 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4983 section
->sh_size
, _("symbols"));
4988 if (symtab_shndx_hdr
!= NULL
4989 && (symtab_shndx_hdr
->sh_link
4990 == (unsigned long) (section
- section_headers
)))
4992 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4993 symtab_shndx_hdr
->sh_offset
,
4994 1, symtab_shndx_hdr
->sh_size
,
4995 _("symbol table section indicies"));
4998 /* PR17531: file: heap-buffer-overflow */
4999 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5001 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5002 printable_section_name (symtab_shndx_hdr
),
5003 (unsigned long) symtab_shndx_hdr
->sh_size
,
5004 (unsigned long) section
->sh_size
);
5009 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5013 error (_("Out of memory reading %lu symbols\n"),
5014 (unsigned long) number
);
5018 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5020 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5021 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5022 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5023 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5024 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5026 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5027 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5028 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5029 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5030 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5039 if (num_syms_return
!= NULL
)
5040 * num_syms_return
= isyms
== NULL
? 0 : number
;
5045 static Elf_Internal_Sym
*
5046 get_64bit_elf_symbols (FILE * file
,
5047 Elf_Internal_Shdr
* section
,
5048 unsigned long * num_syms_return
)
5050 unsigned long number
= 0;
5051 Elf64_External_Sym
* esyms
= NULL
;
5052 Elf_External_Sym_Shndx
* shndx
= NULL
;
5053 Elf_Internal_Sym
* isyms
= NULL
;
5054 Elf_Internal_Sym
* psym
;
5057 if (section
->sh_size
== 0)
5059 if (num_syms_return
!= NULL
)
5060 * num_syms_return
= 0;
5064 /* Run some sanity checks first. */
5065 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5067 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5068 printable_section_name (section
),
5069 (unsigned long) section
->sh_entsize
);
5073 if (section
->sh_size
> current_file_size
)
5075 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5076 printable_section_name (section
),
5077 (unsigned long) section
->sh_size
);
5081 number
= section
->sh_size
/ section
->sh_entsize
;
5083 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5085 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5086 (unsigned long) section
->sh_size
,
5087 printable_section_name (section
),
5088 (unsigned long) section
->sh_entsize
);
5092 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5093 section
->sh_size
, _("symbols"));
5097 if (symtab_shndx_hdr
!= NULL
5098 && (symtab_shndx_hdr
->sh_link
5099 == (unsigned long) (section
- section_headers
)))
5101 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5102 symtab_shndx_hdr
->sh_offset
,
5103 1, symtab_shndx_hdr
->sh_size
,
5104 _("symbol table section indicies"));
5107 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5109 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5110 printable_section_name (symtab_shndx_hdr
),
5111 (unsigned long) symtab_shndx_hdr
->sh_size
,
5112 (unsigned long) section
->sh_size
);
5117 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5121 error (_("Out of memory reading %lu symbols\n"),
5122 (unsigned long) number
);
5126 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5128 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5129 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5130 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5131 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5133 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5135 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5136 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5137 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5139 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5140 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5149 if (num_syms_return
!= NULL
)
5150 * num_syms_return
= isyms
== NULL
? 0 : number
;
5156 get_elf_section_flags (bfd_vma sh_flags
)
5158 static char buff
[1024];
5160 int field_size
= is_32bit_elf
? 8 : 16;
5162 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5163 bfd_vma os_flags
= 0;
5164 bfd_vma proc_flags
= 0;
5165 bfd_vma unknown_flags
= 0;
5173 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5174 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5175 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5176 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5177 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5178 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5179 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5180 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5181 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5182 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5183 /* IA-64 specific. */
5184 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5185 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5186 /* IA-64 OpenVMS specific. */
5187 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5188 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5189 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5190 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5191 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5192 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5194 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5195 /* SPARC specific. */
5196 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5197 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5200 if (do_section_details
)
5202 sprintf (buff
, "[%*.*lx]: ",
5203 field_size
, field_size
, (unsigned long) sh_flags
);
5204 p
+= field_size
+ 4;
5211 flag
= sh_flags
& - sh_flags
;
5214 if (do_section_details
)
5218 case SHF_WRITE
: sindex
= 0; break;
5219 case SHF_ALLOC
: sindex
= 1; break;
5220 case SHF_EXECINSTR
: sindex
= 2; break;
5221 case SHF_MERGE
: sindex
= 3; break;
5222 case SHF_STRINGS
: sindex
= 4; break;
5223 case SHF_INFO_LINK
: sindex
= 5; break;
5224 case SHF_LINK_ORDER
: sindex
= 6; break;
5225 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5226 case SHF_GROUP
: sindex
= 8; break;
5227 case SHF_TLS
: sindex
= 9; break;
5228 case SHF_EXCLUDE
: sindex
= 18; break;
5229 case SHF_COMPRESSED
: sindex
= 20; break;
5233 switch (elf_header
.e_machine
)
5236 if (flag
== SHF_IA_64_SHORT
)
5238 else if (flag
== SHF_IA_64_NORECOV
)
5241 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5244 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5245 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5246 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5247 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5248 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5249 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5260 case EM_OLD_SPARCV9
:
5261 case EM_SPARC32PLUS
:
5264 if (flag
== SHF_ORDERED
)
5274 if (p
!= buff
+ field_size
+ 4)
5276 if (size
< (10 + 2))
5278 warn (_("Internal error: not enough buffer room for section flag info"));
5279 return _("<unknown>");
5286 size
-= flags
[sindex
].len
;
5287 p
= stpcpy (p
, flags
[sindex
].str
);
5289 else if (flag
& SHF_MASKOS
)
5291 else if (flag
& SHF_MASKPROC
)
5294 unknown_flags
|= flag
;
5300 case SHF_WRITE
: *p
= 'W'; break;
5301 case SHF_ALLOC
: *p
= 'A'; break;
5302 case SHF_EXECINSTR
: *p
= 'X'; break;
5303 case SHF_MERGE
: *p
= 'M'; break;
5304 case SHF_STRINGS
: *p
= 'S'; break;
5305 case SHF_INFO_LINK
: *p
= 'I'; break;
5306 case SHF_LINK_ORDER
: *p
= 'L'; break;
5307 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5308 case SHF_GROUP
: *p
= 'G'; break;
5309 case SHF_TLS
: *p
= 'T'; break;
5310 case SHF_EXCLUDE
: *p
= 'E'; break;
5311 case SHF_COMPRESSED
: *p
= 'C'; break;
5314 if ((elf_header
.e_machine
== EM_X86_64
5315 || elf_header
.e_machine
== EM_L1OM
5316 || elf_header
.e_machine
== EM_K1OM
)
5317 && flag
== SHF_X86_64_LARGE
)
5319 else if (flag
& SHF_MASKOS
)
5322 sh_flags
&= ~ SHF_MASKOS
;
5324 else if (flag
& SHF_MASKPROC
)
5327 sh_flags
&= ~ SHF_MASKPROC
;
5337 if (do_section_details
)
5341 size
-= 5 + field_size
;
5342 if (p
!= buff
+ field_size
+ 4)
5346 warn (_("Internal error: not enough buffer room for section flag info"));
5347 return _("<unknown>");
5353 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5354 (unsigned long) os_flags
);
5355 p
+= 5 + field_size
;
5359 size
-= 7 + field_size
;
5360 if (p
!= buff
+ field_size
+ 4)
5364 warn (_("Internal error: not enough buffer room for section flag info"));
5365 return _("<unknown>");
5371 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5372 (unsigned long) proc_flags
);
5373 p
+= 7 + field_size
;
5377 size
-= 10 + field_size
;
5378 if (p
!= buff
+ field_size
+ 4)
5382 warn (_("Internal error: not enough buffer room for section flag info"));
5383 return _("<unknown>");
5389 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5390 (unsigned long) unknown_flags
);
5391 p
+= 10 + field_size
;
5400 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5404 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5405 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5406 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5407 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5408 return sizeof (*echdr
);
5412 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5413 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5414 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5415 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5416 return sizeof (*echdr
);
5421 process_section_headers (FILE * file
)
5423 Elf_Internal_Shdr
* section
;
5426 section_headers
= NULL
;
5428 if (elf_header
.e_shnum
== 0)
5430 /* PR binutils/12467. */
5431 if (elf_header
.e_shoff
!= 0)
5432 warn (_("possibly corrupt ELF file header - it has a non-zero"
5433 " section header offset, but no section headers\n"));
5434 else if (do_sections
)
5435 printf (_("\nThere are no sections in this file.\n"));
5440 if (do_sections
&& !do_header
)
5441 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5442 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5446 if (! get_32bit_section_headers (file
, FALSE
))
5449 else if (! get_64bit_section_headers (file
, FALSE
))
5452 /* Read in the string table, so that we have names to display. */
5453 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5454 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5456 section
= section_headers
+ elf_header
.e_shstrndx
;
5458 if (section
->sh_size
!= 0)
5460 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5461 1, section
->sh_size
,
5464 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5468 /* Scan the sections for the dynamic symbol table
5469 and dynamic string table and debug sections. */
5470 dynamic_symbols
= NULL
;
5471 dynamic_strings
= NULL
;
5472 dynamic_syminfo
= NULL
;
5473 symtab_shndx_hdr
= NULL
;
5475 eh_addr_size
= is_32bit_elf
? 4 : 8;
5476 switch (elf_header
.e_machine
)
5479 case EM_MIPS_RS3_LE
:
5480 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5481 FDE addresses. However, the ABI also has a semi-official ILP32
5482 variant for which the normal FDE address size rules apply.
5484 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5485 section, where XX is the size of longs in bits. Unfortunately,
5486 earlier compilers provided no way of distinguishing ILP32 objects
5487 from LP64 objects, so if there's any doubt, we should assume that
5488 the official LP64 form is being used. */
5489 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5490 && find_section (".gcc_compiled_long32") == NULL
)
5496 switch (elf_header
.e_flags
& EF_H8_MACH
)
5498 case E_H8_MACH_H8300
:
5499 case E_H8_MACH_H8300HN
:
5500 case E_H8_MACH_H8300SN
:
5501 case E_H8_MACH_H8300SXN
:
5504 case E_H8_MACH_H8300H
:
5505 case E_H8_MACH_H8300S
:
5506 case E_H8_MACH_H8300SX
:
5514 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5516 case EF_M32C_CPU_M16C
:
5523 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5526 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5527 if (section->sh_entsize != expected_entsize) \
5530 sprintf_vma (buf, section->sh_entsize); \
5531 /* Note: coded this way so that there is a single string for \
5533 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5534 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5535 (unsigned) expected_entsize); \
5536 section->sh_entsize = expected_entsize; \
5541 #define CHECK_ENTSIZE(section, i, type) \
5542 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5543 sizeof (Elf64_External_##type))
5545 for (i
= 0, section
= section_headers
;
5546 i
< elf_header
.e_shnum
;
5549 char * name
= SECTION_NAME (section
);
5551 if (section
->sh_type
== SHT_DYNSYM
)
5553 if (dynamic_symbols
!= NULL
)
5555 error (_("File contains multiple dynamic symbol tables\n"));
5559 CHECK_ENTSIZE (section
, i
, Sym
);
5560 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5562 else if (section
->sh_type
== SHT_STRTAB
5563 && streq (name
, ".dynstr"))
5565 if (dynamic_strings
!= NULL
)
5567 error (_("File contains multiple dynamic string tables\n"));
5571 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5572 1, section
->sh_size
,
5573 _("dynamic strings"));
5574 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5576 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5578 if (symtab_shndx_hdr
!= NULL
)
5580 error (_("File contains multiple symtab shndx tables\n"));
5583 symtab_shndx_hdr
= section
;
5585 else if (section
->sh_type
== SHT_SYMTAB
)
5586 CHECK_ENTSIZE (section
, i
, Sym
);
5587 else if (section
->sh_type
== SHT_GROUP
)
5588 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5589 else if (section
->sh_type
== SHT_REL
)
5590 CHECK_ENTSIZE (section
, i
, Rel
);
5591 else if (section
->sh_type
== SHT_RELA
)
5592 CHECK_ENTSIZE (section
, i
, Rela
);
5593 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5594 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5595 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5596 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5597 || do_debug_addr
|| do_debug_cu_index
)
5598 && (const_strneq (name
, ".debug_")
5599 || const_strneq (name
, ".zdebug_")))
5602 name
+= sizeof (".zdebug_") - 1;
5604 name
+= sizeof (".debug_") - 1;
5607 || (do_debug_info
&& const_strneq (name
, "info"))
5608 || (do_debug_info
&& const_strneq (name
, "types"))
5609 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5610 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5611 || (do_debug_lines
&& const_strneq (name
, "line."))
5612 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5613 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5614 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5615 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5616 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5617 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5618 || (do_debug_frames
&& const_strneq (name
, "frame"))
5619 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5620 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5621 || (do_debug_str
&& const_strneq (name
, "str"))
5622 || (do_debug_loc
&& const_strneq (name
, "loc"))
5623 || (do_debug_addr
&& const_strneq (name
, "addr"))
5624 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5625 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5627 request_dump_bynumber (i
, DEBUG_DUMP
);
5629 /* Linkonce section to be combined with .debug_info at link time. */
5630 else if ((do_debugging
|| do_debug_info
)
5631 && const_strneq (name
, ".gnu.linkonce.wi."))
5632 request_dump_bynumber (i
, DEBUG_DUMP
);
5633 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5634 request_dump_bynumber (i
, DEBUG_DUMP
);
5635 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5636 request_dump_bynumber (i
, DEBUG_DUMP
);
5637 /* Trace sections for Itanium VMS. */
5638 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5639 || do_trace_aranges
)
5640 && const_strneq (name
, ".trace_"))
5642 name
+= sizeof (".trace_") - 1;
5645 || (do_trace_info
&& streq (name
, "info"))
5646 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5647 || (do_trace_aranges
&& streq (name
, "aranges"))
5649 request_dump_bynumber (i
, DEBUG_DUMP
);
5656 if (elf_header
.e_shnum
> 1)
5657 printf (_("\nSection Headers:\n"));
5659 printf (_("\nSection Header:\n"));
5663 if (do_section_details
)
5665 printf (_(" [Nr] Name\n"));
5666 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5670 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5674 if (do_section_details
)
5676 printf (_(" [Nr] Name\n"));
5677 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5681 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5685 if (do_section_details
)
5687 printf (_(" [Nr] Name\n"));
5688 printf (_(" Type Address Offset Link\n"));
5689 printf (_(" Size EntSize Info Align\n"));
5693 printf (_(" [Nr] Name Type Address Offset\n"));
5694 printf (_(" Size EntSize Flags Link Info Align\n"));
5698 if (do_section_details
)
5699 printf (_(" Flags\n"));
5701 for (i
= 0, section
= section_headers
;
5702 i
< elf_header
.e_shnum
;
5705 printf (" [%2u] ", i
);
5706 if (do_section_details
)
5707 printf ("%s\n ", printable_section_name (section
));
5709 print_symbol (-17, SECTION_NAME (section
));
5711 printf (do_wide
? " %-15s " : " %-15.15s ",
5712 get_section_type_name (section
->sh_type
));
5716 const char * link_too_big
= NULL
;
5718 print_vma (section
->sh_addr
, LONG_HEX
);
5720 printf ( " %6.6lx %6.6lx %2.2lx",
5721 (unsigned long) section
->sh_offset
,
5722 (unsigned long) section
->sh_size
,
5723 (unsigned long) section
->sh_entsize
);
5725 if (do_section_details
)
5726 fputs (" ", stdout
);
5728 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5730 if (section
->sh_link
>= elf_header
.e_shnum
)
5733 /* The sh_link value is out of range. Normally this indicates
5734 an error but it can have special values in Solaris binaries. */
5735 switch (elf_header
.e_machine
)
5742 case EM_OLD_SPARCV9
:
5743 case EM_SPARC32PLUS
:
5746 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5747 link_too_big
= "BEFORE";
5748 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5749 link_too_big
= "AFTER";
5756 if (do_section_details
)
5758 if (link_too_big
!= NULL
&& * link_too_big
)
5759 printf ("<%s> ", link_too_big
);
5761 printf ("%2u ", section
->sh_link
);
5762 printf ("%3u %2lu\n", section
->sh_info
,
5763 (unsigned long) section
->sh_addralign
);
5766 printf ("%2u %3u %2lu\n",
5769 (unsigned long) section
->sh_addralign
);
5771 if (link_too_big
&& ! * link_too_big
)
5772 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5773 i
, section
->sh_link
);
5777 print_vma (section
->sh_addr
, LONG_HEX
);
5779 if ((long) section
->sh_offset
== section
->sh_offset
)
5780 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5784 print_vma (section
->sh_offset
, LONG_HEX
);
5787 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5788 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5792 print_vma (section
->sh_size
, LONG_HEX
);
5795 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5796 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5800 print_vma (section
->sh_entsize
, LONG_HEX
);
5803 if (do_section_details
)
5804 fputs (" ", stdout
);
5806 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5808 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5810 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5811 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5814 print_vma (section
->sh_addralign
, DEC
);
5818 else if (do_section_details
)
5820 printf (" %-15.15s ",
5821 get_section_type_name (section
->sh_type
));
5822 print_vma (section
->sh_addr
, LONG_HEX
);
5823 if ((long) section
->sh_offset
== section
->sh_offset
)
5824 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5828 print_vma (section
->sh_offset
, LONG_HEX
);
5830 printf (" %u\n ", section
->sh_link
);
5831 print_vma (section
->sh_size
, LONG_HEX
);
5833 print_vma (section
->sh_entsize
, LONG_HEX
);
5835 printf (" %-16u %lu\n",
5837 (unsigned long) section
->sh_addralign
);
5842 print_vma (section
->sh_addr
, LONG_HEX
);
5843 if ((long) section
->sh_offset
== section
->sh_offset
)
5844 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5848 print_vma (section
->sh_offset
, LONG_HEX
);
5851 print_vma (section
->sh_size
, LONG_HEX
);
5853 print_vma (section
->sh_entsize
, LONG_HEX
);
5855 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5857 printf (" %2u %3u %lu\n",
5860 (unsigned long) section
->sh_addralign
);
5863 if (do_section_details
)
5865 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5866 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5868 /* Minimum section size is 12 bytes for 32-bit compression
5869 header + 12 bytes for compressed data header. */
5870 unsigned char buf
[24];
5871 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5872 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5873 sizeof (buf
), _("compression header")))
5875 Elf_Internal_Chdr chdr
;
5876 get_compression_header (&chdr
, buf
);
5877 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5880 printf (_(" [<unknown>: 0x%x], "),
5882 print_vma (chdr
.ch_size
, LONG_HEX
);
5883 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
5889 if (!do_section_details
)
5891 if (elf_header
.e_machine
== EM_X86_64
5892 || elf_header
.e_machine
== EM_L1OM
5893 || elf_header
.e_machine
== EM_K1OM
)
5894 printf (_("Key to Flags:\n\
5895 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5896 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5897 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5899 printf (_("Key to Flags:\n\
5900 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5901 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5902 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5909 get_group_flags (unsigned int flags
)
5911 static char buff
[32];
5921 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5928 process_section_groups (FILE * file
)
5930 Elf_Internal_Shdr
* section
;
5932 struct group
* group
;
5933 Elf_Internal_Shdr
* symtab_sec
;
5934 Elf_Internal_Shdr
* strtab_sec
;
5935 Elf_Internal_Sym
* symtab
;
5936 unsigned long num_syms
;
5940 /* Don't process section groups unless needed. */
5941 if (!do_unwind
&& !do_section_groups
)
5944 if (elf_header
.e_shnum
== 0)
5946 if (do_section_groups
)
5947 printf (_("\nThere are no sections to group in this file.\n"));
5952 if (section_headers
== NULL
)
5954 error (_("Section headers are not available!\n"));
5955 /* PR 13622: This can happen with a corrupt ELF header. */
5959 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5960 sizeof (struct group
*));
5962 if (section_headers_groups
== NULL
)
5964 error (_("Out of memory reading %u section group headers\n"),
5965 elf_header
.e_shnum
);
5969 /* Scan the sections for the group section. */
5971 for (i
= 0, section
= section_headers
;
5972 i
< elf_header
.e_shnum
;
5974 if (section
->sh_type
== SHT_GROUP
)
5977 if (group_count
== 0)
5979 if (do_section_groups
)
5980 printf (_("\nThere are no section groups in this file.\n"));
5985 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5987 if (section_groups
== NULL
)
5989 error (_("Out of memory reading %lu groups\n"),
5990 (unsigned long) group_count
);
6000 for (i
= 0, section
= section_headers
, group
= section_groups
;
6001 i
< elf_header
.e_shnum
;
6004 if (section
->sh_type
== SHT_GROUP
)
6006 const char * name
= printable_section_name (section
);
6007 const char * group_name
;
6008 unsigned char * start
;
6009 unsigned char * indices
;
6010 unsigned int entry
, j
, size
;
6011 Elf_Internal_Shdr
* sec
;
6012 Elf_Internal_Sym
* sym
;
6014 /* Get the symbol table. */
6015 if (section
->sh_link
>= elf_header
.e_shnum
6016 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6019 error (_("Bad sh_link in group section `%s'\n"), name
);
6023 if (symtab_sec
!= sec
)
6028 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6033 error (_("Corrupt header in group section `%s'\n"), name
);
6037 if (section
->sh_info
>= num_syms
)
6039 error (_("Bad sh_info in group section `%s'\n"), name
);
6043 sym
= symtab
+ section
->sh_info
;
6045 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6047 if (sym
->st_shndx
== 0
6048 || sym
->st_shndx
>= elf_header
.e_shnum
)
6050 error (_("Bad sh_info in group section `%s'\n"), name
);
6054 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6063 /* Get the string table. */
6064 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6073 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6079 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6080 1, strtab_sec
->sh_size
,
6082 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6084 group_name
= sym
->st_name
< strtab_size
6085 ? strtab
+ sym
->st_name
: _("<corrupt>");
6088 /* PR 17531: file: loop. */
6089 if (section
->sh_entsize
> section
->sh_size
)
6091 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6092 printable_section_name (section
),
6093 (unsigned long) section
->sh_entsize
,
6094 (unsigned long) section
->sh_size
);
6098 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6099 1, section
->sh_size
,
6105 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6106 entry
= byte_get (indices
, 4);
6109 if (do_section_groups
)
6111 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6112 get_group_flags (entry
), i
, name
, group_name
, size
);
6114 printf (_(" [Index] Name\n"));
6117 group
->group_index
= i
;
6119 for (j
= 0; j
< size
; j
++)
6121 struct group_list
* g
;
6123 entry
= byte_get (indices
, 4);
6126 if (entry
>= elf_header
.e_shnum
)
6128 static unsigned num_group_errors
= 0;
6130 if (num_group_errors
++ < 10)
6132 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6133 entry
, i
, elf_header
.e_shnum
- 1);
6134 if (num_group_errors
== 10)
6135 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6140 if (section_headers_groups
[entry
] != NULL
)
6144 static unsigned num_errs
= 0;
6146 if (num_errs
++ < 10)
6148 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6150 section_headers_groups
[entry
]->group_index
);
6152 warn (_("Further error messages about already contained group sections suppressed\n"));
6158 /* Intel C/C++ compiler may put section 0 in a
6159 section group. We just warn it the first time
6160 and ignore it afterwards. */
6161 static int warned
= 0;
6164 error (_("section 0 in group section [%5u]\n"),
6165 section_headers_groups
[entry
]->group_index
);
6171 section_headers_groups
[entry
] = group
;
6173 if (do_section_groups
)
6175 sec
= section_headers
+ entry
;
6176 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6179 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6180 g
->section_index
= entry
;
6181 g
->next
= group
->root
;
6199 /* Data used to display dynamic fixups. */
6201 struct ia64_vms_dynfixup
6203 bfd_vma needed_ident
; /* Library ident number. */
6204 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6205 bfd_vma fixup_needed
; /* Index of the library. */
6206 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6207 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6210 /* Data used to display dynamic relocations. */
6212 struct ia64_vms_dynimgrela
6214 bfd_vma img_rela_cnt
; /* Number of relocations. */
6215 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6218 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6222 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6223 const char *strtab
, unsigned int strtab_sz
)
6225 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6227 const char *lib_name
;
6229 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6230 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6231 _("dynamic section image fixups"));
6235 if (fixup
->needed
< strtab_sz
)
6236 lib_name
= strtab
+ fixup
->needed
;
6239 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6240 (unsigned long) fixup
->needed
);
6243 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6244 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6246 (_("Seg Offset Type SymVec DataType\n"));
6248 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6253 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6254 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6255 type
= BYTE_GET (imfs
[i
].type
);
6256 rtype
= elf_ia64_reloc_type (type
);
6258 printf (" 0x%08x ", type
);
6260 printf (" %-32s ", rtype
);
6261 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6262 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6268 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6271 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6273 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6276 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6277 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6278 _("dynamic section image relocations"));
6282 printf (_("\nImage relocs\n"));
6284 (_("Seg Offset Type Addend Seg Sym Off\n"));
6286 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6291 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6292 printf ("%08" BFD_VMA_FMT
"x ",
6293 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6294 type
= BYTE_GET (imrs
[i
].type
);
6295 rtype
= elf_ia64_reloc_type (type
);
6297 printf ("0x%08x ", type
);
6299 printf ("%-31s ", rtype
);
6300 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6301 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6302 printf ("%08" BFD_VMA_FMT
"x\n",
6303 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6309 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6312 process_ia64_vms_dynamic_relocs (FILE *file
)
6314 struct ia64_vms_dynfixup fixup
;
6315 struct ia64_vms_dynimgrela imgrela
;
6316 Elf_Internal_Dyn
*entry
;
6318 bfd_vma strtab_off
= 0;
6319 bfd_vma strtab_sz
= 0;
6320 char *strtab
= NULL
;
6322 memset (&fixup
, 0, sizeof (fixup
));
6323 memset (&imgrela
, 0, sizeof (imgrela
));
6325 /* Note: the order of the entries is specified by the OpenVMS specs. */
6326 for (entry
= dynamic_section
;
6327 entry
< dynamic_section
+ dynamic_nent
;
6330 switch (entry
->d_tag
)
6332 case DT_IA_64_VMS_STRTAB_OFFSET
:
6333 strtab_off
= entry
->d_un
.d_val
;
6336 strtab_sz
= entry
->d_un
.d_val
;
6338 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6339 1, strtab_sz
, _("dynamic string section"));
6342 case DT_IA_64_VMS_NEEDED_IDENT
:
6343 fixup
.needed_ident
= entry
->d_un
.d_val
;
6346 fixup
.needed
= entry
->d_un
.d_val
;
6348 case DT_IA_64_VMS_FIXUP_NEEDED
:
6349 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6351 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6352 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6354 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6355 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6357 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6360 case DT_IA_64_VMS_IMG_RELA_CNT
:
6361 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6363 case DT_IA_64_VMS_IMG_RELA_OFF
:
6364 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6366 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6386 } dynamic_relocations
[] =
6388 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6389 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6390 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6393 /* Process the reloc section. */
6396 process_relocs (FILE * file
)
6398 unsigned long rel_size
;
6399 unsigned long rel_offset
;
6405 if (do_using_dynamic
)
6409 int has_dynamic_reloc
;
6412 has_dynamic_reloc
= 0;
6414 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6416 is_rela
= dynamic_relocations
[i
].rela
;
6417 name
= dynamic_relocations
[i
].name
;
6418 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6419 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6421 has_dynamic_reloc
|= rel_size
;
6423 if (is_rela
== UNKNOWN
)
6425 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6426 switch (dynamic_info
[DT_PLTREL
])
6440 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6441 name
, rel_offset
, rel_size
);
6443 dump_relocations (file
,
6444 offset_from_vma (file
, rel_offset
, rel_size
),
6446 dynamic_symbols
, num_dynamic_syms
,
6447 dynamic_strings
, dynamic_strings_length
,
6453 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6455 if (! has_dynamic_reloc
)
6456 printf (_("\nThere are no dynamic relocations in this file.\n"));
6460 Elf_Internal_Shdr
* section
;
6464 for (i
= 0, section
= section_headers
;
6465 i
< elf_header
.e_shnum
;
6468 if ( section
->sh_type
!= SHT_RELA
6469 && section
->sh_type
!= SHT_REL
)
6472 rel_offset
= section
->sh_offset
;
6473 rel_size
= section
->sh_size
;
6477 Elf_Internal_Shdr
* strsec
;
6480 printf (_("\nRelocation section "));
6482 if (string_table
== NULL
)
6483 printf ("%d", section
->sh_name
);
6485 printf ("'%s'", printable_section_name (section
));
6487 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6488 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6490 is_rela
= section
->sh_type
== SHT_RELA
;
6492 if (section
->sh_link
!= 0
6493 && section
->sh_link
< elf_header
.e_shnum
)
6495 Elf_Internal_Shdr
* symsec
;
6496 Elf_Internal_Sym
* symtab
;
6497 unsigned long nsyms
;
6498 unsigned long strtablen
= 0;
6499 char * strtab
= NULL
;
6501 symsec
= section_headers
+ section
->sh_link
;
6502 if (symsec
->sh_type
!= SHT_SYMTAB
6503 && symsec
->sh_type
!= SHT_DYNSYM
)
6506 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6511 if (symsec
->sh_link
!= 0
6512 && symsec
->sh_link
< elf_header
.e_shnum
)
6514 strsec
= section_headers
+ symsec
->sh_link
;
6516 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6519 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6522 dump_relocations (file
, rel_offset
, rel_size
,
6523 symtab
, nsyms
, strtab
, strtablen
,
6525 symsec
->sh_type
== SHT_DYNSYM
);
6531 dump_relocations (file
, rel_offset
, rel_size
,
6532 NULL
, 0, NULL
, 0, is_rela
, 0);
6539 printf (_("\nThere are no relocations in this file.\n"));
6545 /* An absolute address consists of a section and an offset. If the
6546 section is NULL, the offset itself is the address, otherwise, the
6547 address equals to LOAD_ADDRESS(section) + offset. */
6551 unsigned short section
;
6555 #define ABSADDR(a) \
6557 ? section_headers [(a).section].sh_addr + (a).offset \
6560 /* Find the nearest symbol at or below ADDR. Returns the symbol
6561 name, if found, and the offset from the symbol to ADDR. */
6564 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6565 unsigned long nsyms
,
6566 const char * strtab
,
6567 unsigned long strtab_size
,
6568 struct absaddr addr
,
6569 const char ** symname
,
6572 bfd_vma dist
= 0x100000;
6573 Elf_Internal_Sym
* sym
;
6574 Elf_Internal_Sym
* beg
;
6575 Elf_Internal_Sym
* end
;
6576 Elf_Internal_Sym
* best
= NULL
;
6578 REMOVE_ARCH_BITS (addr
.offset
);
6580 end
= symtab
+ nsyms
;
6586 sym
= beg
+ (end
- beg
) / 2;
6588 value
= sym
->st_value
;
6589 REMOVE_ARCH_BITS (value
);
6591 if (sym
->st_name
!= 0
6592 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6593 && addr
.offset
>= value
6594 && addr
.offset
- value
< dist
)
6597 dist
= addr
.offset
- value
;
6602 if (addr
.offset
< value
)
6610 *symname
= (best
->st_name
>= strtab_size
6611 ? _("<corrupt>") : strtab
+ best
->st_name
);
6617 *offset
= addr
.offset
;
6621 symcmp (const void *p
, const void *q
)
6623 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6624 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6626 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6629 /* Process the unwind section. */
6631 #include "unwind-ia64.h"
6633 struct ia64_unw_table_entry
6635 struct absaddr start
;
6637 struct absaddr info
;
6640 struct ia64_unw_aux_info
6642 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6643 unsigned long table_len
; /* Length of unwind table. */
6644 unsigned char * info
; /* Unwind info. */
6645 unsigned long info_size
; /* Size of unwind info. */
6646 bfd_vma info_addr
; /* Starting address of unwind info. */
6647 bfd_vma seg_base
; /* Starting address of segment. */
6648 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6649 unsigned long nsyms
; /* Number of symbols. */
6650 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6651 unsigned long nfuns
; /* Number of entries in funtab. */
6652 char * strtab
; /* The string table. */
6653 unsigned long strtab_size
; /* Size of string table. */
6657 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6659 struct ia64_unw_table_entry
* tp
;
6660 unsigned long j
, nfuns
;
6663 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6664 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6665 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6666 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6668 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6670 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6674 const unsigned char * dp
;
6675 const unsigned char * head
;
6676 const unsigned char * end
;
6677 const char * procname
;
6679 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6680 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6682 fputs ("\n<", stdout
);
6686 fputs (procname
, stdout
);
6689 printf ("+%lx", (unsigned long) offset
);
6692 fputs (">: [", stdout
);
6693 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6694 fputc ('-', stdout
);
6695 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6696 printf ("], info at +0x%lx\n",
6697 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6699 /* PR 17531: file: 86232b32. */
6700 if (aux
->info
== NULL
)
6703 /* PR 17531: file: 0997b4d1. */
6704 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6706 warn (_("Invalid offset %lx in table entry %ld\n"),
6707 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6711 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6712 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6714 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6715 (unsigned) UNW_VER (stamp
),
6716 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6717 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6718 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6719 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6721 if (UNW_VER (stamp
) != 1)
6723 printf (_("\tUnknown version.\n"));
6728 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6729 /* PR 17531: file: 16ceda89. */
6730 if (end
> aux
->info
+ aux
->info_size
)
6731 end
= aux
->info
+ aux
->info_size
;
6732 for (dp
= head
+ 8; dp
< end
;)
6733 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6740 slurp_ia64_unwind_table (FILE * file
,
6741 struct ia64_unw_aux_info
* aux
,
6742 Elf_Internal_Shdr
* sec
)
6744 unsigned long size
, nrelas
, i
;
6745 Elf_Internal_Phdr
* seg
;
6746 struct ia64_unw_table_entry
* tep
;
6747 Elf_Internal_Shdr
* relsec
;
6748 Elf_Internal_Rela
* rela
;
6749 Elf_Internal_Rela
* rp
;
6750 unsigned char * table
;
6752 Elf_Internal_Sym
* sym
;
6753 const char * relname
;
6757 /* First, find the starting address of the segment that includes
6760 if (elf_header
.e_phnum
)
6762 if (! get_program_headers (file
))
6765 for (seg
= program_headers
;
6766 seg
< program_headers
+ elf_header
.e_phnum
;
6769 if (seg
->p_type
!= PT_LOAD
)
6772 if (sec
->sh_addr
>= seg
->p_vaddr
6773 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6775 aux
->seg_base
= seg
->p_vaddr
;
6781 /* Second, build the unwind table from the contents of the unwind section: */
6782 size
= sec
->sh_size
;
6783 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6788 aux
->table_len
= size
/ (3 * eh_addr_size
);
6789 aux
->table
= (struct ia64_unw_table_entry
*)
6790 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6793 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6795 tep
->start
.section
= SHN_UNDEF
;
6796 tep
->end
.section
= SHN_UNDEF
;
6797 tep
->info
.section
= SHN_UNDEF
;
6798 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6799 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6800 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6801 tep
->start
.offset
+= aux
->seg_base
;
6802 tep
->end
.offset
+= aux
->seg_base
;
6803 tep
->info
.offset
+= aux
->seg_base
;
6807 /* Third, apply any relocations to the unwind table: */
6808 for (relsec
= section_headers
;
6809 relsec
< section_headers
+ elf_header
.e_shnum
;
6812 if (relsec
->sh_type
!= SHT_RELA
6813 || relsec
->sh_info
>= elf_header
.e_shnum
6814 || section_headers
+ relsec
->sh_info
!= sec
)
6817 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6826 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6828 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6829 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6831 /* PR 17531: file: 9fa67536. */
6832 if (relname
== NULL
)
6834 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6838 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6840 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6844 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6846 /* PR 17531: file: 5bc8d9bf. */
6847 if (i
>= aux
->table_len
)
6849 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6853 switch (rp
->r_offset
/ eh_addr_size
% 3)
6856 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6857 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6860 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6861 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6864 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6865 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6879 ia64_process_unwind (FILE * file
)
6881 Elf_Internal_Shdr
* sec
;
6882 Elf_Internal_Shdr
* unwsec
= NULL
;
6883 Elf_Internal_Shdr
* strsec
;
6884 unsigned long i
, unwcount
= 0, unwstart
= 0;
6885 struct ia64_unw_aux_info aux
;
6887 memset (& aux
, 0, sizeof (aux
));
6889 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6891 if (sec
->sh_type
== SHT_SYMTAB
6892 && sec
->sh_link
< elf_header
.e_shnum
)
6894 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6896 strsec
= section_headers
+ sec
->sh_link
;
6897 if (aux
.strtab
!= NULL
)
6899 error (_("Multiple auxillary string tables encountered\n"));
6902 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6905 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6907 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6912 printf (_("\nThere are no unwind sections in this file.\n"));
6914 while (unwcount
-- > 0)
6919 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6920 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6921 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6926 /* We have already counted the number of SHT_IA64_UNWIND
6927 sections so the loop above should never fail. */
6928 assert (unwsec
!= NULL
);
6931 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6933 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6935 /* We need to find which section group it is in. */
6936 struct group_list
* g
;
6938 if (section_headers_groups
== NULL
6939 || section_headers_groups
[i
] == NULL
)
6940 i
= elf_header
.e_shnum
;
6943 g
= section_headers_groups
[i
]->root
;
6945 for (; g
!= NULL
; g
= g
->next
)
6947 sec
= section_headers
+ g
->section_index
;
6949 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6954 i
= elf_header
.e_shnum
;
6957 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6959 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6960 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6961 suffix
= SECTION_NAME (unwsec
) + len
;
6962 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6964 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6965 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6970 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6971 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6972 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6973 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6975 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6976 suffix
= SECTION_NAME (unwsec
) + len
;
6977 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6979 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6980 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6984 if (i
== elf_header
.e_shnum
)
6986 printf (_("\nCould not find unwind info section for "));
6988 if (string_table
== NULL
)
6989 printf ("%d", unwsec
->sh_name
);
6991 printf ("'%s'", printable_section_name (unwsec
));
6995 aux
.info_addr
= sec
->sh_addr
;
6996 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6999 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7001 printf (_("\nUnwind section "));
7003 if (string_table
== NULL
)
7004 printf ("%d", unwsec
->sh_name
);
7006 printf ("'%s'", printable_section_name (unwsec
));
7008 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7009 (unsigned long) unwsec
->sh_offset
,
7010 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7012 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7013 && aux
.table_len
> 0)
7014 dump_ia64_unwind (& aux
);
7017 free ((char *) aux
.table
);
7019 free ((char *) aux
.info
);
7028 free ((char *) aux
.strtab
);
7031 struct hppa_unw_table_entry
7033 struct absaddr start
;
7035 unsigned int Cannot_unwind
:1; /* 0 */
7036 unsigned int Millicode
:1; /* 1 */
7037 unsigned int Millicode_save_sr0
:1; /* 2 */
7038 unsigned int Region_description
:2; /* 3..4 */
7039 unsigned int reserved1
:1; /* 5 */
7040 unsigned int Entry_SR
:1; /* 6 */
7041 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7042 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7043 unsigned int Args_stored
:1; /* 16 */
7044 unsigned int Variable_Frame
:1; /* 17 */
7045 unsigned int Separate_Package_Body
:1; /* 18 */
7046 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7047 unsigned int Stack_Overflow_Check
:1; /* 20 */
7048 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7049 unsigned int Ada_Region
:1; /* 22 */
7050 unsigned int cxx_info
:1; /* 23 */
7051 unsigned int cxx_try_catch
:1; /* 24 */
7052 unsigned int sched_entry_seq
:1; /* 25 */
7053 unsigned int reserved2
:1; /* 26 */
7054 unsigned int Save_SP
:1; /* 27 */
7055 unsigned int Save_RP
:1; /* 28 */
7056 unsigned int Save_MRP_in_frame
:1; /* 29 */
7057 unsigned int extn_ptr_defined
:1; /* 30 */
7058 unsigned int Cleanup_defined
:1; /* 31 */
7060 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7061 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7062 unsigned int Large_frame
:1; /* 2 */
7063 unsigned int Pseudo_SP_Set
:1; /* 3 */
7064 unsigned int reserved4
:1; /* 4 */
7065 unsigned int Total_frame_size
:27; /* 5..31 */
7068 struct hppa_unw_aux_info
7070 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7071 unsigned long table_len
; /* Length of unwind table. */
7072 bfd_vma seg_base
; /* Starting address of segment. */
7073 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7074 unsigned long nsyms
; /* Number of symbols. */
7075 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7076 unsigned long nfuns
; /* Number of entries in funtab. */
7077 char * strtab
; /* The string table. */
7078 unsigned long strtab_size
; /* Size of string table. */
7082 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7084 struct hppa_unw_table_entry
* tp
;
7085 unsigned long j
, nfuns
;
7087 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7088 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7089 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7090 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7092 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7094 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7097 const char * procname
;
7099 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7100 aux
->strtab_size
, tp
->start
, &procname
,
7103 fputs ("\n<", stdout
);
7107 fputs (procname
, stdout
);
7110 printf ("+%lx", (unsigned long) offset
);
7113 fputs (">: [", stdout
);
7114 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7115 fputc ('-', stdout
);
7116 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7119 #define PF(_m) if (tp->_m) printf (#_m " ");
7120 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7123 PF(Millicode_save_sr0
);
7124 /* PV(Region_description); */
7130 PF(Separate_Package_Body
);
7131 PF(Frame_Extension_Millicode
);
7132 PF(Stack_Overflow_Check
);
7133 PF(Two_Instruction_SP_Increment
);
7137 PF(sched_entry_seq
);
7140 PF(Save_MRP_in_frame
);
7141 PF(extn_ptr_defined
);
7142 PF(Cleanup_defined
);
7143 PF(MPE_XL_interrupt_marker
);
7144 PF(HP_UX_interrupt_marker
);
7147 PV(Total_frame_size
);
7158 slurp_hppa_unwind_table (FILE * file
,
7159 struct hppa_unw_aux_info
* aux
,
7160 Elf_Internal_Shdr
* sec
)
7162 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7163 Elf_Internal_Phdr
* seg
;
7164 struct hppa_unw_table_entry
* tep
;
7165 Elf_Internal_Shdr
* relsec
;
7166 Elf_Internal_Rela
* rela
;
7167 Elf_Internal_Rela
* rp
;
7168 unsigned char * table
;
7170 Elf_Internal_Sym
* sym
;
7171 const char * relname
;
7173 /* First, find the starting address of the segment that includes
7176 if (elf_header
.e_phnum
)
7178 if (! get_program_headers (file
))
7181 for (seg
= program_headers
;
7182 seg
< program_headers
+ elf_header
.e_phnum
;
7185 if (seg
->p_type
!= PT_LOAD
)
7188 if (sec
->sh_addr
>= seg
->p_vaddr
7189 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7191 aux
->seg_base
= seg
->p_vaddr
;
7197 /* Second, build the unwind table from the contents of the unwind
7199 size
= sec
->sh_size
;
7200 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7206 nentries
= size
/ unw_ent_size
;
7207 size
= unw_ent_size
* nentries
;
7209 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7210 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7212 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7214 unsigned int tmp1
, tmp2
;
7216 tep
->start
.section
= SHN_UNDEF
;
7217 tep
->end
.section
= SHN_UNDEF
;
7219 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7220 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7221 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7222 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7224 tep
->start
.offset
+= aux
->seg_base
;
7225 tep
->end
.offset
+= aux
->seg_base
;
7227 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7228 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7229 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7230 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7231 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7232 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7233 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7234 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7235 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7236 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7237 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7238 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7239 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7240 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7241 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7242 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7243 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7244 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7245 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7246 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7247 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7248 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7249 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7250 tep
->Cleanup_defined
= tmp1
& 0x1;
7252 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7253 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7254 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7255 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7256 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7257 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7261 /* Third, apply any relocations to the unwind table. */
7262 for (relsec
= section_headers
;
7263 relsec
< section_headers
+ elf_header
.e_shnum
;
7266 if (relsec
->sh_type
!= SHT_RELA
7267 || relsec
->sh_info
>= elf_header
.e_shnum
7268 || section_headers
+ relsec
->sh_info
!= sec
)
7271 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7275 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7277 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7278 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7280 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7281 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7283 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7287 i
= rp
->r_offset
/ unw_ent_size
;
7289 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7292 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7293 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7296 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7297 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7307 aux
->table_len
= nentries
;
7313 hppa_process_unwind (FILE * file
)
7315 struct hppa_unw_aux_info aux
;
7316 Elf_Internal_Shdr
* unwsec
= NULL
;
7317 Elf_Internal_Shdr
* strsec
;
7318 Elf_Internal_Shdr
* sec
;
7321 if (string_table
== NULL
)
7324 memset (& aux
, 0, sizeof (aux
));
7326 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7328 if (sec
->sh_type
== SHT_SYMTAB
7329 && sec
->sh_link
< elf_header
.e_shnum
)
7331 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7333 strsec
= section_headers
+ sec
->sh_link
;
7334 if (aux
.strtab
!= NULL
)
7336 error (_("Multiple auxillary string tables encountered\n"));
7339 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7342 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7344 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7349 printf (_("\nThere are no unwind sections in this file.\n"));
7351 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7353 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7355 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7356 printable_section_name (sec
),
7357 (unsigned long) sec
->sh_offset
,
7358 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7360 slurp_hppa_unwind_table (file
, &aux
, sec
);
7361 if (aux
.table_len
> 0)
7362 dump_hppa_unwind (&aux
);
7365 free ((char *) aux
.table
);
7373 free ((char *) aux
.strtab
);
7378 unsigned char * data
; /* The unwind data. */
7379 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7380 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7381 unsigned long nrelas
; /* The number of relocations. */
7382 unsigned int rel_type
; /* REL or RELA ? */
7383 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7386 struct arm_unw_aux_info
7388 FILE * file
; /* The file containing the unwind sections. */
7389 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7390 unsigned long nsyms
; /* Number of symbols. */
7391 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7392 unsigned long nfuns
; /* Number of these symbols. */
7393 char * strtab
; /* The file's string table. */
7394 unsigned long strtab_size
; /* Size of string table. */
7398 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7399 bfd_vma fn
, struct absaddr addr
)
7401 const char *procname
;
7404 if (addr
.section
== SHN_UNDEF
)
7407 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7408 aux
->strtab_size
, addr
, &procname
,
7411 print_vma (fn
, PREFIX_HEX
);
7415 fputs (" <", stdout
);
7416 fputs (procname
, stdout
);
7419 printf ("+0x%lx", (unsigned long) sym_offset
);
7420 fputc ('>', stdout
);
7427 arm_free_section (struct arm_section
*arm_sec
)
7429 if (arm_sec
->data
!= NULL
)
7430 free (arm_sec
->data
);
7432 if (arm_sec
->rela
!= NULL
)
7433 free (arm_sec
->rela
);
7436 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7437 cached section and install SEC instead.
7438 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7439 and return its valued in * WORDP, relocating if necessary.
7440 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7441 relocation's offset in ADDR.
7442 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7443 into the string table of the symbol associated with the reloc. If no
7444 reloc was applied store -1 there.
7445 5) Return TRUE upon success, FALSE otherwise. */
7448 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7449 struct arm_section
* arm_sec
,
7450 Elf_Internal_Shdr
* sec
,
7451 bfd_vma word_offset
,
7452 unsigned int * wordp
,
7453 struct absaddr
* addr
,
7456 Elf_Internal_Rela
*rp
;
7457 Elf_Internal_Sym
*sym
;
7458 const char * relname
;
7460 bfd_boolean wrapped
;
7462 if (sec
== NULL
|| arm_sec
== NULL
)
7465 addr
->section
= SHN_UNDEF
;
7468 if (sym_name
!= NULL
)
7469 *sym_name
= (bfd_vma
) -1;
7471 /* If necessary, update the section cache. */
7472 if (sec
!= arm_sec
->sec
)
7474 Elf_Internal_Shdr
*relsec
;
7476 arm_free_section (arm_sec
);
7479 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7480 sec
->sh_size
, _("unwind data"));
7481 arm_sec
->rela
= NULL
;
7482 arm_sec
->nrelas
= 0;
7484 for (relsec
= section_headers
;
7485 relsec
< section_headers
+ elf_header
.e_shnum
;
7488 if (relsec
->sh_info
>= elf_header
.e_shnum
7489 || section_headers
+ relsec
->sh_info
!= sec
7490 /* PR 15745: Check the section type as well. */
7491 || (relsec
->sh_type
!= SHT_REL
7492 && relsec
->sh_type
!= SHT_RELA
))
7495 arm_sec
->rel_type
= relsec
->sh_type
;
7496 if (relsec
->sh_type
== SHT_REL
)
7498 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7500 & arm_sec
->rela
, & arm_sec
->nrelas
))
7503 else /* relsec->sh_type == SHT_RELA */
7505 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7507 & arm_sec
->rela
, & arm_sec
->nrelas
))
7513 arm_sec
->next_rela
= arm_sec
->rela
;
7516 /* If there is no unwind data we can do nothing. */
7517 if (arm_sec
->data
== NULL
)
7520 /* If the offset is invalid then fail. */
7521 if (word_offset
> (sec
->sh_size
- 4)
7523 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7524 || ((bfd_signed_vma
) word_offset
) < 0)
7527 /* Get the word at the required offset. */
7528 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7530 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7531 if (arm_sec
->rela
== NULL
)
7537 /* Look through the relocs to find the one that applies to the provided offset. */
7539 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7541 bfd_vma prelval
, offset
;
7543 if (rp
->r_offset
> word_offset
&& !wrapped
)
7548 if (rp
->r_offset
> word_offset
)
7551 if (rp
->r_offset
& 3)
7553 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7554 (unsigned long) rp
->r_offset
);
7558 if (rp
->r_offset
< word_offset
)
7561 /* PR 17531: file: 027-161405-0.004 */
7562 if (aux
->symtab
== NULL
)
7565 if (arm_sec
->rel_type
== SHT_REL
)
7567 offset
= word
& 0x7fffffff;
7568 if (offset
& 0x40000000)
7569 offset
|= ~ (bfd_vma
) 0x7fffffff;
7571 else if (arm_sec
->rel_type
== SHT_RELA
)
7572 offset
= rp
->r_addend
;
7575 error (_("Unknown section relocation type %d encountered\n"),
7580 /* PR 17531 file: 027-1241568-0.004. */
7581 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7583 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7584 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7588 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7589 offset
+= sym
->st_value
;
7590 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7592 /* Check that we are processing the expected reloc type. */
7593 if (elf_header
.e_machine
== EM_ARM
)
7595 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7596 if (relname
== NULL
)
7598 warn (_("Skipping unknown ARM relocation type: %d\n"),
7599 (int) ELF32_R_TYPE (rp
->r_info
));
7603 if (streq (relname
, "R_ARM_NONE"))
7606 if (! streq (relname
, "R_ARM_PREL31"))
7608 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7612 else if (elf_header
.e_machine
== EM_TI_C6000
)
7614 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7615 if (relname
== NULL
)
7617 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7618 (int) ELF32_R_TYPE (rp
->r_info
));
7622 if (streq (relname
, "R_C6000_NONE"))
7625 if (! streq (relname
, "R_C6000_PREL31"))
7627 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7635 /* This function currently only supports ARM and TI unwinders. */
7636 warn (_("Only TI and ARM unwinders are currently supported\n"));
7640 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7641 addr
->section
= sym
->st_shndx
;
7642 addr
->offset
= offset
;
7645 * sym_name
= sym
->st_name
;
7650 arm_sec
->next_rela
= rp
;
7655 static const char *tic6x_unwind_regnames
[16] =
7657 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7658 "A14", "A13", "A12", "A11", "A10",
7659 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7663 decode_tic6x_unwind_regmask (unsigned int mask
)
7667 for (i
= 12; mask
; mask
>>= 1, i
--)
7671 fputs (tic6x_unwind_regnames
[i
], stdout
);
7673 fputs (", ", stdout
);
7679 if (remaining == 0 && more_words) \
7682 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7683 data_offset, & word, & addr, NULL)) \
7689 #define GET_OP(OP) \
7694 (OP) = word >> 24; \
7699 printf (_("[Truncated opcode]\n")); \
7702 printf ("0x%02x ", OP)
7705 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7707 unsigned int remaining
,
7708 unsigned int more_words
,
7709 bfd_vma data_offset
,
7710 Elf_Internal_Shdr
* data_sec
,
7711 struct arm_section
* data_arm_sec
)
7713 struct absaddr addr
;
7715 /* Decode the unwinding instructions. */
7718 unsigned int op
, op2
;
7727 printf (" 0x%02x ", op
);
7729 if ((op
& 0xc0) == 0x00)
7731 int offset
= ((op
& 0x3f) << 2) + 4;
7733 printf (" vsp = vsp + %d", offset
);
7735 else if ((op
& 0xc0) == 0x40)
7737 int offset
= ((op
& 0x3f) << 2) + 4;
7739 printf (" vsp = vsp - %d", offset
);
7741 else if ((op
& 0xf0) == 0x80)
7744 if (op
== 0x80 && op2
== 0)
7745 printf (_("Refuse to unwind"));
7748 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7753 for (i
= 0; i
< 12; i
++)
7754 if (mask
& (1 << i
))
7760 printf ("r%d", 4 + i
);
7765 else if ((op
& 0xf0) == 0x90)
7767 if (op
== 0x9d || op
== 0x9f)
7768 printf (_(" [Reserved]"));
7770 printf (" vsp = r%d", op
& 0x0f);
7772 else if ((op
& 0xf0) == 0xa0)
7774 int end
= 4 + (op
& 0x07);
7779 for (i
= 4; i
<= end
; i
++)
7795 else if (op
== 0xb0)
7796 printf (_(" finish"));
7797 else if (op
== 0xb1)
7800 if (op2
== 0 || (op2
& 0xf0) != 0)
7801 printf (_("[Spare]"));
7804 unsigned int mask
= op2
& 0x0f;
7809 for (i
= 0; i
< 12; i
++)
7810 if (mask
& (1 << i
))
7821 else if (op
== 0xb2)
7823 unsigned char buf
[9];
7824 unsigned int i
, len
;
7825 unsigned long offset
;
7827 for (i
= 0; i
< sizeof (buf
); i
++)
7830 if ((buf
[i
] & 0x80) == 0)
7833 if (i
== sizeof (buf
))
7834 printf (_("corrupt change to vsp"));
7837 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7838 assert (len
== i
+ 1);
7839 offset
= offset
* 4 + 0x204;
7840 printf ("vsp = vsp + %ld", offset
);
7843 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7845 unsigned int first
, last
;
7852 printf ("pop {D%d", first
);
7854 printf ("-D%d", first
+ last
);
7857 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7859 unsigned int count
= op
& 0x07;
7863 printf ("-D%d", 8 + count
);
7866 else if (op
>= 0xc0 && op
<= 0xc5)
7868 unsigned int count
= op
& 0x07;
7870 printf (" pop {wR10");
7872 printf ("-wR%d", 10 + count
);
7875 else if (op
== 0xc6)
7877 unsigned int first
, last
;
7882 printf ("pop {wR%d", first
);
7884 printf ("-wR%d", first
+ last
);
7887 else if (op
== 0xc7)
7890 if (op2
== 0 || (op2
& 0xf0) != 0)
7891 printf (_("[Spare]"));
7894 unsigned int mask
= op2
& 0x0f;
7899 for (i
= 0; i
< 4; i
++)
7900 if (mask
& (1 << i
))
7906 printf ("wCGR%d", i
);
7912 printf (_(" [unsupported opcode]"));
7918 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7920 unsigned int remaining
,
7921 unsigned int more_words
,
7922 bfd_vma data_offset
,
7923 Elf_Internal_Shdr
* data_sec
,
7924 struct arm_section
* data_arm_sec
)
7926 struct absaddr addr
;
7928 /* Decode the unwinding instructions. */
7931 unsigned int op
, op2
;
7940 printf (" 0x%02x ", op
);
7942 if ((op
& 0xc0) == 0x00)
7944 int offset
= ((op
& 0x3f) << 3) + 8;
7945 printf (" sp = sp + %d", offset
);
7947 else if ((op
& 0xc0) == 0x80)
7950 if (op
== 0x80 && op2
== 0)
7951 printf (_("Refuse to unwind"));
7954 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7956 printf ("pop compact {");
7960 decode_tic6x_unwind_regmask (mask
);
7964 else if ((op
& 0xf0) == 0xc0)
7972 unsigned int offset
;
7976 /* Scan entire instruction first so that GET_OP output is not
7977 interleaved with disassembly. */
7979 for (i
= 0; nregs
< (op
& 0xf); i
++)
7985 regpos
[nregs
].offset
= i
* 2;
7986 regpos
[nregs
].reg
= reg
;
7993 regpos
[nregs
].offset
= i
* 2 + 1;
7994 regpos
[nregs
].reg
= reg
;
7999 printf (_("pop frame {"));
8001 for (i
= i
* 2; i
> 0; i
--)
8003 if (regpos
[reg
].offset
== i
- 1)
8005 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8012 fputs (name
, stdout
);
8019 else if (op
== 0xd0)
8020 printf (" MOV FP, SP");
8021 else if (op
== 0xd1)
8022 printf (" __c6xabi_pop_rts");
8023 else if (op
== 0xd2)
8025 unsigned char buf
[9];
8026 unsigned int i
, len
;
8027 unsigned long offset
;
8029 for (i
= 0; i
< sizeof (buf
); i
++)
8032 if ((buf
[i
] & 0x80) == 0)
8035 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8036 if (i
== sizeof (buf
))
8038 printf ("<corrupt sp adjust>\n");
8039 warn (_("Corrupt stack pointer adjustment detected\n"));
8043 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8044 assert (len
== i
+ 1);
8045 offset
= offset
* 8 + 0x408;
8046 printf (_("sp = sp + %ld"), offset
);
8048 else if ((op
& 0xf0) == 0xe0)
8050 if ((op
& 0x0f) == 7)
8053 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8057 printf (_(" [unsupported opcode]"));
8064 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8068 offset
= word
& 0x7fffffff;
8069 if (offset
& 0x40000000)
8070 offset
|= ~ (bfd_vma
) 0x7fffffff;
8072 if (elf_header
.e_machine
== EM_TI_C6000
)
8075 return offset
+ where
;
8079 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8081 unsigned int remaining
,
8082 bfd_vma data_offset
,
8083 Elf_Internal_Shdr
* data_sec
,
8084 struct arm_section
* data_arm_sec
)
8087 unsigned int more_words
= 0;
8088 struct absaddr addr
;
8089 bfd_vma sym_name
= (bfd_vma
) -1;
8093 /* Fetch the first word.
8094 Note - when decoding an object file the address extracted
8095 here will always be 0. So we also pass in the sym_name
8096 parameter so that we can find the symbol associated with
8097 the personality routine. */
8098 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8099 & word
, & addr
, & sym_name
))
8105 if ((word
& 0x80000000) == 0)
8107 /* Expand prel31 for personality routine. */
8109 const char *procname
;
8111 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8112 printf (_(" Personality routine: "));
8114 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8115 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8117 procname
= aux
->strtab
+ sym_name
;
8118 print_vma (fn
, PREFIX_HEX
);
8121 fputs (" <", stdout
);
8122 fputs (procname
, stdout
);
8123 fputc ('>', stdout
);
8127 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8128 fputc ('\n', stdout
);
8130 /* The GCC personality routines use the standard compact
8131 encoding, starting with one byte giving the number of
8133 if (procname
!= NULL
8134 && (const_strneq (procname
, "__gcc_personality_v0")
8135 || const_strneq (procname
, "__gxx_personality_v0")
8136 || const_strneq (procname
, "__gcj_personality_v0")
8137 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8144 printf (_(" [Truncated data]\n"));
8147 more_words
= word
>> 24;
8157 /* ARM EHABI Section 6.3:
8159 An exception-handling table entry for the compact model looks like:
8163 1 0 index Data for personalityRoutine[index] */
8165 if (elf_header
.e_machine
== EM_ARM
8166 && (word
& 0x70000000))
8167 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8169 per_index
= (word
>> 24) & 0x7f;
8170 printf (_(" Compact model index: %d\n"), per_index
);
8177 else if (per_index
< 3)
8179 more_words
= (word
>> 16) & 0xff;
8185 switch (elf_header
.e_machine
)
8190 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8191 data_offset
, data_sec
, data_arm_sec
);
8195 warn (_("Unknown ARM compact model index encountered\n"));
8196 printf (_(" [reserved]\n"));
8203 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8204 data_offset
, data_sec
, data_arm_sec
);
8206 else if (per_index
< 5)
8208 if (((word
>> 17) & 0x7f) == 0x7f)
8209 printf (_(" Restore stack from frame pointer\n"));
8211 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8212 printf (_(" Registers restored: "));
8214 printf (" (compact) ");
8215 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8217 printf (_(" Return register: %s\n"),
8218 tic6x_unwind_regnames
[word
& 0xf]);
8221 printf (_(" [reserved (%d)]\n"), per_index
);
8225 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8226 elf_header
.e_machine
);
8229 /* Decode the descriptors. Not implemented. */
8233 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8235 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8236 unsigned int i
, exidx_len
;
8237 unsigned long j
, nfuns
;
8239 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8240 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8241 exidx_len
= exidx_sec
->sh_size
/ 8;
8243 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8244 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8245 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8246 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8248 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8250 for (i
= 0; i
< exidx_len
; i
++)
8252 unsigned int exidx_fn
, exidx_entry
;
8253 struct absaddr fn_addr
, entry_addr
;
8256 fputc ('\n', stdout
);
8258 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8259 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8260 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8261 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8264 arm_free_section (& exidx_arm_sec
);
8265 arm_free_section (& extab_arm_sec
);
8269 /* ARM EHABI, Section 5:
8270 An index table entry consists of 2 words.
8271 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8272 if (exidx_fn
& 0x80000000)
8273 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8275 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8277 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8278 fputs (": ", stdout
);
8280 if (exidx_entry
== 1)
8282 print_vma (exidx_entry
, PREFIX_HEX
);
8283 fputs (" [cantunwind]\n", stdout
);
8285 else if (exidx_entry
& 0x80000000)
8287 print_vma (exidx_entry
, PREFIX_HEX
);
8288 fputc ('\n', stdout
);
8289 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8293 bfd_vma table
, table_offset
= 0;
8294 Elf_Internal_Shdr
*table_sec
;
8296 fputs ("@", stdout
);
8297 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8298 print_vma (table
, PREFIX_HEX
);
8301 /* Locate the matching .ARM.extab. */
8302 if (entry_addr
.section
!= SHN_UNDEF
8303 && entry_addr
.section
< elf_header
.e_shnum
)
8305 table_sec
= section_headers
+ entry_addr
.section
;
8306 table_offset
= entry_addr
.offset
;
8308 if (table_offset
> table_sec
->sh_size
8309 || ((bfd_signed_vma
) table_offset
) < 0)
8311 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8312 (unsigned long) table_offset
,
8313 printable_section_name (table_sec
));
8319 table_sec
= find_section_by_address (table
);
8320 if (table_sec
!= NULL
)
8321 table_offset
= table
- table_sec
->sh_addr
;
8323 if (table_sec
== NULL
)
8325 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8326 (unsigned long) table
);
8329 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8337 arm_free_section (&exidx_arm_sec
);
8338 arm_free_section (&extab_arm_sec
);
8341 /* Used for both ARM and C6X unwinding tables. */
8344 arm_process_unwind (FILE *file
)
8346 struct arm_unw_aux_info aux
;
8347 Elf_Internal_Shdr
*unwsec
= NULL
;
8348 Elf_Internal_Shdr
*strsec
;
8349 Elf_Internal_Shdr
*sec
;
8351 unsigned int sec_type
;
8353 switch (elf_header
.e_machine
)
8356 sec_type
= SHT_ARM_EXIDX
;
8360 sec_type
= SHT_C6000_UNWIND
;
8364 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8365 elf_header
.e_machine
);
8369 if (string_table
== NULL
)
8372 memset (& aux
, 0, sizeof (aux
));
8375 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8377 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8379 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8381 strsec
= section_headers
+ sec
->sh_link
;
8383 /* PR binutils/17531 file: 011-12666-0.004. */
8384 if (aux
.strtab
!= NULL
)
8386 error (_("Multiple string tables found in file.\n"));
8389 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8390 1, strsec
->sh_size
, _("string table"));
8391 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8393 else if (sec
->sh_type
== sec_type
)
8398 printf (_("\nThere are no unwind sections in this file.\n"));
8400 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8402 if (sec
->sh_type
== sec_type
)
8404 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8405 printable_section_name (sec
),
8406 (unsigned long) sec
->sh_offset
,
8407 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8409 dump_arm_unwind (&aux
, sec
);
8416 free ((char *) aux
.strtab
);
8420 process_unwind (FILE * file
)
8422 struct unwind_handler
8425 void (* handler
)(FILE *);
8428 { EM_ARM
, arm_process_unwind
},
8429 { EM_IA_64
, ia64_process_unwind
},
8430 { EM_PARISC
, hppa_process_unwind
},
8431 { EM_TI_C6000
, arm_process_unwind
},
8439 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8440 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8442 handlers
[i
].handler (file
);
8446 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8447 get_machine_name (elf_header
.e_machine
));
8451 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8453 switch (entry
->d_tag
)
8456 if (entry
->d_un
.d_val
== 0)
8460 static const char * opts
[] =
8462 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8463 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8464 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8465 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8471 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8472 if (entry
->d_un
.d_val
& (1 << cnt
))
8474 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8480 case DT_MIPS_IVERSION
:
8481 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8482 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8486 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8487 /* Note: coded this way so that there is a single string for translation. */
8488 printf (_("<corrupt: %s>"), buf
);
8492 case DT_MIPS_TIME_STAMP
:
8496 time_t atime
= entry
->d_un
.d_val
;
8498 tmp
= gmtime (&atime
);
8499 /* PR 17531: file: 6accc532. */
8501 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8503 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8504 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8505 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8506 printf (_("Time Stamp: %s"), timebuf
);
8510 case DT_MIPS_RLD_VERSION
:
8511 case DT_MIPS_LOCAL_GOTNO
:
8512 case DT_MIPS_CONFLICTNO
:
8513 case DT_MIPS_LIBLISTNO
:
8514 case DT_MIPS_SYMTABNO
:
8515 case DT_MIPS_UNREFEXTNO
:
8516 case DT_MIPS_HIPAGENO
:
8517 case DT_MIPS_DELTA_CLASS_NO
:
8518 case DT_MIPS_DELTA_INSTANCE_NO
:
8519 case DT_MIPS_DELTA_RELOC_NO
:
8520 case DT_MIPS_DELTA_SYM_NO
:
8521 case DT_MIPS_DELTA_CLASSSYM_NO
:
8522 case DT_MIPS_COMPACT_SIZE
:
8523 print_vma (entry
->d_un
.d_ptr
, DEC
);
8527 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8533 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8535 switch (entry
->d_tag
)
8537 case DT_HP_DLD_FLAGS
:
8546 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8547 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8548 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8549 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8550 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8551 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8552 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8553 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8554 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8555 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8556 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8557 { DT_HP_GST
, "HP_GST" },
8558 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8559 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8560 { DT_HP_NODELETE
, "HP_NODELETE" },
8561 { DT_HP_GROUP
, "HP_GROUP" },
8562 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8566 bfd_vma val
= entry
->d_un
.d_val
;
8568 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8569 if (val
& flags
[cnt
].bit
)
8573 fputs (flags
[cnt
].str
, stdout
);
8575 val
^= flags
[cnt
].bit
;
8578 if (val
!= 0 || first
)
8582 print_vma (val
, HEX
);
8588 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8596 /* VMS vs Unix time offset and factor. */
8598 #define VMS_EPOCH_OFFSET 35067168000000000LL
8599 #define VMS_GRANULARITY_FACTOR 10000000
8601 /* Display a VMS time in a human readable format. */
8604 print_vms_time (bfd_int64_t vmstime
)
8609 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8610 tm
= gmtime (&unxtime
);
8611 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8612 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8613 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8618 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8620 switch (entry
->d_tag
)
8622 case DT_IA_64_PLT_RESERVE
:
8623 /* First 3 slots reserved. */
8624 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8626 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8629 case DT_IA_64_VMS_LINKTIME
:
8631 print_vms_time (entry
->d_un
.d_val
);
8635 case DT_IA_64_VMS_LNKFLAGS
:
8636 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8637 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8638 printf (" CALL_DEBUG");
8639 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8640 printf (" NOP0BUFS");
8641 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8642 printf (" P0IMAGE");
8643 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8644 printf (" MKTHREADS");
8645 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8646 printf (" UPCALLS");
8647 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8649 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8650 printf (" INITIALIZE");
8651 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8653 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8654 printf (" EXE_INIT");
8655 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8656 printf (" TBK_IN_IMG");
8657 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8658 printf (" DBG_IN_IMG");
8659 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8660 printf (" TBK_IN_DSF");
8661 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8662 printf (" DBG_IN_DSF");
8663 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8664 printf (" SIGNATURES");
8665 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8666 printf (" REL_SEG_OFF");
8670 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8677 get_32bit_dynamic_section (FILE * file
)
8679 Elf32_External_Dyn
* edyn
;
8680 Elf32_External_Dyn
* ext
;
8681 Elf_Internal_Dyn
* entry
;
8683 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8684 dynamic_size
, _("dynamic section"));
8688 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8689 might not have the luxury of section headers. Look for the DT_NULL
8690 terminator to determine the number of entries. */
8691 for (ext
= edyn
, dynamic_nent
= 0;
8692 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8696 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8700 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8702 if (dynamic_section
== NULL
)
8704 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8705 (unsigned long) dynamic_nent
);
8710 for (ext
= edyn
, entry
= dynamic_section
;
8711 entry
< dynamic_section
+ dynamic_nent
;
8714 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8715 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8724 get_64bit_dynamic_section (FILE * file
)
8726 Elf64_External_Dyn
* edyn
;
8727 Elf64_External_Dyn
* ext
;
8728 Elf_Internal_Dyn
* entry
;
8730 /* Read in the data. */
8731 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8732 dynamic_size
, _("dynamic section"));
8736 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8737 might not have the luxury of section headers. Look for the DT_NULL
8738 terminator to determine the number of entries. */
8739 for (ext
= edyn
, dynamic_nent
= 0;
8740 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8741 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8745 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8749 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8751 if (dynamic_section
== NULL
)
8753 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8754 (unsigned long) dynamic_nent
);
8759 /* Convert from external to internal formats. */
8760 for (ext
= edyn
, entry
= dynamic_section
;
8761 entry
< dynamic_section
+ dynamic_nent
;
8764 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8765 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8774 print_dynamic_flags (bfd_vma flags
)
8782 flag
= flags
& - flags
;
8792 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8793 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8794 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8795 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8796 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8797 default: fputs (_("unknown"), stdout
); break;
8803 /* Parse and display the contents of the dynamic section. */
8806 process_dynamic_section (FILE * file
)
8808 Elf_Internal_Dyn
* entry
;
8810 if (dynamic_size
== 0)
8813 printf (_("\nThere is no dynamic section in this file.\n"));
8820 if (! get_32bit_dynamic_section (file
))
8823 else if (! get_64bit_dynamic_section (file
))
8826 /* Find the appropriate symbol table. */
8827 if (dynamic_symbols
== NULL
)
8829 for (entry
= dynamic_section
;
8830 entry
< dynamic_section
+ dynamic_nent
;
8833 Elf_Internal_Shdr section
;
8835 if (entry
->d_tag
!= DT_SYMTAB
)
8838 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8840 /* Since we do not know how big the symbol table is,
8841 we default to reading in the entire file (!) and
8842 processing that. This is overkill, I know, but it
8844 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8846 if (archive_file_offset
!= 0)
8847 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8850 if (fseek (file
, 0, SEEK_END
))
8851 error (_("Unable to seek to end of file!\n"));
8853 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8857 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8859 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8860 section
.sh_name
= string_table_length
;
8862 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8863 if (num_dynamic_syms
< 1)
8865 error (_("Unable to determine the number of symbols to load\n"));
8871 /* Similarly find a string table. */
8872 if (dynamic_strings
== NULL
)
8874 for (entry
= dynamic_section
;
8875 entry
< dynamic_section
+ dynamic_nent
;
8878 unsigned long offset
;
8881 if (entry
->d_tag
!= DT_STRTAB
)
8884 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8886 /* Since we do not know how big the string table is,
8887 we default to reading in the entire file (!) and
8888 processing that. This is overkill, I know, but it
8891 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8893 if (archive_file_offset
!= 0)
8894 str_tab_len
= archive_file_size
- offset
;
8897 if (fseek (file
, 0, SEEK_END
))
8898 error (_("Unable to seek to end of file\n"));
8899 str_tab_len
= ftell (file
) - offset
;
8902 if (str_tab_len
< 1)
8905 (_("Unable to determine the length of the dynamic string table\n"));
8909 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8911 _("dynamic string table"));
8912 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8917 /* And find the syminfo section if available. */
8918 if (dynamic_syminfo
== NULL
)
8920 unsigned long syminsz
= 0;
8922 for (entry
= dynamic_section
;
8923 entry
< dynamic_section
+ dynamic_nent
;
8926 if (entry
->d_tag
== DT_SYMINENT
)
8928 /* Note: these braces are necessary to avoid a syntax
8929 error from the SunOS4 C compiler. */
8930 /* PR binutils/17531: A corrupt file can trigger this test.
8931 So do not use an assert, instead generate an error message. */
8932 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8933 error (_("Bad value (%d) for SYMINENT entry\n"),
8934 (int) entry
->d_un
.d_val
);
8936 else if (entry
->d_tag
== DT_SYMINSZ
)
8937 syminsz
= entry
->d_un
.d_val
;
8938 else if (entry
->d_tag
== DT_SYMINFO
)
8939 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8943 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8945 Elf_External_Syminfo
* extsyminfo
;
8946 Elf_External_Syminfo
* extsym
;
8947 Elf_Internal_Syminfo
* syminfo
;
8949 /* There is a syminfo section. Read the data. */
8950 extsyminfo
= (Elf_External_Syminfo
*)
8951 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8952 _("symbol information"));
8956 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8957 if (dynamic_syminfo
== NULL
)
8959 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8960 (unsigned long) syminsz
);
8964 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8965 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8966 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8967 ++syminfo
, ++extsym
)
8969 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8970 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8977 if (do_dynamic
&& dynamic_addr
)
8978 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8979 dynamic_addr
, (unsigned long) dynamic_nent
);
8981 printf (_(" Tag Type Name/Value\n"));
8983 for (entry
= dynamic_section
;
8984 entry
< dynamic_section
+ dynamic_nent
;
8992 print_vma (entry
->d_tag
, FULL_HEX
);
8993 dtype
= get_dynamic_type (entry
->d_tag
);
8994 printf (" (%s)%*s", dtype
,
8995 ((is_32bit_elf
? 27 : 19)
8996 - (int) strlen (dtype
)),
9000 switch (entry
->d_tag
)
9004 print_dynamic_flags (entry
->d_un
.d_val
);
9014 switch (entry
->d_tag
)
9017 printf (_("Auxiliary library"));
9021 printf (_("Filter library"));
9025 printf (_("Configuration file"));
9029 printf (_("Dependency audit library"));
9033 printf (_("Audit library"));
9037 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9038 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9042 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9051 printf (_("Flags:"));
9053 if (entry
->d_un
.d_val
== 0)
9054 printf (_(" None\n"));
9057 unsigned long int val
= entry
->d_un
.d_val
;
9059 if (val
& DTF_1_PARINIT
)
9061 printf (" PARINIT");
9062 val
^= DTF_1_PARINIT
;
9064 if (val
& DTF_1_CONFEXP
)
9066 printf (" CONFEXP");
9067 val
^= DTF_1_CONFEXP
;
9070 printf (" %lx", val
);
9079 printf (_("Flags:"));
9081 if (entry
->d_un
.d_val
== 0)
9082 printf (_(" None\n"));
9085 unsigned long int val
= entry
->d_un
.d_val
;
9087 if (val
& DF_P1_LAZYLOAD
)
9089 printf (" LAZYLOAD");
9090 val
^= DF_P1_LAZYLOAD
;
9092 if (val
& DF_P1_GROUPPERM
)
9094 printf (" GROUPPERM");
9095 val
^= DF_P1_GROUPPERM
;
9098 printf (" %lx", val
);
9107 printf (_("Flags:"));
9108 if (entry
->d_un
.d_val
== 0)
9109 printf (_(" None\n"));
9112 unsigned long int val
= entry
->d_un
.d_val
;
9119 if (val
& DF_1_GLOBAL
)
9124 if (val
& DF_1_GROUP
)
9129 if (val
& DF_1_NODELETE
)
9131 printf (" NODELETE");
9132 val
^= DF_1_NODELETE
;
9134 if (val
& DF_1_LOADFLTR
)
9136 printf (" LOADFLTR");
9137 val
^= DF_1_LOADFLTR
;
9139 if (val
& DF_1_INITFIRST
)
9141 printf (" INITFIRST");
9142 val
^= DF_1_INITFIRST
;
9144 if (val
& DF_1_NOOPEN
)
9149 if (val
& DF_1_ORIGIN
)
9154 if (val
& DF_1_DIRECT
)
9159 if (val
& DF_1_TRANS
)
9164 if (val
& DF_1_INTERPOSE
)
9166 printf (" INTERPOSE");
9167 val
^= DF_1_INTERPOSE
;
9169 if (val
& DF_1_NODEFLIB
)
9171 printf (" NODEFLIB");
9172 val
^= DF_1_NODEFLIB
;
9174 if (val
& DF_1_NODUMP
)
9179 if (val
& DF_1_CONFALT
)
9181 printf (" CONFALT");
9182 val
^= DF_1_CONFALT
;
9184 if (val
& DF_1_ENDFILTEE
)
9186 printf (" ENDFILTEE");
9187 val
^= DF_1_ENDFILTEE
;
9189 if (val
& DF_1_DISPRELDNE
)
9191 printf (" DISPRELDNE");
9192 val
^= DF_1_DISPRELDNE
;
9194 if (val
& DF_1_DISPRELPND
)
9196 printf (" DISPRELPND");
9197 val
^= DF_1_DISPRELPND
;
9199 if (val
& DF_1_NODIRECT
)
9201 printf (" NODIRECT");
9202 val
^= DF_1_NODIRECT
;
9204 if (val
& DF_1_IGNMULDEF
)
9206 printf (" IGNMULDEF");
9207 val
^= DF_1_IGNMULDEF
;
9209 if (val
& DF_1_NOKSYMS
)
9211 printf (" NOKSYMS");
9212 val
^= DF_1_NOKSYMS
;
9214 if (val
& DF_1_NOHDR
)
9219 if (val
& DF_1_EDITED
)
9224 if (val
& DF_1_NORELOC
)
9226 printf (" NORELOC");
9227 val
^= DF_1_NORELOC
;
9229 if (val
& DF_1_SYMINTPOSE
)
9231 printf (" SYMINTPOSE");
9232 val
^= DF_1_SYMINTPOSE
;
9234 if (val
& DF_1_GLOBAUDIT
)
9236 printf (" GLOBAUDIT");
9237 val
^= DF_1_GLOBAUDIT
;
9239 if (val
& DF_1_SINGLETON
)
9241 printf (" SINGLETON");
9242 val
^= DF_1_SINGLETON
;
9244 if (val
& DF_1_STUB
)
9255 printf (" %lx", val
);
9262 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9264 puts (get_dynamic_type (entry
->d_un
.d_val
));
9284 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9290 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9291 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9297 switch (entry
->d_tag
)
9300 printf (_("Shared library: [%s]"), name
);
9302 if (streq (name
, program_interpreter
))
9303 printf (_(" program interpreter"));
9307 printf (_("Library soname: [%s]"), name
);
9311 printf (_("Library rpath: [%s]"), name
);
9315 printf (_("Library runpath: [%s]"), name
);
9319 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9324 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9337 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9341 case DT_INIT_ARRAYSZ
:
9342 case DT_FINI_ARRAYSZ
:
9343 case DT_GNU_CONFLICTSZ
:
9344 case DT_GNU_LIBLISTSZ
:
9347 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9348 printf (_(" (bytes)\n"));
9358 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9371 if (entry
->d_tag
== DT_USED
9372 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9374 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9378 printf (_("Not needed object: [%s]\n"), name
);
9383 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9389 /* The value of this entry is ignored. */
9394 case DT_GNU_PRELINKED
:
9398 time_t atime
= entry
->d_un
.d_val
;
9400 tmp
= gmtime (&atime
);
9401 /* PR 17533 file: 041-1244816-0.004. */
9403 printf (_("<corrupt time val: %lx"),
9404 (unsigned long) atime
);
9406 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9407 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9408 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9414 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9417 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9423 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9424 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9429 switch (elf_header
.e_machine
)
9432 case EM_MIPS_RS3_LE
:
9433 dynamic_section_mips_val (entry
);
9436 dynamic_section_parisc_val (entry
);
9439 dynamic_section_ia64_val (entry
);
9442 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9454 get_ver_flags (unsigned int flags
)
9456 static char buff
[32];
9463 if (flags
& VER_FLG_BASE
)
9464 strcat (buff
, "BASE ");
9466 if (flags
& VER_FLG_WEAK
)
9468 if (flags
& VER_FLG_BASE
)
9469 strcat (buff
, "| ");
9471 strcat (buff
, "WEAK ");
9474 if (flags
& VER_FLG_INFO
)
9476 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9477 strcat (buff
, "| ");
9479 strcat (buff
, "INFO ");
9482 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9483 strcat (buff
, _("| <unknown>"));
9488 /* Display the contents of the version sections. */
9491 process_version_sections (FILE * file
)
9493 Elf_Internal_Shdr
* section
;
9500 for (i
= 0, section
= section_headers
;
9501 i
< elf_header
.e_shnum
;
9504 switch (section
->sh_type
)
9506 case SHT_GNU_verdef
:
9508 Elf_External_Verdef
* edefs
;
9515 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9516 printable_section_name (section
),
9519 printf (_(" Addr: 0x"));
9520 printf_vma (section
->sh_addr
);
9521 printf (_(" Offset: %#08lx Link: %u (%s)"),
9522 (unsigned long) section
->sh_offset
, section
->sh_link
,
9523 printable_section_name_from_index (section
->sh_link
));
9525 edefs
= (Elf_External_Verdef
*)
9526 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9527 _("version definition section"));
9530 endbuf
= (char *) edefs
+ section
->sh_size
;
9532 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9535 Elf_External_Verdef
* edef
;
9536 Elf_Internal_Verdef ent
;
9537 Elf_External_Verdaux
* eaux
;
9538 Elf_Internal_Verdaux aux
;
9542 /* Check for very large indicies. */
9543 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9546 vstart
= ((char *) edefs
) + idx
;
9547 if (vstart
+ sizeof (*edef
) > endbuf
)
9550 edef
= (Elf_External_Verdef
*) vstart
;
9552 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9553 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9554 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9555 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9556 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9557 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9558 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9560 printf (_(" %#06x: Rev: %d Flags: %s"),
9561 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9563 printf (_(" Index: %d Cnt: %d "),
9564 ent
.vd_ndx
, ent
.vd_cnt
);
9566 /* Check for overflow. */
9567 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9570 vstart
+= ent
.vd_aux
;
9572 eaux
= (Elf_External_Verdaux
*) vstart
;
9574 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9575 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9577 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9578 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9580 printf (_("Name index: %ld\n"), aux
.vda_name
);
9582 isum
= idx
+ ent
.vd_aux
;
9584 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9586 /* Check for overflow. */
9587 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9590 isum
+= aux
.vda_next
;
9591 vstart
+= aux
.vda_next
;
9593 eaux
= (Elf_External_Verdaux
*) vstart
;
9594 if (vstart
+ sizeof (*eaux
) > endbuf
)
9597 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9598 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9600 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9601 printf (_(" %#06x: Parent %d: %s\n"),
9602 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9604 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9605 isum
, j
, aux
.vda_name
);
9609 printf (_(" Version def aux past end of section\n"));
9611 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9612 if (idx
+ ent
.vd_next
<= idx
)
9618 if (cnt
< section
->sh_info
)
9619 printf (_(" Version definition past end of section\n"));
9625 case SHT_GNU_verneed
:
9627 Elf_External_Verneed
* eneed
;
9634 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9635 printable_section_name (section
), section
->sh_info
);
9637 printf (_(" Addr: 0x"));
9638 printf_vma (section
->sh_addr
);
9639 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9640 (unsigned long) section
->sh_offset
, section
->sh_link
,
9641 printable_section_name_from_index (section
->sh_link
));
9643 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9644 section
->sh_offset
, 1,
9646 _("Version Needs section"));
9649 endbuf
= (char *) eneed
+ section
->sh_size
;
9651 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9653 Elf_External_Verneed
* entry
;
9654 Elf_Internal_Verneed ent
;
9659 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9662 vstart
= ((char *) eneed
) + idx
;
9663 if (vstart
+ sizeof (*entry
) > endbuf
)
9666 entry
= (Elf_External_Verneed
*) vstart
;
9668 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9669 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9670 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9671 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9672 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9674 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9676 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9677 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9679 printf (_(" File: %lx"), ent
.vn_file
);
9681 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9683 /* Check for overflow. */
9684 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9686 vstart
+= ent
.vn_aux
;
9688 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9690 Elf_External_Vernaux
* eaux
;
9691 Elf_Internal_Vernaux aux
;
9693 if (vstart
+ sizeof (*eaux
) > endbuf
)
9695 eaux
= (Elf_External_Vernaux
*) vstart
;
9697 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9698 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9699 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9700 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9701 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9703 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9704 printf (_(" %#06x: Name: %s"),
9705 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9707 printf (_(" %#06x: Name index: %lx"),
9708 isum
, aux
.vna_name
);
9710 printf (_(" Flags: %s Version: %d\n"),
9711 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9713 /* Check for overflow. */
9714 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9715 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9717 warn (_("Invalid vna_next field of %lx\n"),
9722 isum
+= aux
.vna_next
;
9723 vstart
+= aux
.vna_next
;
9727 warn (_("Missing Version Needs auxillary information\n"));
9729 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9731 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9732 cnt
= section
->sh_info
;
9738 if (cnt
< section
->sh_info
)
9739 warn (_("Missing Version Needs information\n"));
9745 case SHT_GNU_versym
:
9747 Elf_Internal_Shdr
* link_section
;
9750 unsigned char * edata
;
9751 unsigned short * data
;
9753 Elf_Internal_Sym
* symbols
;
9754 Elf_Internal_Shdr
* string_sec
;
9755 unsigned long num_syms
;
9758 if (section
->sh_link
>= elf_header
.e_shnum
)
9761 link_section
= section_headers
+ section
->sh_link
;
9762 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9764 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9769 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9770 if (symbols
== NULL
)
9773 string_sec
= section_headers
+ link_section
->sh_link
;
9775 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9776 string_sec
->sh_size
,
9777 _("version string table"));
9784 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9785 printable_section_name (section
), (unsigned long) total
);
9787 printf (_(" Addr: "));
9788 printf_vma (section
->sh_addr
);
9789 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9790 (unsigned long) section
->sh_offset
, section
->sh_link
,
9791 printable_section_name (link_section
));
9793 off
= offset_from_vma (file
,
9794 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9795 total
* sizeof (short));
9796 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9798 _("version symbol data"));
9806 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9808 for (cnt
= total
; cnt
--;)
9809 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9814 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9817 int check_def
, check_need
;
9820 printf (" %03x:", cnt
);
9822 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9823 switch (data
[cnt
+ j
])
9826 fputs (_(" 0 (*local*) "), stdout
);
9830 fputs (_(" 1 (*global*) "), stdout
);
9834 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9835 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9837 /* If this index value is greater than the size of the symbols
9838 array, break to avoid an out-of-bounds read. */
9839 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9841 warn (_("invalid index into symbol array\n"));
9847 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9848 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9851 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9858 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9860 Elf_Internal_Verneed ivn
;
9861 unsigned long offset
;
9863 offset
= offset_from_vma
9864 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9865 sizeof (Elf_External_Verneed
));
9869 Elf_Internal_Vernaux ivna
;
9870 Elf_External_Verneed evn
;
9871 Elf_External_Vernaux evna
;
9872 unsigned long a_off
;
9874 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9875 _("version need")) == NULL
)
9878 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9879 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9881 a_off
= offset
+ ivn
.vn_aux
;
9885 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9886 1, _("version need aux (2)")) == NULL
)
9893 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9894 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9897 a_off
+= ivna
.vna_next
;
9899 while (ivna
.vna_other
!= data
[cnt
+ j
]
9900 && ivna
.vna_next
!= 0);
9902 if (ivna
.vna_other
== data
[cnt
+ j
])
9904 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9906 if (ivna
.vna_name
>= string_sec
->sh_size
)
9907 name
= _("*invalid*");
9909 name
= strtab
+ ivna
.vna_name
;
9910 nn
+= printf ("(%s%-*s",
9912 12 - (int) strlen (name
),
9918 offset
+= ivn
.vn_next
;
9920 while (ivn
.vn_next
);
9923 if (check_def
&& data
[cnt
+ j
] != 0x8001
9924 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9926 Elf_Internal_Verdef ivd
;
9927 Elf_External_Verdef evd
;
9928 unsigned long offset
;
9930 offset
= offset_from_vma
9931 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9936 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9937 _("version def")) == NULL
)
9940 /* PR 17531: file: 046-1082287-0.004. */
9941 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9946 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9947 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9950 offset
+= ivd
.vd_next
;
9952 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9953 && ivd
.vd_next
!= 0);
9955 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9957 Elf_External_Verdaux evda
;
9958 Elf_Internal_Verdaux ivda
;
9960 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9962 if (get_data (&evda
, file
,
9963 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9965 _("version def aux")) == NULL
)
9968 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9970 if (ivda
.vda_name
>= string_sec
->sh_size
)
9971 name
= _("*invalid*");
9973 name
= strtab
+ ivda
.vda_name
;
9974 nn
+= printf ("(%s%-*s",
9976 12 - (int) strlen (name
),
9982 printf ("%*c", 18 - nn
, ' ');
10000 printf (_("\nNo version information found in this file.\n"));
10005 static const char *
10006 get_symbol_binding (unsigned int binding
)
10008 static char buff
[32];
10012 case STB_LOCAL
: return "LOCAL";
10013 case STB_GLOBAL
: return "GLOBAL";
10014 case STB_WEAK
: return "WEAK";
10016 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10017 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10019 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10021 if (binding
== STB_GNU_UNIQUE
10022 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10023 /* GNU is still using the default value 0. */
10024 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10026 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10029 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10034 static const char *
10035 get_symbol_type (unsigned int type
)
10037 static char buff
[32];
10041 case STT_NOTYPE
: return "NOTYPE";
10042 case STT_OBJECT
: return "OBJECT";
10043 case STT_FUNC
: return "FUNC";
10044 case STT_SECTION
: return "SECTION";
10045 case STT_FILE
: return "FILE";
10046 case STT_COMMON
: return "COMMON";
10047 case STT_TLS
: return "TLS";
10048 case STT_RELC
: return "RELC";
10049 case STT_SRELC
: return "SRELC";
10051 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10053 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10054 return "THUMB_FUNC";
10056 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10059 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10060 return "PARISC_MILLI";
10062 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10064 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10066 if (elf_header
.e_machine
== EM_PARISC
)
10068 if (type
== STT_HP_OPAQUE
)
10069 return "HP_OPAQUE";
10070 if (type
== STT_HP_STUB
)
10074 if (type
== STT_GNU_IFUNC
10075 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10076 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10077 /* GNU is still using the default value 0. */
10078 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10081 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10084 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10089 static const char *
10090 get_symbol_visibility (unsigned int visibility
)
10092 switch (visibility
)
10094 case STV_DEFAULT
: return "DEFAULT";
10095 case STV_INTERNAL
: return "INTERNAL";
10096 case STV_HIDDEN
: return "HIDDEN";
10097 case STV_PROTECTED
: return "PROTECTED";
10099 error (_("Unrecognized visibility value: %u"), visibility
);
10100 return _("<unknown>");
10104 static const char *
10105 get_mips_symbol_other (unsigned int other
)
10115 case STO_MICROMIPS
:
10116 return "MICROMIPS";
10117 case STO_MICROMIPS
| STO_MIPS_PIC
:
10118 return "MICROMIPS, MIPS PIC";
10126 static const char *
10127 get_ia64_symbol_other (unsigned int other
)
10129 if (is_ia64_vms ())
10131 static char res
[32];
10135 /* Function types is for images and .STB files only. */
10136 switch (elf_header
.e_type
)
10140 switch (VMS_ST_FUNC_TYPE (other
))
10142 case VMS_SFT_CODE_ADDR
:
10143 strcat (res
, " CA");
10145 case VMS_SFT_SYMV_IDX
:
10146 strcat (res
, " VEC");
10149 strcat (res
, " FD");
10151 case VMS_SFT_RESERVE
:
10152 strcat (res
, " RSV");
10155 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10156 VMS_ST_FUNC_TYPE (other
));
10157 strcat (res
, " <unknown>");
10164 switch (VMS_ST_LINKAGE (other
))
10166 case VMS_STL_IGNORE
:
10167 strcat (res
, " IGN");
10169 case VMS_STL_RESERVE
:
10170 strcat (res
, " RSV");
10173 strcat (res
, " STD");
10176 strcat (res
, " LNK");
10179 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10180 VMS_ST_LINKAGE (other
));
10181 strcat (res
, " <unknown>");
10193 static const char *
10194 get_ppc64_symbol_other (unsigned int other
)
10196 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10198 static char buf
[32];
10199 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10200 PPC64_LOCAL_ENTRY_OFFSET (other
));
10206 static const char *
10207 get_symbol_other (unsigned int other
)
10209 const char * result
= NULL
;
10210 static char buff
[32];
10215 switch (elf_header
.e_machine
)
10218 result
= get_mips_symbol_other (other
);
10221 result
= get_ia64_symbol_other (other
);
10224 result
= get_ppc64_symbol_other (other
);
10233 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10237 static const char *
10238 get_symbol_index_type (unsigned int type
)
10240 static char buff
[32];
10244 case SHN_UNDEF
: return "UND";
10245 case SHN_ABS
: return "ABS";
10246 case SHN_COMMON
: return "COM";
10248 if (type
== SHN_IA_64_ANSI_COMMON
10249 && elf_header
.e_machine
== EM_IA_64
10250 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10252 else if ((elf_header
.e_machine
== EM_X86_64
10253 || elf_header
.e_machine
== EM_L1OM
10254 || elf_header
.e_machine
== EM_K1OM
)
10255 && type
== SHN_X86_64_LCOMMON
)
10256 return "LARGE_COM";
10257 else if ((type
== SHN_MIPS_SCOMMON
10258 && elf_header
.e_machine
== EM_MIPS
)
10259 || (type
== SHN_TIC6X_SCOMMON
10260 && elf_header
.e_machine
== EM_TI_C6000
))
10262 else if (type
== SHN_MIPS_SUNDEFINED
10263 && elf_header
.e_machine
== EM_MIPS
)
10265 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10266 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10267 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10268 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10269 else if (type
>= SHN_LORESERVE
)
10270 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10271 else if (type
>= elf_header
.e_shnum
)
10272 sprintf (buff
, _("bad section index[%3d]"), type
);
10274 sprintf (buff
, "%3d", type
);
10282 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10284 unsigned char * e_data
;
10287 /* If the size_t type is smaller than the bfd_size_type, eg because
10288 you are building a 32-bit tool on a 64-bit host, then make sure
10289 that when (number) is cast to (size_t) no information is lost. */
10290 if (sizeof (size_t) < sizeof (bfd_size_type
)
10291 && (bfd_size_type
) ((size_t) number
) != number
)
10293 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10294 (unsigned long long) number
, ent_size
);
10298 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10299 attempting to allocate memory when the read is bound to fail. */
10300 if (ent_size
* number
> current_file_size
)
10302 error (_("Invalid number of dynamic entries: %llu\n"),
10303 (unsigned long long) number
);
10307 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10308 if (e_data
== NULL
)
10310 error (_("Out of memory reading %llu dynamic entries\n"),
10311 (unsigned long long) number
);
10315 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10317 error (_("Unable to read in %llu bytes of dynamic data\n"),
10318 (unsigned long long) (number
* ent_size
));
10323 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10324 if (i_data
== NULL
)
10326 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10327 (unsigned long long) number
);
10333 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10341 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10343 Elf_Internal_Sym
* psym
;
10346 n
= print_vma (si
, DEC_5
);
10348 fputs (&" "[n
], stdout
);
10349 printf (" %3lu: ", hn
);
10351 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10353 printf (_("<No info available for dynamic symbol number %lu>\n"),
10354 (unsigned long) si
);
10358 psym
= dynamic_symbols
+ si
;
10359 print_vma (psym
->st_value
, LONG_HEX
);
10361 print_vma (psym
->st_size
, DEC_5
);
10363 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10364 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10365 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10366 /* Check to see if any other bits in the st_other field are set.
10367 Note - displaying this information disrupts the layout of the
10368 table being generated, but for the moment this case is very
10370 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10371 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10372 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10373 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10374 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10376 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10380 static const char *
10381 get_symbol_version_string (FILE *file
, int is_dynsym
,
10382 const char *strtab
,
10383 unsigned long int strtab_size
,
10384 unsigned int si
, Elf_Internal_Sym
*psym
,
10385 enum versioned_symbol_info
*sym_info
,
10386 unsigned short *vna_other
)
10388 const char *version_string
= NULL
;
10391 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10393 unsigned char data
[2];
10394 unsigned short vers_data
;
10395 unsigned long offset
;
10399 offset
= offset_from_vma
10400 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10401 sizeof data
+ si
* sizeof (vers_data
));
10403 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10404 sizeof (data
), 1, _("version data")) == NULL
)
10407 vers_data
= byte_get (data
, 2);
10409 is_nobits
= (section_headers
!= NULL
10410 && psym
->st_shndx
< elf_header
.e_shnum
10411 && section_headers
[psym
->st_shndx
].sh_type
10414 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10416 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10418 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10419 && (is_nobits
|| ! check_def
))
10421 Elf_External_Verneed evn
;
10422 Elf_Internal_Verneed ivn
;
10423 Elf_Internal_Vernaux ivna
;
10425 /* We must test both. */
10426 offset
= offset_from_vma
10427 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10432 unsigned long vna_off
;
10434 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10435 _("version need")) == NULL
)
10438 ivna
.vna_other
= 0;
10443 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10444 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10446 vna_off
= offset
+ ivn
.vn_aux
;
10450 Elf_External_Vernaux evna
;
10452 if (get_data (&evna
, file
, vna_off
,
10454 _("version need aux (3)")) == NULL
)
10457 ivna
.vna_other
= 0;
10462 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10463 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10464 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10467 vna_off
+= ivna
.vna_next
;
10469 while (ivna
.vna_other
!= vers_data
10470 && ivna
.vna_next
!= 0);
10472 if (ivna
.vna_other
== vers_data
)
10475 offset
+= ivn
.vn_next
;
10477 while (ivn
.vn_next
!= 0);
10479 if (ivna
.vna_other
== vers_data
)
10481 *sym_info
= symbol_undefined
;
10482 *vna_other
= ivna
.vna_other
;
10483 version_string
= (ivna
.vna_name
< strtab_size
10484 ? strtab
+ ivna
.vna_name
10488 else if (! is_nobits
)
10489 error (_("bad dynamic symbol\n"));
10496 if (vers_data
!= 0x8001
10497 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10499 Elf_Internal_Verdef ivd
;
10500 Elf_Internal_Verdaux ivda
;
10501 Elf_External_Verdaux evda
;
10504 off
= offset_from_vma
10506 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10507 sizeof (Elf_External_Verdef
));
10511 Elf_External_Verdef evd
;
10513 if (get_data (&evd
, file
, off
, sizeof (evd
),
10514 1, _("version def")) == NULL
)
10522 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10523 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10524 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10527 off
+= ivd
.vd_next
;
10529 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10530 && ivd
.vd_next
!= 0);
10532 off
-= ivd
.vd_next
;
10535 if (get_data (&evda
, file
, off
, sizeof (evda
),
10536 1, _("version def aux")) == NULL
)
10537 return version_string
;
10539 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10541 if (psym
->st_name
!= ivda
.vda_name
)
10543 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10544 ? symbol_hidden
: symbol_public
);
10545 version_string
= (ivda
.vda_name
< strtab_size
10546 ? strtab
+ ivda
.vda_name
10553 return version_string
;
10556 /* Dump the symbol table. */
10558 process_symbol_table (FILE * file
)
10560 Elf_Internal_Shdr
* section
;
10561 bfd_size_type nbuckets
= 0;
10562 bfd_size_type nchains
= 0;
10563 bfd_vma
* buckets
= NULL
;
10564 bfd_vma
* chains
= NULL
;
10565 bfd_vma ngnubuckets
= 0;
10566 bfd_vma
* gnubuckets
= NULL
;
10567 bfd_vma
* gnuchains
= NULL
;
10568 bfd_vma gnusymidx
= 0;
10569 bfd_size_type ngnuchains
= 0;
10571 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10574 if (dynamic_info
[DT_HASH
]
10576 || (do_using_dynamic
10578 && dynamic_strings
!= NULL
)))
10580 unsigned char nb
[8];
10581 unsigned char nc
[8];
10582 unsigned int hash_ent_size
= 4;
10584 if ((elf_header
.e_machine
== EM_ALPHA
10585 || elf_header
.e_machine
== EM_S390
10586 || elf_header
.e_machine
== EM_S390_OLD
)
10587 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10591 (archive_file_offset
10592 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10593 sizeof nb
+ sizeof nc
)),
10596 error (_("Unable to seek to start of dynamic information\n"));
10600 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10602 error (_("Failed to read in number of buckets\n"));
10606 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10608 error (_("Failed to read in number of chains\n"));
10612 nbuckets
= byte_get (nb
, hash_ent_size
);
10613 nchains
= byte_get (nc
, hash_ent_size
);
10615 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10616 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10619 if (buckets
== NULL
|| chains
== NULL
)
10621 if (do_using_dynamic
)
10632 if (dynamic_info_DT_GNU_HASH
10634 || (do_using_dynamic
10636 && dynamic_strings
!= NULL
)))
10638 unsigned char nb
[16];
10639 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10640 bfd_vma buckets_vma
;
10643 (archive_file_offset
10644 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10648 error (_("Unable to seek to start of dynamic information\n"));
10652 if (fread (nb
, 16, 1, file
) != 1)
10654 error (_("Failed to read in number of buckets\n"));
10658 ngnubuckets
= byte_get (nb
, 4);
10659 gnusymidx
= byte_get (nb
+ 4, 4);
10660 bitmaskwords
= byte_get (nb
+ 8, 4);
10661 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10663 buckets_vma
+= bitmaskwords
* 4;
10665 buckets_vma
+= bitmaskwords
* 8;
10668 (archive_file_offset
10669 + offset_from_vma (file
, buckets_vma
, 4)),
10672 error (_("Unable to seek to start of dynamic information\n"));
10676 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10678 if (gnubuckets
== NULL
)
10681 for (i
= 0; i
< ngnubuckets
; i
++)
10682 if (gnubuckets
[i
] != 0)
10684 if (gnubuckets
[i
] < gnusymidx
)
10687 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10688 maxchain
= gnubuckets
[i
];
10691 if (maxchain
== 0xffffffff)
10694 maxchain
-= gnusymidx
;
10697 (archive_file_offset
10698 + offset_from_vma (file
, buckets_vma
10699 + 4 * (ngnubuckets
+ maxchain
), 4)),
10702 error (_("Unable to seek to start of dynamic information\n"));
10708 if (fread (nb
, 4, 1, file
) != 1)
10710 error (_("Failed to determine last chain length\n"));
10714 if (maxchain
+ 1 == 0)
10719 while ((byte_get (nb
, 4) & 1) == 0);
10722 (archive_file_offset
10723 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10726 error (_("Unable to seek to start of dynamic information\n"));
10730 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10731 ngnuchains
= maxchain
;
10734 if (gnuchains
== NULL
)
10739 if (do_using_dynamic
)
10744 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10746 && do_using_dynamic
10747 && dynamic_strings
!= NULL
10748 && dynamic_symbols
!= NULL
)
10752 if (dynamic_info
[DT_HASH
])
10756 printf (_("\nSymbol table for image:\n"));
10758 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10760 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10762 for (hn
= 0; hn
< nbuckets
; hn
++)
10767 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10768 print_dynamic_symbol (si
, hn
);
10772 if (dynamic_info_DT_GNU_HASH
)
10774 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10776 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10778 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10780 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10781 if (gnubuckets
[hn
] != 0)
10783 bfd_vma si
= gnubuckets
[hn
];
10784 bfd_vma off
= si
- gnusymidx
;
10788 print_dynamic_symbol (si
, hn
);
10791 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10795 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10796 && section_headers
!= NULL
)
10800 for (i
= 0, section
= section_headers
;
10801 i
< elf_header
.e_shnum
;
10805 char * strtab
= NULL
;
10806 unsigned long int strtab_size
= 0;
10807 Elf_Internal_Sym
* symtab
;
10808 Elf_Internal_Sym
* psym
;
10809 unsigned long num_syms
;
10811 if ((section
->sh_type
!= SHT_SYMTAB
10812 && section
->sh_type
!= SHT_DYNSYM
)
10814 && section
->sh_type
== SHT_SYMTAB
))
10817 if (section
->sh_entsize
== 0)
10819 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10820 printable_section_name (section
));
10824 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10825 printable_section_name (section
),
10826 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10829 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10831 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10833 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10834 if (symtab
== NULL
)
10837 if (section
->sh_link
== elf_header
.e_shstrndx
)
10839 strtab
= string_table
;
10840 strtab_size
= string_table_length
;
10842 else if (section
->sh_link
< elf_header
.e_shnum
)
10844 Elf_Internal_Shdr
* string_sec
;
10846 string_sec
= section_headers
+ section
->sh_link
;
10848 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10849 1, string_sec
->sh_size
,
10850 _("string table"));
10851 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10854 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10856 const char *version_string
;
10857 enum versioned_symbol_info sym_info
;
10858 unsigned short vna_other
;
10860 printf ("%6d: ", si
);
10861 print_vma (psym
->st_value
, LONG_HEX
);
10863 print_vma (psym
->st_size
, DEC_5
);
10864 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10865 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10866 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10867 /* Check to see if any other bits in the st_other field are set.
10868 Note - displaying this information disrupts the layout of the
10869 table being generated, but for the moment this case is very rare. */
10870 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10871 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10872 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10873 print_symbol (25, psym
->st_name
< strtab_size
10874 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10877 = get_symbol_version_string (file
,
10878 section
->sh_type
== SHT_DYNSYM
,
10879 strtab
, strtab_size
, si
,
10880 psym
, &sym_info
, &vna_other
);
10881 if (version_string
)
10883 if (sym_info
== symbol_undefined
)
10884 printf ("@%s (%d)", version_string
, vna_other
);
10886 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10894 if (strtab
!= string_table
)
10900 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10902 if (do_histogram
&& buckets
!= NULL
)
10904 unsigned long * lengths
;
10905 unsigned long * counts
;
10908 unsigned long maxlength
= 0;
10909 unsigned long nzero_counts
= 0;
10910 unsigned long nsyms
= 0;
10911 unsigned long chained
;
10913 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10914 (unsigned long) nbuckets
);
10916 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10917 if (lengths
== NULL
)
10919 error (_("Out of memory allocating space for histogram buckets\n"));
10923 printf (_(" Length Number %% of total Coverage\n"));
10924 for (hn
= 0; hn
< nbuckets
; ++hn
)
10926 for (si
= buckets
[hn
], chained
= 0;
10927 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10928 si
= chains
[si
], ++chained
)
10931 if (maxlength
< ++lengths
[hn
])
10935 /* PR binutils/17531: A corrupt binary could contain broken
10936 histogram data. Do not go into an infinite loop trying
10938 if (chained
> nchains
)
10940 error (_("histogram chain is corrupt\n"));
10945 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10946 if (counts
== NULL
)
10949 error (_("Out of memory allocating space for histogram counts\n"));
10953 for (hn
= 0; hn
< nbuckets
; ++hn
)
10954 ++counts
[lengths
[hn
]];
10959 printf (" 0 %-10lu (%5.1f%%)\n",
10960 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10961 for (i
= 1; i
<= maxlength
; ++i
)
10963 nzero_counts
+= counts
[i
] * i
;
10964 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10965 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10966 (nzero_counts
* 100.0) / nsyms
);
10974 if (buckets
!= NULL
)
10980 if (do_histogram
&& gnubuckets
!= NULL
)
10982 unsigned long * lengths
;
10983 unsigned long * counts
;
10985 unsigned long maxlength
= 0;
10986 unsigned long nzero_counts
= 0;
10987 unsigned long nsyms
= 0;
10989 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10990 (unsigned long) ngnubuckets
);
10992 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10993 if (lengths
== NULL
)
10995 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10999 printf (_(" Length Number %% of total Coverage\n"));
11001 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11002 if (gnubuckets
[hn
] != 0)
11004 bfd_vma off
, length
= 1;
11006 for (off
= gnubuckets
[hn
] - gnusymidx
;
11007 /* PR 17531 file: 010-77222-0.004. */
11008 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11011 lengths
[hn
] = length
;
11012 if (length
> maxlength
)
11013 maxlength
= length
;
11017 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11018 if (counts
== NULL
)
11021 error (_("Out of memory allocating space for gnu histogram counts\n"));
11025 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11026 ++counts
[lengths
[hn
]];
11028 if (ngnubuckets
> 0)
11031 printf (" 0 %-10lu (%5.1f%%)\n",
11032 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11033 for (j
= 1; j
<= maxlength
; ++j
)
11035 nzero_counts
+= counts
[j
] * j
;
11036 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11037 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11038 (nzero_counts
* 100.0) / nsyms
);
11052 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11056 if (dynamic_syminfo
== NULL
11058 /* No syminfo, this is ok. */
11061 /* There better should be a dynamic symbol section. */
11062 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11066 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11067 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11069 printf (_(" Num: Name BoundTo Flags\n"));
11070 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11072 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11074 printf ("%4d: ", i
);
11075 if (i
>= num_dynamic_syms
)
11076 printf (_("<corrupt index>"));
11077 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11078 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11080 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11083 switch (dynamic_syminfo
[i
].si_boundto
)
11085 case SYMINFO_BT_SELF
:
11086 fputs ("SELF ", stdout
);
11088 case SYMINFO_BT_PARENT
:
11089 fputs ("PARENT ", stdout
);
11092 if (dynamic_syminfo
[i
].si_boundto
> 0
11093 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11094 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11096 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11100 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11104 if (flags
& SYMINFO_FLG_DIRECT
)
11105 printf (" DIRECT");
11106 if (flags
& SYMINFO_FLG_PASSTHRU
)
11107 printf (" PASSTHRU");
11108 if (flags
& SYMINFO_FLG_COPY
)
11110 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11111 printf (" LAZYLOAD");
11119 /* Check to see if the given reloc needs to be handled in a target specific
11120 manner. If so then process the reloc and return TRUE otherwise return
11124 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11125 unsigned char * start
,
11126 Elf_Internal_Sym
* symtab
)
11128 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11130 switch (elf_header
.e_machine
)
11133 case EM_MSP430_OLD
:
11135 static Elf_Internal_Sym
* saved_sym
= NULL
;
11137 switch (reloc_type
)
11139 case 10: /* R_MSP430_SYM_DIFF */
11140 if (uses_msp430x_relocs ())
11142 case 21: /* R_MSP430X_SYM_DIFF */
11143 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11146 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11147 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11148 goto handle_sym_diff
;
11150 case 5: /* R_MSP430_16_BYTE */
11151 case 9: /* R_MSP430_8 */
11152 if (uses_msp430x_relocs ())
11154 goto handle_sym_diff
;
11156 case 2: /* R_MSP430_ABS16 */
11157 case 15: /* R_MSP430X_ABS16 */
11158 if (! uses_msp430x_relocs ())
11160 goto handle_sym_diff
;
11163 if (saved_sym
!= NULL
)
11167 value
= reloc
->r_addend
11168 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11169 - saved_sym
->st_value
);
11171 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11179 if (saved_sym
!= NULL
)
11180 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11187 case EM_CYGNUS_MN10300
:
11189 static Elf_Internal_Sym
* saved_sym
= NULL
;
11191 switch (reloc_type
)
11193 case 34: /* R_MN10300_ALIGN */
11195 case 33: /* R_MN10300_SYM_DIFF */
11196 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11198 case 1: /* R_MN10300_32 */
11199 case 2: /* R_MN10300_16 */
11200 if (saved_sym
!= NULL
)
11204 value
= reloc
->r_addend
11205 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11206 - saved_sym
->st_value
);
11208 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11215 if (saved_sym
!= NULL
)
11216 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11224 static bfd_vma saved_sym1
= 0;
11225 static bfd_vma saved_sym2
= 0;
11226 static bfd_vma value
;
11228 switch (reloc_type
)
11230 case 0x80: /* R_RL78_SYM. */
11231 saved_sym1
= saved_sym2
;
11232 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11233 saved_sym2
+= reloc
->r_addend
;
11236 case 0x83: /* R_RL78_OPsub. */
11237 value
= saved_sym1
- saved_sym2
;
11238 saved_sym2
= saved_sym1
= 0;
11242 case 0x41: /* R_RL78_ABS32. */
11243 byte_put (start
+ reloc
->r_offset
, value
, 4);
11247 case 0x43: /* R_RL78_ABS16. */
11248 byte_put (start
+ reloc
->r_offset
, value
, 2);
11262 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11263 DWARF debug sections. This is a target specific test. Note - we do not
11264 go through the whole including-target-headers-multiple-times route, (as
11265 we have already done with <elf/h8.h>) because this would become very
11266 messy and even then this function would have to contain target specific
11267 information (the names of the relocs instead of their numeric values).
11268 FIXME: This is not the correct way to solve this problem. The proper way
11269 is to have target specific reloc sizing and typing functions created by
11270 the reloc-macros.h header, in the same way that it already creates the
11271 reloc naming functions. */
11274 is_32bit_abs_reloc (unsigned int reloc_type
)
11276 switch (elf_header
.e_machine
)
11280 return reloc_type
== 1; /* R_386_32. */
11282 return reloc_type
== 1; /* R_68K_32. */
11284 return reloc_type
== 1; /* R_860_32. */
11286 return reloc_type
== 2; /* R_960_32. */
11288 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11290 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11292 return reloc_type
== 1; /* R_ARC_32. */
11294 return reloc_type
== 2; /* R_ARM_ABS32 */
11297 return reloc_type
== 1;
11298 case EM_ADAPTEVA_EPIPHANY
:
11299 return reloc_type
== 3;
11301 return reloc_type
== 0x12; /* R_byte4_data. */
11303 return reloc_type
== 3; /* R_CRIS_32. */
11305 return reloc_type
== 3; /* R_CR16_NUM32. */
11307 return reloc_type
== 15; /* R_CRX_NUM32. */
11308 case EM_CYGNUS_FRV
:
11309 return reloc_type
== 1;
11310 case EM_CYGNUS_D10V
:
11312 return reloc_type
== 6; /* R_D10V_32. */
11313 case EM_CYGNUS_D30V
:
11315 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11317 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11318 case EM_CYGNUS_FR30
:
11320 return reloc_type
== 3; /* R_FR30_32. */
11322 return reloc_type
== 1; /* R_FT32_32. */
11326 return reloc_type
== 1; /* R_H8_DIR32. */
11328 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11329 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11332 return reloc_type
== 2; /* R_IP2K_32. */
11334 return reloc_type
== 2; /* R_IQ2000_32. */
11335 case EM_LATTICEMICO32
:
11336 return reloc_type
== 3; /* R_LM32_32. */
11339 return reloc_type
== 3; /* R_M32C_32. */
11341 return reloc_type
== 34; /* R_M32R_32_RELA. */
11343 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11344 case EM_CYGNUS_MEP
:
11345 return reloc_type
== 4; /* R_MEP_32. */
11347 return reloc_type
== 2; /* R_METAG_ADDR32. */
11348 case EM_MICROBLAZE
:
11349 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11351 return reloc_type
== 2; /* R_MIPS_32. */
11353 return reloc_type
== 4; /* R_MMIX_32. */
11354 case EM_CYGNUS_MN10200
:
11356 return reloc_type
== 1; /* R_MN10200_32. */
11357 case EM_CYGNUS_MN10300
:
11359 return reloc_type
== 1; /* R_MN10300_32. */
11361 return reloc_type
== 1; /* R_MOXIE_32. */
11362 case EM_MSP430_OLD
:
11364 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11366 return reloc_type
== 2; /* R_MT_32. */
11368 return reloc_type
== 20; /* R_NDS32_RELA. */
11369 case EM_ALTERA_NIOS2
:
11370 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11372 return reloc_type
== 1; /* R_NIOS_32. */
11374 return reloc_type
== 1; /* R_OR1K_32. */
11376 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11377 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11380 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11382 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11384 return reloc_type
== 1; /* R_PPC_ADDR32. */
11386 return reloc_type
== 1; /* R_RL78_DIR32. */
11388 return reloc_type
== 1; /* R_RX_DIR32. */
11390 return reloc_type
== 1; /* R_I370_ADDR31. */
11393 return reloc_type
== 4; /* R_S390_32. */
11395 return reloc_type
== 8; /* R_SCORE_ABS32. */
11397 return reloc_type
== 1; /* R_SH_DIR32. */
11398 case EM_SPARC32PLUS
:
11401 return reloc_type
== 3 /* R_SPARC_32. */
11402 || reloc_type
== 23; /* R_SPARC_UA32. */
11404 return reloc_type
== 6; /* R_SPU_ADDR32 */
11406 return reloc_type
== 1; /* R_C6000_ABS32. */
11408 return reloc_type
== 2; /* R_TILEGX_32. */
11410 return reloc_type
== 1; /* R_TILEPRO_32. */
11411 case EM_CYGNUS_V850
:
11413 return reloc_type
== 6; /* R_V850_ABS32. */
11415 return reloc_type
== 0x33; /* R_V810_WORD. */
11417 return reloc_type
== 1; /* R_VAX_32. */
11419 return reloc_type
== 3; /* R_VISIUM_32. */
11423 return reloc_type
== 10; /* R_X86_64_32. */
11426 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11428 return reloc_type
== 4; /* R_XGATE_32. */
11430 return reloc_type
== 1; /* R_XSTROMY16_32. */
11431 case EM_XTENSA_OLD
:
11433 return reloc_type
== 1; /* R_XTENSA_32. */
11436 static unsigned int prev_warn
= 0;
11438 /* Avoid repeating the same warning multiple times. */
11439 if (prev_warn
!= elf_header
.e_machine
)
11440 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11441 elf_header
.e_machine
);
11442 prev_warn
= elf_header
.e_machine
;
11448 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11449 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11452 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11454 switch (elf_header
.e_machine
)
11458 return reloc_type
== 2; /* R_386_PC32. */
11460 return reloc_type
== 4; /* R_68K_PC32. */
11462 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11463 case EM_ADAPTEVA_EPIPHANY
:
11464 return reloc_type
== 6;
11466 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11468 return reloc_type
== 3; /* R_ARM_REL32 */
11469 case EM_MICROBLAZE
:
11470 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11472 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11474 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11476 return reloc_type
== 26; /* R_PPC_REL32. */
11478 return reloc_type
== 26; /* R_PPC64_REL32. */
11481 return reloc_type
== 5; /* R_390_PC32. */
11483 return reloc_type
== 2; /* R_SH_REL32. */
11484 case EM_SPARC32PLUS
:
11487 return reloc_type
== 6; /* R_SPARC_DISP32. */
11489 return reloc_type
== 13; /* R_SPU_REL32. */
11491 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11493 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11495 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11499 return reloc_type
== 2; /* R_X86_64_PC32. */
11500 case EM_XTENSA_OLD
:
11502 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11504 /* Do not abort or issue an error message here. Not all targets use
11505 pc-relative 32-bit relocs in their DWARF debug information and we
11506 have already tested for target coverage in is_32bit_abs_reloc. A
11507 more helpful warning message will be generated by apply_relocations
11508 anyway, so just return. */
11513 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11514 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11517 is_64bit_abs_reloc (unsigned int reloc_type
)
11519 switch (elf_header
.e_machine
)
11522 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11524 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11526 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11528 return reloc_type
== 80; /* R_PARISC_DIR64. */
11530 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11531 case EM_SPARC32PLUS
:
11534 return reloc_type
== 54; /* R_SPARC_UA64. */
11538 return reloc_type
== 1; /* R_X86_64_64. */
11541 return reloc_type
== 22; /* R_S390_64. */
11543 return reloc_type
== 1; /* R_TILEGX_64. */
11545 return reloc_type
== 18; /* R_MIPS_64. */
11551 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11552 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11555 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11557 switch (elf_header
.e_machine
)
11560 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11562 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11564 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11566 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11568 return reloc_type
== 44; /* R_PPC64_REL64. */
11569 case EM_SPARC32PLUS
:
11572 return reloc_type
== 46; /* R_SPARC_DISP64. */
11576 return reloc_type
== 24; /* R_X86_64_PC64. */
11579 return reloc_type
== 23; /* R_S390_PC64. */
11581 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11587 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11588 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11591 is_24bit_abs_reloc (unsigned int reloc_type
)
11593 switch (elf_header
.e_machine
)
11595 case EM_CYGNUS_MN10200
:
11597 return reloc_type
== 4; /* R_MN10200_24. */
11603 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11604 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11607 is_16bit_abs_reloc (unsigned int reloc_type
)
11609 switch (elf_header
.e_machine
)
11613 return reloc_type
== 4; /* R_AVR_16. */
11614 case EM_ADAPTEVA_EPIPHANY
:
11615 return reloc_type
== 5;
11616 case EM_CYGNUS_D10V
:
11618 return reloc_type
== 3; /* R_D10V_16. */
11622 return reloc_type
== R_H8_DIR16
;
11625 return reloc_type
== 1; /* R_IP2K_16. */
11628 return reloc_type
== 1; /* R_M32C_16 */
11630 if (uses_msp430x_relocs ())
11631 return reloc_type
== 2; /* R_MSP430_ABS16. */
11632 case EM_MSP430_OLD
:
11633 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11635 return reloc_type
== 19; /* R_NDS32_RELA. */
11636 case EM_ALTERA_NIOS2
:
11637 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11639 return reloc_type
== 9; /* R_NIOS_16. */
11641 return reloc_type
== 2; /* R_OR1K_16. */
11643 return reloc_type
== 2; /* R_C6000_ABS16. */
11646 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11647 case EM_CYGNUS_MN10200
:
11649 return reloc_type
== 2; /* R_MN10200_16. */
11650 case EM_CYGNUS_MN10300
:
11652 return reloc_type
== 2; /* R_MN10300_16. */
11654 return reloc_type
== 2; /* R_VISIUM_16. */
11656 return reloc_type
== 3; /* R_XGATE_16. */
11662 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11663 relocation entries (possibly formerly used for SHT_GROUP sections). */
11666 is_none_reloc (unsigned int reloc_type
)
11668 switch (elf_header
.e_machine
)
11670 case EM_68K
: /* R_68K_NONE. */
11671 case EM_386
: /* R_386_NONE. */
11672 case EM_SPARC32PLUS
:
11674 case EM_SPARC
: /* R_SPARC_NONE. */
11675 case EM_MIPS
: /* R_MIPS_NONE. */
11676 case EM_PARISC
: /* R_PARISC_NONE. */
11677 case EM_ALPHA
: /* R_ALPHA_NONE. */
11678 case EM_ADAPTEVA_EPIPHANY
:
11679 case EM_PPC
: /* R_PPC_NONE. */
11680 case EM_PPC64
: /* R_PPC64_NONE. */
11681 case EM_ARM
: /* R_ARM_NONE. */
11682 case EM_IA_64
: /* R_IA64_NONE. */
11683 case EM_SH
: /* R_SH_NONE. */
11685 case EM_S390
: /* R_390_NONE. */
11686 case EM_CRIS
: /* R_CRIS_NONE. */
11687 case EM_X86_64
: /* R_X86_64_NONE. */
11688 case EM_L1OM
: /* R_X86_64_NONE. */
11689 case EM_K1OM
: /* R_X86_64_NONE. */
11690 case EM_MN10300
: /* R_MN10300_NONE. */
11691 case EM_FT32
: /* R_FT32_NONE. */
11692 case EM_MOXIE
: /* R_MOXIE_NONE. */
11693 case EM_M32R
: /* R_M32R_NONE. */
11694 case EM_TI_C6000
:/* R_C6000_NONE. */
11695 case EM_TILEGX
: /* R_TILEGX_NONE. */
11696 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11698 case EM_C166
: /* R_XC16X_NONE. */
11699 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11700 case EM_NIOS32
: /* R_NIOS_NONE. */
11701 case EM_OR1K
: /* R_OR1K_NONE. */
11702 return reloc_type
== 0;
11704 return reloc_type
== 0 || reloc_type
== 256;
11706 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11707 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11708 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11709 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11710 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11711 case EM_XTENSA_OLD
:
11713 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11714 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11715 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11716 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11718 return reloc_type
== 3; /* R_METAG_NONE. */
11723 /* Returns TRUE if there is a relocation against
11724 section NAME at OFFSET bytes. */
11727 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11729 Elf_Internal_Rela
* relocs
;
11730 Elf_Internal_Rela
* rp
;
11732 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11735 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11737 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11738 if (rp
->r_offset
== offset
)
11744 /* Apply relocations to a section.
11745 Note: So far support has been added only for those relocations
11746 which can be found in debug sections.
11747 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11748 loaded relocs. It is then the caller's responsibility to free them.
11749 FIXME: Add support for more relocations ? */
11752 apply_relocations (void * file
,
11753 const Elf_Internal_Shdr
* section
,
11754 unsigned char * start
,
11755 bfd_size_type size
,
11756 void ** relocs_return
,
11757 unsigned long * num_relocs_return
)
11759 Elf_Internal_Shdr
* relsec
;
11760 unsigned char * end
= start
+ size
;
11762 if (relocs_return
!= NULL
)
11764 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11765 * num_relocs_return
= 0;
11768 if (elf_header
.e_type
!= ET_REL
)
11771 /* Find the reloc section associated with the section. */
11772 for (relsec
= section_headers
;
11773 relsec
< section_headers
+ elf_header
.e_shnum
;
11776 bfd_boolean is_rela
;
11777 unsigned long num_relocs
;
11778 Elf_Internal_Rela
* relocs
;
11779 Elf_Internal_Rela
* rp
;
11780 Elf_Internal_Shdr
* symsec
;
11781 Elf_Internal_Sym
* symtab
;
11782 unsigned long num_syms
;
11783 Elf_Internal_Sym
* sym
;
11785 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11786 || relsec
->sh_info
>= elf_header
.e_shnum
11787 || section_headers
+ relsec
->sh_info
!= section
11788 || relsec
->sh_size
== 0
11789 || relsec
->sh_link
>= elf_header
.e_shnum
)
11792 is_rela
= relsec
->sh_type
== SHT_RELA
;
11796 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11797 relsec
->sh_size
, & relocs
, & num_relocs
))
11802 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11803 relsec
->sh_size
, & relocs
, & num_relocs
))
11807 /* SH uses RELA but uses in place value instead of the addend field. */
11808 if (elf_header
.e_machine
== EM_SH
)
11811 symsec
= section_headers
+ relsec
->sh_link
;
11812 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11814 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11817 unsigned int reloc_type
;
11818 unsigned int reloc_size
;
11819 unsigned char * rloc
;
11820 unsigned long sym_index
;
11822 reloc_type
= get_reloc_type (rp
->r_info
);
11824 if (target_specific_reloc_handling (rp
, start
, symtab
))
11826 else if (is_none_reloc (reloc_type
))
11828 else if (is_32bit_abs_reloc (reloc_type
)
11829 || is_32bit_pcrel_reloc (reloc_type
))
11831 else if (is_64bit_abs_reloc (reloc_type
)
11832 || is_64bit_pcrel_reloc (reloc_type
))
11834 else if (is_24bit_abs_reloc (reloc_type
))
11836 else if (is_16bit_abs_reloc (reloc_type
))
11840 static unsigned int prev_reloc
= 0;
11841 if (reloc_type
!= prev_reloc
)
11842 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11843 reloc_type
, printable_section_name (section
));
11844 prev_reloc
= reloc_type
;
11848 rloc
= start
+ rp
->r_offset
;
11849 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11851 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11852 (unsigned long) rp
->r_offset
,
11853 printable_section_name (section
));
11857 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11858 if (sym_index
>= num_syms
)
11860 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11861 sym_index
, printable_section_name (section
));
11864 sym
= symtab
+ sym_index
;
11866 /* If the reloc has a symbol associated with it,
11867 make sure that it is of an appropriate type.
11869 Relocations against symbols without type can happen.
11870 Gcc -feliminate-dwarf2-dups may generate symbols
11871 without type for debug info.
11873 Icc generates relocations against function symbols
11874 instead of local labels.
11876 Relocations against object symbols can happen, eg when
11877 referencing a global array. For an example of this see
11878 the _clz.o binary in libgcc.a. */
11880 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11882 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11883 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11884 (long int)(rp
- relocs
),
11885 printable_section_name (relsec
));
11891 addend
+= rp
->r_addend
;
11892 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11893 partial_inplace. */
11895 || (elf_header
.e_machine
== EM_XTENSA
11896 && reloc_type
== 1)
11897 || ((elf_header
.e_machine
== EM_PJ
11898 || elf_header
.e_machine
== EM_PJ_OLD
)
11899 && reloc_type
== 1)
11900 || ((elf_header
.e_machine
== EM_D30V
11901 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11902 && reloc_type
== 12))
11903 addend
+= byte_get (rloc
, reloc_size
);
11905 if (is_32bit_pcrel_reloc (reloc_type
)
11906 || is_64bit_pcrel_reloc (reloc_type
))
11908 /* On HPPA, all pc-relative relocations are biased by 8. */
11909 if (elf_header
.e_machine
== EM_PARISC
)
11911 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11915 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11922 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
11923 * num_relocs_return
= num_relocs
;
11932 #ifdef SUPPORT_DISASSEMBLY
11934 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11936 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11938 /* FIXME: XXX -- to be done --- XXX */
11944 /* Reads in the contents of SECTION from FILE, returning a pointer
11945 to a malloc'ed buffer or NULL if something went wrong. */
11948 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11950 bfd_size_type num_bytes
;
11952 num_bytes
= section
->sh_size
;
11954 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11956 printf (_("\nSection '%s' has no data to dump.\n"),
11957 printable_section_name (section
));
11961 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11962 _("section contents"));
11965 /* Uncompresses a section that was compressed using zlib, in place. */
11968 uncompress_section_contents (unsigned char **buffer
,
11969 dwarf_size_type uncompressed_size
,
11970 dwarf_size_type
*size
)
11972 dwarf_size_type compressed_size
= *size
;
11973 unsigned char * compressed_buffer
= *buffer
;
11974 unsigned char * uncompressed_buffer
;
11978 /* It is possible the section consists of several compressed
11979 buffers concatenated together, so we uncompress in a loop. */
11980 /* PR 18313: The state field in the z_stream structure is supposed
11981 to be invisible to the user (ie us), but some compilers will
11982 still complain about it being used without initialisation. So
11983 we first zero the entire z_stream structure and then set the fields
11985 memset (& strm
, 0, sizeof strm
);
11986 strm
.avail_in
= compressed_size
;
11987 strm
.next_in
= (Bytef
*) compressed_buffer
;
11988 strm
.avail_out
= uncompressed_size
;
11989 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11991 rc
= inflateInit (& strm
);
11992 while (strm
.avail_in
> 0)
11996 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11997 + (uncompressed_size
- strm
.avail_out
));
11998 rc
= inflate (&strm
, Z_FINISH
);
11999 if (rc
!= Z_STREAM_END
)
12001 rc
= inflateReset (& strm
);
12003 rc
= inflateEnd (& strm
);
12005 || strm
.avail_out
!= 0)
12008 *buffer
= uncompressed_buffer
;
12009 *size
= uncompressed_size
;
12013 free (uncompressed_buffer
);
12014 /* Indicate decompression failure. */
12020 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12022 Elf_Internal_Shdr
* relsec
;
12023 bfd_size_type num_bytes
;
12024 unsigned char * data
;
12025 unsigned char * end
;
12026 unsigned char * real_start
;
12027 unsigned char * start
;
12028 bfd_boolean some_strings_shown
;
12030 real_start
= start
= (unsigned char *) get_section_contents (section
,
12034 num_bytes
= section
->sh_size
;
12036 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12038 if (decompress_dumps
)
12040 dwarf_size_type new_size
= num_bytes
;
12041 dwarf_size_type uncompressed_size
= 0;
12043 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12045 Elf_Internal_Chdr chdr
;
12046 unsigned int compression_header_size
12047 = get_compression_header (& chdr
, (unsigned char *) start
);
12049 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12051 warn (_("section '%s' has unsupported compress type: %d\n"),
12052 printable_section_name (section
), chdr
.ch_type
);
12055 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12057 warn (_("compressed section '%s' is corrupted\n"),
12058 printable_section_name (section
));
12061 uncompressed_size
= chdr
.ch_size
;
12062 start
+= compression_header_size
;
12063 new_size
-= compression_header_size
;
12065 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12067 /* Read the zlib header. In this case, it should be "ZLIB"
12068 followed by the uncompressed section size, 8 bytes in
12069 big-endian order. */
12070 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12071 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12072 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12073 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12074 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12075 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12076 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12077 uncompressed_size
+= start
[11];
12082 if (uncompressed_size
12083 && uncompress_section_contents (& start
,
12084 uncompressed_size
, & new_size
))
12085 num_bytes
= new_size
;
12088 /* If the section being dumped has relocations against it the user might
12089 be expecting these relocations to have been applied. Check for this
12090 case and issue a warning message in order to avoid confusion.
12091 FIXME: Maybe we ought to have an option that dumps a section with
12092 relocs applied ? */
12093 for (relsec
= section_headers
;
12094 relsec
< section_headers
+ elf_header
.e_shnum
;
12097 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12098 || relsec
->sh_info
>= elf_header
.e_shnum
12099 || section_headers
+ relsec
->sh_info
!= section
12100 || relsec
->sh_size
== 0
12101 || relsec
->sh_link
>= elf_header
.e_shnum
)
12104 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12109 end
= start
+ num_bytes
;
12110 some_strings_shown
= FALSE
;
12114 while (!ISPRINT (* data
))
12115 if (++ data
>= end
)
12120 size_t maxlen
= end
- data
;
12123 /* PR 11128: Use two separate invocations in order to work
12124 around bugs in the Solaris 8 implementation of printf. */
12125 printf (" [%6tx] ", data
- start
);
12127 printf (" [%6Ix] ", (size_t) (data
- start
));
12131 print_symbol ((int) maxlen
, (const char *) data
);
12133 data
+= strnlen ((const char *) data
, maxlen
);
12137 printf (_("<corrupt>\n"));
12140 some_strings_shown
= TRUE
;
12144 if (! some_strings_shown
)
12145 printf (_(" No strings found in this section."));
12153 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12155 bfd_boolean relocate
)
12157 Elf_Internal_Shdr
* relsec
;
12158 bfd_size_type bytes
;
12159 bfd_size_type section_size
;
12161 unsigned char * data
;
12162 unsigned char * real_start
;
12163 unsigned char * start
;
12165 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12168 section_size
= section
->sh_size
;
12170 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12172 if (decompress_dumps
)
12174 dwarf_size_type new_size
= section_size
;
12175 dwarf_size_type uncompressed_size
= 0;
12177 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12179 Elf_Internal_Chdr chdr
;
12180 unsigned int compression_header_size
12181 = get_compression_header (& chdr
, start
);
12183 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12185 warn (_("section '%s' has unsupported compress type: %d\n"),
12186 printable_section_name (section
), chdr
.ch_type
);
12189 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12191 warn (_("compressed section '%s' is corrupted\n"),
12192 printable_section_name (section
));
12195 uncompressed_size
= chdr
.ch_size
;
12196 start
+= compression_header_size
;
12197 new_size
-= compression_header_size
;
12199 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12201 /* Read the zlib header. In this case, it should be "ZLIB"
12202 followed by the uncompressed section size, 8 bytes in
12203 big-endian order. */
12204 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12205 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12206 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12207 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12208 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12209 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12210 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12211 uncompressed_size
+= start
[11];
12216 if (uncompressed_size
12217 && uncompress_section_contents (& start
, uncompressed_size
,
12219 section_size
= new_size
;
12224 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12228 /* If the section being dumped has relocations against it the user might
12229 be expecting these relocations to have been applied. Check for this
12230 case and issue a warning message in order to avoid confusion.
12231 FIXME: Maybe we ought to have an option that dumps a section with
12232 relocs applied ? */
12233 for (relsec
= section_headers
;
12234 relsec
< section_headers
+ elf_header
.e_shnum
;
12237 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12238 || relsec
->sh_info
>= elf_header
.e_shnum
12239 || section_headers
+ relsec
->sh_info
!= section
12240 || relsec
->sh_size
== 0
12241 || relsec
->sh_link
>= elf_header
.e_shnum
)
12244 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12249 addr
= section
->sh_addr
;
12250 bytes
= section_size
;
12259 lbytes
= (bytes
> 16 ? 16 : bytes
);
12261 printf (" 0x%8.8lx ", (unsigned long) addr
);
12263 for (j
= 0; j
< 16; j
++)
12266 printf ("%2.2x", data
[j
]);
12274 for (j
= 0; j
< lbytes
; j
++)
12277 if (k
>= ' ' && k
< 0x7f)
12296 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12297 const Elf_Internal_Shdr
* sec
, void * file
)
12299 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12302 /* If it is already loaded, do nothing. */
12303 if (section
->start
!= NULL
)
12306 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12307 section
->address
= sec
->sh_addr
;
12308 section
->user_data
= NULL
;
12309 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12311 sec
->sh_size
, buf
);
12312 if (section
->start
== NULL
)
12316 unsigned char *start
= section
->start
;
12317 dwarf_size_type size
= sec
->sh_size
;
12318 dwarf_size_type uncompressed_size
= 0;
12320 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12322 Elf_Internal_Chdr chdr
;
12323 unsigned int compression_header_size
12324 = get_compression_header (&chdr
, start
);
12325 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12327 warn (_("section '%s' has unsupported compress type: %d\n"),
12328 section
->name
, chdr
.ch_type
);
12331 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12333 warn (_("compressed section '%s' is corrupted\n"),
12337 uncompressed_size
= chdr
.ch_size
;
12338 start
+= compression_header_size
;
12339 size
-= compression_header_size
;
12341 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12343 /* Read the zlib header. In this case, it should be "ZLIB"
12344 followed by the uncompressed section size, 8 bytes in
12345 big-endian order. */
12346 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12347 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12348 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12349 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12350 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12351 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12352 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12353 uncompressed_size
+= start
[11];
12358 if (uncompressed_size
12359 && uncompress_section_contents (&start
, uncompressed_size
,
12362 /* Free the compressed buffer, update the section buffer
12363 and the section size if uncompress is successful. */
12364 free (section
->start
);
12365 section
->start
= start
;
12367 section
->size
= size
;
12370 if (section
->start
== NULL
)
12373 if (debug_displays
[debug
].relocate
)
12374 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12375 & section
->reloc_info
, & section
->num_relocs
);
12378 section
->reloc_info
= NULL
;
12379 section
->num_relocs
= 0;
12385 /* If this is not NULL, load_debug_section will only look for sections
12386 within the list of sections given here. */
12387 unsigned int *section_subset
= NULL
;
12390 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12392 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12393 Elf_Internal_Shdr
* sec
;
12395 /* Locate the debug section. */
12396 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12398 section
->name
= section
->uncompressed_name
;
12401 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12403 section
->name
= section
->compressed_name
;
12408 /* If we're loading from a subset of sections, and we've loaded
12409 a section matching this name before, it's likely that it's a
12411 if (section_subset
!= NULL
)
12412 free_debug_section (debug
);
12414 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12418 free_debug_section (enum dwarf_section_display_enum debug
)
12420 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12422 if (section
->start
== NULL
)
12425 free ((char *) section
->start
);
12426 section
->start
= NULL
;
12427 section
->address
= 0;
12432 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12434 char * name
= SECTION_NAME (section
);
12435 const char * print_name
= printable_section_name (section
);
12436 bfd_size_type length
;
12440 length
= section
->sh_size
;
12443 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12446 if (section
->sh_type
== SHT_NOBITS
)
12448 /* There is no point in dumping the contents of a debugging section
12449 which has the NOBITS type - the bits in the file will be random.
12450 This can happen when a file containing a .eh_frame section is
12451 stripped with the --only-keep-debug command line option. */
12452 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12457 if (const_strneq (name
, ".gnu.linkonce.wi."))
12458 name
= ".debug_info";
12460 /* See if we know how to display the contents of this section. */
12461 for (i
= 0; i
< max
; i
++)
12462 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12463 || (i
== line
&& const_strneq (name
, ".debug_line."))
12464 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12466 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12467 int secondary
= (section
!= find_section (name
));
12470 free_debug_section ((enum dwarf_section_display_enum
) i
);
12472 if (i
== line
&& const_strneq (name
, ".debug_line."))
12474 else if (streq (sec
->uncompressed_name
, name
))
12475 sec
->name
= sec
->uncompressed_name
;
12477 sec
->name
= sec
->compressed_name
;
12478 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12481 /* If this debug section is part of a CU/TU set in a .dwp file,
12482 restrict load_debug_section to the sections in that set. */
12483 section_subset
= find_cu_tu_set (file
, shndx
);
12485 result
&= debug_displays
[i
].display (sec
, file
);
12487 section_subset
= NULL
;
12489 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12490 free_debug_section ((enum dwarf_section_display_enum
) i
);
12498 printf (_("Unrecognized debug section: %s\n"), print_name
);
12505 /* Set DUMP_SECTS for all sections where dumps were requested
12506 based on section name. */
12509 initialise_dumps_byname (void)
12511 struct dump_list_entry
* cur
;
12513 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12518 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12519 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12521 request_dump_bynumber (i
, cur
->type
);
12526 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12532 process_section_contents (FILE * file
)
12534 Elf_Internal_Shdr
* section
;
12540 initialise_dumps_byname ();
12542 for (i
= 0, section
= section_headers
;
12543 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12546 #ifdef SUPPORT_DISASSEMBLY
12547 if (dump_sects
[i
] & DISASS_DUMP
)
12548 disassemble_section (section
, file
);
12550 if (dump_sects
[i
] & HEX_DUMP
)
12551 dump_section_as_bytes (section
, file
, FALSE
);
12553 if (dump_sects
[i
] & RELOC_DUMP
)
12554 dump_section_as_bytes (section
, file
, TRUE
);
12556 if (dump_sects
[i
] & STRING_DUMP
)
12557 dump_section_as_strings (section
, file
);
12559 if (dump_sects
[i
] & DEBUG_DUMP
)
12560 display_debug_section (i
, section
, file
);
12563 /* Check to see if the user requested a
12564 dump of a section that does not exist. */
12565 while (i
++ < num_dump_sects
)
12567 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12571 process_mips_fpe_exception (int mask
)
12576 if (mask
& OEX_FPU_INEX
)
12577 fputs ("INEX", stdout
), first
= 0;
12578 if (mask
& OEX_FPU_UFLO
)
12579 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12580 if (mask
& OEX_FPU_OFLO
)
12581 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12582 if (mask
& OEX_FPU_DIV0
)
12583 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12584 if (mask
& OEX_FPU_INVAL
)
12585 printf ("%sINVAL", first
? "" : "|");
12588 fputs ("0", stdout
);
12591 /* Display's the value of TAG at location P. If TAG is
12592 greater than 0 it is assumed to be an unknown tag, and
12593 a message is printed to this effect. Otherwise it is
12594 assumed that a message has already been printed.
12596 If the bottom bit of TAG is set it assumed to have a
12597 string value, otherwise it is assumed to have an integer
12600 Returns an updated P pointing to the first unread byte
12601 beyond the end of TAG's value.
12603 Reads at or beyond END will not be made. */
12605 static unsigned char *
12606 display_tag_value (int tag
,
12608 const unsigned char * const end
)
12613 printf (" Tag_unknown_%d: ", tag
);
12617 warn (_("<corrupt tag>\n"));
12621 /* PR 17531 file: 027-19978-0.004. */
12622 size_t maxlen
= (end
- p
) - 1;
12627 print_symbol ((int) maxlen
, (const char *) p
);
12628 p
+= strnlen ((char *) p
, maxlen
) + 1;
12632 printf (_("<corrupt string tag>"));
12633 p
= (unsigned char *) end
;
12641 val
= read_uleb128 (p
, &len
, end
);
12643 printf ("%ld (0x%lx)\n", val
, val
);
12650 /* ARM EABI attributes section. */
12655 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12657 const char ** table
;
12658 } arm_attr_public_tag
;
12660 static const char * arm_attr_tag_CPU_arch
[] =
12661 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12662 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12663 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12664 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12665 {"No", "Thumb-1", "Thumb-2"};
12666 static const char * arm_attr_tag_FP_arch
[] =
12667 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12668 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12669 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12670 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12671 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12672 static const char * arm_attr_tag_PCS_config
[] =
12673 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12674 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12675 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12676 {"V6", "SB", "TLS", "Unused"};
12677 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12678 {"Absolute", "PC-relative", "SB-relative", "None"};
12679 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12680 {"Absolute", "PC-relative", "None"};
12681 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12682 {"None", "direct", "GOT-indirect"};
12683 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12684 {"None", "??? 1", "2", "??? 3", "4"};
12685 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12686 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12687 {"Unused", "Needed", "Sign only"};
12688 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12689 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12690 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12691 {"Unused", "Finite", "RTABI", "IEEE 754"};
12692 static const char * arm_attr_tag_ABI_enum_size
[] =
12693 {"Unused", "small", "int", "forced to int"};
12694 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12695 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12696 static const char * arm_attr_tag_ABI_VFP_args
[] =
12697 {"AAPCS", "VFP registers", "custom", "compatible"};
12698 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12699 {"AAPCS", "WMMX registers", "custom"};
12700 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12701 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12702 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12703 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12704 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12705 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12706 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12707 static const char * arm_attr_tag_FP_HP_extension
[] =
12708 {"Not Allowed", "Allowed"};
12709 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12710 {"None", "IEEE 754", "Alternative Format"};
12711 static const char * arm_attr_tag_MPextension_use
[] =
12712 {"Not Allowed", "Allowed"};
12713 static const char * arm_attr_tag_DIV_use
[] =
12714 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12715 "Allowed in v7-A with integer division extension"};
12716 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12717 static const char * arm_attr_tag_Virtualization_use
[] =
12718 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12719 "TrustZone and Virtualization Extensions"};
12720 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12721 {"Not Allowed", "Allowed"};
12723 #define LOOKUP(id, name) \
12724 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12725 static arm_attr_public_tag arm_attr_public_tags
[] =
12727 {4, "CPU_raw_name", 1, NULL
},
12728 {5, "CPU_name", 1, NULL
},
12729 LOOKUP(6, CPU_arch
),
12730 {7, "CPU_arch_profile", 0, NULL
},
12731 LOOKUP(8, ARM_ISA_use
),
12732 LOOKUP(9, THUMB_ISA_use
),
12733 LOOKUP(10, FP_arch
),
12734 LOOKUP(11, WMMX_arch
),
12735 LOOKUP(12, Advanced_SIMD_arch
),
12736 LOOKUP(13, PCS_config
),
12737 LOOKUP(14, ABI_PCS_R9_use
),
12738 LOOKUP(15, ABI_PCS_RW_data
),
12739 LOOKUP(16, ABI_PCS_RO_data
),
12740 LOOKUP(17, ABI_PCS_GOT_use
),
12741 LOOKUP(18, ABI_PCS_wchar_t
),
12742 LOOKUP(19, ABI_FP_rounding
),
12743 LOOKUP(20, ABI_FP_denormal
),
12744 LOOKUP(21, ABI_FP_exceptions
),
12745 LOOKUP(22, ABI_FP_user_exceptions
),
12746 LOOKUP(23, ABI_FP_number_model
),
12747 {24, "ABI_align_needed", 0, NULL
},
12748 {25, "ABI_align_preserved", 0, NULL
},
12749 LOOKUP(26, ABI_enum_size
),
12750 LOOKUP(27, ABI_HardFP_use
),
12751 LOOKUP(28, ABI_VFP_args
),
12752 LOOKUP(29, ABI_WMMX_args
),
12753 LOOKUP(30, ABI_optimization_goals
),
12754 LOOKUP(31, ABI_FP_optimization_goals
),
12755 {32, "compatibility", 0, NULL
},
12756 LOOKUP(34, CPU_unaligned_access
),
12757 LOOKUP(36, FP_HP_extension
),
12758 LOOKUP(38, ABI_FP_16bit_format
),
12759 LOOKUP(42, MPextension_use
),
12760 LOOKUP(44, DIV_use
),
12761 {64, "nodefaults", 0, NULL
},
12762 {65, "also_compatible_with", 0, NULL
},
12763 LOOKUP(66, T2EE_use
),
12764 {67, "conformance", 1, NULL
},
12765 LOOKUP(68, Virtualization_use
),
12766 LOOKUP(70, MPextension_use_legacy
)
12770 static unsigned char *
12771 display_arm_attribute (unsigned char * p
,
12772 const unsigned char * const end
)
12777 arm_attr_public_tag
* attr
;
12781 tag
= read_uleb128 (p
, &len
, end
);
12784 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12786 if (arm_attr_public_tags
[i
].tag
== tag
)
12788 attr
= &arm_attr_public_tags
[i
];
12795 printf (" Tag_%s: ", attr
->name
);
12796 switch (attr
->type
)
12801 case 7: /* Tag_CPU_arch_profile. */
12802 val
= read_uleb128 (p
, &len
, end
);
12806 case 0: printf (_("None\n")); break;
12807 case 'A': printf (_("Application\n")); break;
12808 case 'R': printf (_("Realtime\n")); break;
12809 case 'M': printf (_("Microcontroller\n")); break;
12810 case 'S': printf (_("Application or Realtime\n")); break;
12811 default: printf ("??? (%d)\n", val
); break;
12815 case 24: /* Tag_align_needed. */
12816 val
= read_uleb128 (p
, &len
, end
);
12820 case 0: printf (_("None\n")); break;
12821 case 1: printf (_("8-byte\n")); break;
12822 case 2: printf (_("4-byte\n")); break;
12823 case 3: printf ("??? 3\n"); break;
12826 printf (_("8-byte and up to %d-byte extended\n"),
12829 printf ("??? (%d)\n", val
);
12834 case 25: /* Tag_align_preserved. */
12835 val
= read_uleb128 (p
, &len
, end
);
12839 case 0: printf (_("None\n")); break;
12840 case 1: printf (_("8-byte, except leaf SP\n")); break;
12841 case 2: printf (_("8-byte\n")); break;
12842 case 3: printf ("??? 3\n"); break;
12845 printf (_("8-byte and up to %d-byte extended\n"),
12848 printf ("??? (%d)\n", val
);
12853 case 32: /* Tag_compatibility. */
12855 val
= read_uleb128 (p
, &len
, end
);
12857 printf (_("flag = %d, vendor = "), val
);
12860 size_t maxlen
= (end
- p
) - 1;
12862 print_symbol ((int) maxlen
, (const char *) p
);
12863 p
+= strnlen ((char *) p
, maxlen
) + 1;
12867 printf (_("<corrupt>"));
12868 p
= (unsigned char *) end
;
12874 case 64: /* Tag_nodefaults. */
12875 /* PR 17531: file: 001-505008-0.01. */
12878 printf (_("True\n"));
12881 case 65: /* Tag_also_compatible_with. */
12882 val
= read_uleb128 (p
, &len
, end
);
12884 if (val
== 6 /* Tag_CPU_arch. */)
12886 val
= read_uleb128 (p
, &len
, end
);
12888 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12889 printf ("??? (%d)\n", val
);
12891 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12895 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12900 printf (_("<unknown: %d>\n"), tag
);
12906 return display_tag_value (-1, p
, end
);
12908 return display_tag_value (0, p
, end
);
12911 assert (attr
->type
& 0x80);
12912 val
= read_uleb128 (p
, &len
, end
);
12914 type
= attr
->type
& 0x7f;
12916 printf ("??? (%d)\n", val
);
12918 printf ("%s\n", attr
->table
[val
]);
12923 return display_tag_value (tag
, p
, end
);
12926 static unsigned char *
12927 display_gnu_attribute (unsigned char * p
,
12928 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12929 const unsigned char * const end
)
12935 tag
= read_uleb128 (p
, &len
, end
);
12938 /* Tag_compatibility is the only generic GNU attribute defined at
12942 val
= read_uleb128 (p
, &len
, end
);
12945 printf (_("flag = %d, vendor = "), val
);
12948 printf (_("<corrupt>\n"));
12949 warn (_("corrupt vendor attribute\n"));
12955 size_t maxlen
= (end
- p
) - 1;
12957 print_symbol ((int) maxlen
, (const char *) p
);
12958 p
+= strnlen ((char *) p
, maxlen
) + 1;
12962 printf (_("<corrupt>"));
12963 p
= (unsigned char *) end
;
12970 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12971 return display_proc_gnu_attribute (p
, tag
, end
);
12973 return display_tag_value (tag
, p
, end
);
12976 static unsigned char *
12977 display_power_gnu_attribute (unsigned char * p
,
12979 const unsigned char * const end
)
12984 if (tag
== Tag_GNU_Power_ABI_FP
)
12986 val
= read_uleb128 (p
, &len
, end
);
12988 printf (" Tag_GNU_Power_ABI_FP: ");
12993 printf (_("Hard or soft float\n"));
12996 printf (_("Hard float\n"));
12999 printf (_("Soft float\n"));
13002 printf (_("Single-precision hard float\n"));
13005 printf ("??? (%d)\n", val
);
13011 if (tag
== Tag_GNU_Power_ABI_Vector
)
13013 val
= read_uleb128 (p
, &len
, end
);
13015 printf (" Tag_GNU_Power_ABI_Vector: ");
13019 printf (_("Any\n"));
13022 printf (_("Generic\n"));
13025 printf ("AltiVec\n");
13031 printf ("??? (%d)\n", val
);
13037 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13041 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13045 val
= read_uleb128 (p
, &len
, end
);
13047 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13051 printf (_("Any\n"));
13054 printf ("r3/r4\n");
13057 printf (_("Memory\n"));
13060 printf ("??? (%d)\n", val
);
13066 return display_tag_value (tag
& 1, p
, end
);
13069 static unsigned char *
13070 display_s390_gnu_attribute (unsigned char * p
,
13072 const unsigned char * const end
)
13077 if (tag
== Tag_GNU_S390_ABI_Vector
)
13079 val
= read_uleb128 (p
, &len
, end
);
13081 printf (" Tag_GNU_S390_ABI_Vector: ");
13086 printf (_("any\n"));
13089 printf (_("software\n"));
13092 printf (_("hardware\n"));
13095 printf ("??? (%d)\n", val
);
13101 return display_tag_value (tag
& 1, p
, end
);
13105 display_sparc_hwcaps (int mask
)
13111 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13112 fputs ("mul32", stdout
), first
= 0;
13113 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13114 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13115 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13116 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13117 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13118 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13119 if (mask
& ELF_SPARC_HWCAP_POPC
)
13120 printf ("%spopc", first
? "" : "|"), first
= 0;
13121 if (mask
& ELF_SPARC_HWCAP_VIS
)
13122 printf ("%svis", first
? "" : "|"), first
= 0;
13123 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13124 printf ("%svis2", first
? "" : "|"), first
= 0;
13125 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13126 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13127 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13128 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13129 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13130 printf ("%svis3", first
? "" : "|"), first
= 0;
13131 if (mask
& ELF_SPARC_HWCAP_HPC
)
13132 printf ("%shpc", first
? "" : "|"), first
= 0;
13133 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13134 printf ("%srandom", first
? "" : "|"), first
= 0;
13135 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13136 printf ("%strans", first
? "" : "|"), first
= 0;
13137 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13138 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13139 if (mask
& ELF_SPARC_HWCAP_IMA
)
13140 printf ("%sima", first
? "" : "|"), first
= 0;
13141 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13142 printf ("%scspare", first
? "" : "|"), first
= 0;
13145 fputc ('0', stdout
);
13146 fputc ('\n', stdout
);
13150 display_sparc_hwcaps2 (int mask
)
13156 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13157 fputs ("fjathplus", stdout
), first
= 0;
13158 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13159 printf ("%svis3b", first
? "" : "|"), first
= 0;
13160 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13161 printf ("%sadp", first
? "" : "|"), first
= 0;
13162 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13163 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13164 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13165 printf ("%smwait", first
? "" : "|"), first
= 0;
13166 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13167 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13168 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13169 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13170 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13171 printf ("%snsec", first
? "" : "|"), first
= 0;
13172 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13173 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13174 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13175 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13176 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13177 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13180 fputc ('0', stdout
);
13181 fputc ('\n', stdout
);
13184 static unsigned char *
13185 display_sparc_gnu_attribute (unsigned char * p
,
13187 const unsigned char * const end
)
13192 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13194 val
= read_uleb128 (p
, &len
, end
);
13196 printf (" Tag_GNU_Sparc_HWCAPS: ");
13197 display_sparc_hwcaps (val
);
13200 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13202 val
= read_uleb128 (p
, &len
, end
);
13204 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13205 display_sparc_hwcaps2 (val
);
13209 return display_tag_value (tag
, p
, end
);
13213 print_mips_fp_abi_value (int val
)
13217 case Val_GNU_MIPS_ABI_FP_ANY
:
13218 printf (_("Hard or soft float\n"));
13220 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13221 printf (_("Hard float (double precision)\n"));
13223 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13224 printf (_("Hard float (single precision)\n"));
13226 case Val_GNU_MIPS_ABI_FP_SOFT
:
13227 printf (_("Soft float\n"));
13229 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13230 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13232 case Val_GNU_MIPS_ABI_FP_XX
:
13233 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13235 case Val_GNU_MIPS_ABI_FP_64
:
13236 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13238 case Val_GNU_MIPS_ABI_FP_64A
:
13239 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13241 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13242 printf (_("NaN 2008 compatibility\n"));
13245 printf ("??? (%d)\n", val
);
13250 static unsigned char *
13251 display_mips_gnu_attribute (unsigned char * p
,
13253 const unsigned char * const end
)
13255 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13260 val
= read_uleb128 (p
, &len
, end
);
13262 printf (" Tag_GNU_MIPS_ABI_FP: ");
13264 print_mips_fp_abi_value (val
);
13269 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13274 val
= read_uleb128 (p
, &len
, end
);
13276 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13280 case Val_GNU_MIPS_ABI_MSA_ANY
:
13281 printf (_("Any MSA or not\n"));
13283 case Val_GNU_MIPS_ABI_MSA_128
:
13284 printf (_("128-bit MSA\n"));
13287 printf ("??? (%d)\n", val
);
13293 return display_tag_value (tag
& 1, p
, end
);
13296 static unsigned char *
13297 display_tic6x_attribute (unsigned char * p
,
13298 const unsigned char * const end
)
13304 tag
= read_uleb128 (p
, &len
, end
);
13310 val
= read_uleb128 (p
, &len
, end
);
13312 printf (" Tag_ISA: ");
13316 case C6XABI_Tag_ISA_none
:
13317 printf (_("None\n"));
13319 case C6XABI_Tag_ISA_C62X
:
13322 case C6XABI_Tag_ISA_C67X
:
13325 case C6XABI_Tag_ISA_C67XP
:
13326 printf ("C67x+\n");
13328 case C6XABI_Tag_ISA_C64X
:
13331 case C6XABI_Tag_ISA_C64XP
:
13332 printf ("C64x+\n");
13334 case C6XABI_Tag_ISA_C674X
:
13335 printf ("C674x\n");
13338 printf ("??? (%d)\n", val
);
13343 case Tag_ABI_wchar_t
:
13344 val
= read_uleb128 (p
, &len
, end
);
13346 printf (" Tag_ABI_wchar_t: ");
13350 printf (_("Not used\n"));
13353 printf (_("2 bytes\n"));
13356 printf (_("4 bytes\n"));
13359 printf ("??? (%d)\n", val
);
13364 case Tag_ABI_stack_align_needed
:
13365 val
= read_uleb128 (p
, &len
, end
);
13367 printf (" Tag_ABI_stack_align_needed: ");
13371 printf (_("8-byte\n"));
13374 printf (_("16-byte\n"));
13377 printf ("??? (%d)\n", val
);
13382 case Tag_ABI_stack_align_preserved
:
13383 val
= read_uleb128 (p
, &len
, end
);
13385 printf (" Tag_ABI_stack_align_preserved: ");
13389 printf (_("8-byte\n"));
13392 printf (_("16-byte\n"));
13395 printf ("??? (%d)\n", val
);
13401 val
= read_uleb128 (p
, &len
, end
);
13403 printf (" Tag_ABI_DSBT: ");
13407 printf (_("DSBT addressing not used\n"));
13410 printf (_("DSBT addressing used\n"));
13413 printf ("??? (%d)\n", val
);
13419 val
= read_uleb128 (p
, &len
, end
);
13421 printf (" Tag_ABI_PID: ");
13425 printf (_("Data addressing position-dependent\n"));
13428 printf (_("Data addressing position-independent, GOT near DP\n"));
13431 printf (_("Data addressing position-independent, GOT far from DP\n"));
13434 printf ("??? (%d)\n", val
);
13440 val
= read_uleb128 (p
, &len
, end
);
13442 printf (" Tag_ABI_PIC: ");
13446 printf (_("Code addressing position-dependent\n"));
13449 printf (_("Code addressing position-independent\n"));
13452 printf ("??? (%d)\n", val
);
13457 case Tag_ABI_array_object_alignment
:
13458 val
= read_uleb128 (p
, &len
, end
);
13460 printf (" Tag_ABI_array_object_alignment: ");
13464 printf (_("8-byte\n"));
13467 printf (_("4-byte\n"));
13470 printf (_("16-byte\n"));
13473 printf ("??? (%d)\n", val
);
13478 case Tag_ABI_array_object_align_expected
:
13479 val
= read_uleb128 (p
, &len
, end
);
13481 printf (" Tag_ABI_array_object_align_expected: ");
13485 printf (_("8-byte\n"));
13488 printf (_("4-byte\n"));
13491 printf (_("16-byte\n"));
13494 printf ("??? (%d)\n", val
);
13499 case Tag_ABI_compatibility
:
13501 val
= read_uleb128 (p
, &len
, end
);
13503 printf (" Tag_ABI_compatibility: ");
13504 printf (_("flag = %d, vendor = "), val
);
13507 size_t maxlen
= (end
- p
) - 1;
13509 print_symbol ((int) maxlen
, (const char *) p
);
13510 p
+= strnlen ((char *) p
, maxlen
) + 1;
13514 printf (_("<corrupt>"));
13515 p
= (unsigned char *) end
;
13521 case Tag_ABI_conformance
:
13523 printf (" Tag_ABI_conformance: \"");
13526 size_t maxlen
= (end
- p
) - 1;
13528 print_symbol ((int) maxlen
, (const char *) p
);
13529 p
+= strnlen ((char *) p
, maxlen
) + 1;
13533 printf (_("<corrupt>"));
13534 p
= (unsigned char *) end
;
13541 return display_tag_value (tag
, p
, end
);
13545 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13547 unsigned long addr
= 0;
13548 size_t bytes
= end
- p
;
13555 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13557 printf (" 0x%8.8lx ", addr
);
13559 for (j
= 0; j
< 16; j
++)
13562 printf ("%2.2x", p
[j
]);
13570 for (j
= 0; j
< lbytes
; j
++)
13573 if (k
>= ' ' && k
< 0x7f)
13589 static unsigned char *
13590 display_msp430x_attribute (unsigned char * p
,
13591 const unsigned char * const end
)
13597 tag
= read_uleb128 (p
, & len
, end
);
13602 case OFBA_MSPABI_Tag_ISA
:
13603 val
= read_uleb128 (p
, &len
, end
);
13605 printf (" Tag_ISA: ");
13608 case 0: printf (_("None\n")); break;
13609 case 1: printf (_("MSP430\n")); break;
13610 case 2: printf (_("MSP430X\n")); break;
13611 default: printf ("??? (%d)\n", val
); break;
13615 case OFBA_MSPABI_Tag_Code_Model
:
13616 val
= read_uleb128 (p
, &len
, end
);
13618 printf (" Tag_Code_Model: ");
13621 case 0: printf (_("None\n")); break;
13622 case 1: printf (_("Small\n")); break;
13623 case 2: printf (_("Large\n")); break;
13624 default: printf ("??? (%d)\n", val
); break;
13628 case OFBA_MSPABI_Tag_Data_Model
:
13629 val
= read_uleb128 (p
, &len
, end
);
13631 printf (" Tag_Data_Model: ");
13634 case 0: printf (_("None\n")); break;
13635 case 1: printf (_("Small\n")); break;
13636 case 2: printf (_("Large\n")); break;
13637 case 3: printf (_("Restricted Large\n")); break;
13638 default: printf ("??? (%d)\n", val
); break;
13643 printf (_(" <unknown tag %d>: "), tag
);
13650 size_t maxlen
= (end
- p
) - 1;
13652 print_symbol ((int) maxlen
, (const char *) p
);
13653 p
+= strnlen ((char *) p
, maxlen
) + 1;
13657 printf (_("<corrupt>"));
13658 p
= (unsigned char *) end
;
13664 val
= read_uleb128 (p
, &len
, end
);
13666 printf ("%d (0x%x)\n", val
, val
);
13676 process_attributes (FILE * file
,
13677 const char * public_name
,
13678 unsigned int proc_type
,
13679 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13680 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13682 Elf_Internal_Shdr
* sect
;
13685 /* Find the section header so that we get the size. */
13686 for (i
= 0, sect
= section_headers
;
13687 i
< elf_header
.e_shnum
;
13690 unsigned char * contents
;
13693 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13696 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13697 sect
->sh_size
, _("attributes"));
13698 if (contents
== NULL
)
13704 bfd_vma section_len
;
13706 section_len
= sect
->sh_size
- 1;
13709 while (section_len
> 0)
13712 unsigned int namelen
;
13713 bfd_boolean public_section
;
13714 bfd_boolean gnu_section
;
13716 if (section_len
<= 4)
13718 error (_("Tag section ends prematurely\n"));
13721 attr_len
= byte_get (p
, 4);
13724 if (attr_len
> section_len
)
13726 error (_("Bad attribute length (%u > %u)\n"),
13727 (unsigned) attr_len
, (unsigned) section_len
);
13728 attr_len
= section_len
;
13730 /* PR 17531: file: 001-101425-0.004 */
13731 else if (attr_len
< 5)
13733 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13737 section_len
-= attr_len
;
13740 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13741 if (namelen
== 0 || namelen
>= attr_len
)
13743 error (_("Corrupt attribute section name\n"));
13747 printf (_("Attribute Section: "));
13748 print_symbol (INT_MAX
, (const char *) p
);
13751 if (public_name
&& streq ((char *) p
, public_name
))
13752 public_section
= TRUE
;
13754 public_section
= FALSE
;
13756 if (streq ((char *) p
, "gnu"))
13757 gnu_section
= TRUE
;
13759 gnu_section
= FALSE
;
13762 attr_len
-= namelen
;
13764 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13769 unsigned char * end
;
13771 /* PR binutils/17531: Safe handling of corrupt files. */
13774 error (_("Unused bytes at end of section\n"));
13780 size
= byte_get (p
, 4);
13781 if (size
> attr_len
)
13783 error (_("Bad subsection length (%u > %u)\n"),
13784 (unsigned) size
, (unsigned) attr_len
);
13787 /* PR binutils/17531: Safe handling of corrupt files. */
13790 error (_("Bad subsection length (%u < 6)\n"),
13797 end
= p
+ size
- 1;
13798 assert (end
<= contents
+ sect
->sh_size
);
13804 printf (_("File Attributes\n"));
13807 printf (_("Section Attributes:"));
13810 printf (_("Symbol Attributes:"));
13816 val
= read_uleb128 (p
, &j
, end
);
13820 printf (" %d", val
);
13825 printf (_("Unknown tag: %d\n"), tag
);
13826 public_section
= FALSE
;
13830 if (public_section
&& display_pub_attribute
!= NULL
)
13833 p
= display_pub_attribute (p
, end
);
13836 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13839 p
= display_gnu_attribute (p
,
13840 display_proc_gnu_attribute
,
13846 printf (_(" Unknown attribute:\n"));
13847 display_raw_attribute (p
, end
);
13856 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13864 process_arm_specific (FILE * file
)
13866 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13867 display_arm_attribute
, NULL
);
13871 process_power_specific (FILE * file
)
13873 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13874 display_power_gnu_attribute
);
13878 process_s390_specific (FILE * file
)
13880 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13881 display_s390_gnu_attribute
);
13885 process_sparc_specific (FILE * file
)
13887 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13888 display_sparc_gnu_attribute
);
13892 process_tic6x_specific (FILE * file
)
13894 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13895 display_tic6x_attribute
, NULL
);
13899 process_msp430x_specific (FILE * file
)
13901 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13902 display_msp430x_attribute
, NULL
);
13905 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13906 Print the Address, Access and Initial fields of an entry at VMA ADDR
13907 and return the VMA of the next entry, or -1 if there was a problem.
13908 Does not read from DATA_END or beyond. */
13911 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13912 unsigned char * data_end
)
13915 print_vma (addr
, LONG_HEX
);
13917 if (addr
< pltgot
+ 0xfff0)
13918 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13920 printf ("%10s", "");
13923 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13927 unsigned char * from
= data
+ addr
- pltgot
;
13929 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13931 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13932 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13933 return (bfd_vma
) -1;
13937 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13938 print_vma (entry
, LONG_HEX
);
13941 return addr
+ (is_32bit_elf
? 4 : 8);
13944 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13945 PLTGOT. Print the Address and Initial fields of an entry at VMA
13946 ADDR and return the VMA of the next entry. */
13949 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13952 print_vma (addr
, LONG_HEX
);
13955 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13960 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13961 print_vma (entry
, LONG_HEX
);
13963 return addr
+ (is_32bit_elf
? 4 : 8);
13967 print_mips_ases (unsigned int mask
)
13969 if (mask
& AFL_ASE_DSP
)
13970 fputs ("\n\tDSP ASE", stdout
);
13971 if (mask
& AFL_ASE_DSPR2
)
13972 fputs ("\n\tDSP R2 ASE", stdout
);
13973 if (mask
& AFL_ASE_EVA
)
13974 fputs ("\n\tEnhanced VA Scheme", stdout
);
13975 if (mask
& AFL_ASE_MCU
)
13976 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13977 if (mask
& AFL_ASE_MDMX
)
13978 fputs ("\n\tMDMX ASE", stdout
);
13979 if (mask
& AFL_ASE_MIPS3D
)
13980 fputs ("\n\tMIPS-3D ASE", stdout
);
13981 if (mask
& AFL_ASE_MT
)
13982 fputs ("\n\tMT ASE", stdout
);
13983 if (mask
& AFL_ASE_SMARTMIPS
)
13984 fputs ("\n\tSmartMIPS ASE", stdout
);
13985 if (mask
& AFL_ASE_VIRT
)
13986 fputs ("\n\tVZ ASE", stdout
);
13987 if (mask
& AFL_ASE_MSA
)
13988 fputs ("\n\tMSA ASE", stdout
);
13989 if (mask
& AFL_ASE_MIPS16
)
13990 fputs ("\n\tMIPS16 ASE", stdout
);
13991 if (mask
& AFL_ASE_MICROMIPS
)
13992 fputs ("\n\tMICROMIPS ASE", stdout
);
13993 if (mask
& AFL_ASE_XPA
)
13994 fputs ("\n\tXPA ASE", stdout
);
13996 fprintf (stdout
, "\n\t%s", _("None"));
13997 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13998 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14002 print_mips_isa_ext (unsigned int isa_ext
)
14007 fputs (_("None"), stdout
);
14010 fputs ("RMI XLR", stdout
);
14012 case AFL_EXT_OCTEON3
:
14013 fputs ("Cavium Networks Octeon3", stdout
);
14015 case AFL_EXT_OCTEON2
:
14016 fputs ("Cavium Networks Octeon2", stdout
);
14018 case AFL_EXT_OCTEONP
:
14019 fputs ("Cavium Networks OcteonP", stdout
);
14021 case AFL_EXT_LOONGSON_3A
:
14022 fputs ("Loongson 3A", stdout
);
14024 case AFL_EXT_OCTEON
:
14025 fputs ("Cavium Networks Octeon", stdout
);
14028 fputs ("Toshiba R5900", stdout
);
14031 fputs ("MIPS R4650", stdout
);
14034 fputs ("LSI R4010", stdout
);
14037 fputs ("NEC VR4100", stdout
);
14040 fputs ("Toshiba R3900", stdout
);
14042 case AFL_EXT_10000
:
14043 fputs ("MIPS R10000", stdout
);
14046 fputs ("Broadcom SB-1", stdout
);
14049 fputs ("NEC VR4111/VR4181", stdout
);
14052 fputs ("NEC VR4120", stdout
);
14055 fputs ("NEC VR5400", stdout
);
14058 fputs ("NEC VR5500", stdout
);
14060 case AFL_EXT_LOONGSON_2E
:
14061 fputs ("ST Microelectronics Loongson 2E", stdout
);
14063 case AFL_EXT_LOONGSON_2F
:
14064 fputs ("ST Microelectronics Loongson 2F", stdout
);
14067 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14072 get_mips_reg_size (int reg_size
)
14074 return (reg_size
== AFL_REG_NONE
) ? 0
14075 : (reg_size
== AFL_REG_32
) ? 32
14076 : (reg_size
== AFL_REG_64
) ? 64
14077 : (reg_size
== AFL_REG_128
) ? 128
14082 process_mips_specific (FILE * file
)
14084 Elf_Internal_Dyn
* entry
;
14085 Elf_Internal_Shdr
*sect
= NULL
;
14086 size_t liblist_offset
= 0;
14087 size_t liblistno
= 0;
14088 size_t conflictsno
= 0;
14089 size_t options_offset
= 0;
14090 size_t conflicts_offset
= 0;
14091 size_t pltrelsz
= 0;
14093 bfd_vma pltgot
= 0;
14094 bfd_vma mips_pltgot
= 0;
14095 bfd_vma jmprel
= 0;
14096 bfd_vma local_gotno
= 0;
14097 bfd_vma gotsym
= 0;
14098 bfd_vma symtabno
= 0;
14100 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14101 display_mips_gnu_attribute
);
14103 sect
= find_section (".MIPS.abiflags");
14107 Elf_External_ABIFlags_v0
*abiflags_ext
;
14108 Elf_Internal_ABIFlags_v0 abiflags_in
;
14110 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14111 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14114 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14115 sect
->sh_size
, _("MIPS ABI Flags section"));
14118 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14119 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14120 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14121 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14122 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14123 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14124 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14125 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14126 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14127 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14128 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14130 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14131 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14132 if (abiflags_in
.isa_rev
> 1)
14133 printf ("r%d", abiflags_in
.isa_rev
);
14134 printf ("\nGPR size: %d",
14135 get_mips_reg_size (abiflags_in
.gpr_size
));
14136 printf ("\nCPR1 size: %d",
14137 get_mips_reg_size (abiflags_in
.cpr1_size
));
14138 printf ("\nCPR2 size: %d",
14139 get_mips_reg_size (abiflags_in
.cpr2_size
));
14140 fputs ("\nFP ABI: ", stdout
);
14141 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14142 fputs ("ISA Extension: ", stdout
);
14143 print_mips_isa_ext (abiflags_in
.isa_ext
);
14144 fputs ("\nASEs:", stdout
);
14145 print_mips_ases (abiflags_in
.ases
);
14146 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14147 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14148 fputc ('\n', stdout
);
14149 free (abiflags_ext
);
14154 /* We have a lot of special sections. Thanks SGI! */
14155 if (dynamic_section
== NULL
)
14156 /* No information available. */
14159 for (entry
= dynamic_section
;
14160 /* PR 17531 file: 012-50589-0.004. */
14161 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14163 switch (entry
->d_tag
)
14165 case DT_MIPS_LIBLIST
:
14167 = offset_from_vma (file
, entry
->d_un
.d_val
,
14168 liblistno
* sizeof (Elf32_External_Lib
));
14170 case DT_MIPS_LIBLISTNO
:
14171 liblistno
= entry
->d_un
.d_val
;
14173 case DT_MIPS_OPTIONS
:
14174 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14176 case DT_MIPS_CONFLICT
:
14178 = offset_from_vma (file
, entry
->d_un
.d_val
,
14179 conflictsno
* sizeof (Elf32_External_Conflict
));
14181 case DT_MIPS_CONFLICTNO
:
14182 conflictsno
= entry
->d_un
.d_val
;
14185 pltgot
= entry
->d_un
.d_ptr
;
14187 case DT_MIPS_LOCAL_GOTNO
:
14188 local_gotno
= entry
->d_un
.d_val
;
14190 case DT_MIPS_GOTSYM
:
14191 gotsym
= entry
->d_un
.d_val
;
14193 case DT_MIPS_SYMTABNO
:
14194 symtabno
= entry
->d_un
.d_val
;
14196 case DT_MIPS_PLTGOT
:
14197 mips_pltgot
= entry
->d_un
.d_ptr
;
14200 pltrel
= entry
->d_un
.d_val
;
14203 pltrelsz
= entry
->d_un
.d_val
;
14206 jmprel
= entry
->d_un
.d_ptr
;
14212 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14214 Elf32_External_Lib
* elib
;
14217 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14219 sizeof (Elf32_External_Lib
),
14220 _("liblist section data"));
14223 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14224 (unsigned long) liblistno
);
14225 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14228 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14235 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14236 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14237 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14238 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14239 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14241 tmp
= gmtime (&atime
);
14242 snprintf (timebuf
, sizeof (timebuf
),
14243 "%04u-%02u-%02uT%02u:%02u:%02u",
14244 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14245 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14247 printf ("%3lu: ", (unsigned long) cnt
);
14248 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14249 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14251 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14252 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14253 liblist
.l_version
);
14255 if (liblist
.l_flags
== 0)
14259 static const struct
14266 { " EXACT_MATCH", LL_EXACT_MATCH
},
14267 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14268 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14269 { " EXPORTS", LL_EXPORTS
},
14270 { " DELAY_LOAD", LL_DELAY_LOAD
},
14271 { " DELTA", LL_DELTA
}
14273 int flags
= liblist
.l_flags
;
14276 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14277 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14279 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14280 flags
^= l_flags_vals
[fcnt
].bit
;
14283 printf (" %#x", (unsigned int) flags
);
14293 if (options_offset
!= 0)
14295 Elf_External_Options
* eopt
;
14296 Elf_Internal_Options
* iopt
;
14297 Elf_Internal_Options
* option
;
14300 sect
= section_headers
;
14302 /* Find the section header so that we get the size. */
14303 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14304 /* PR 17533 file: 012-277276-0.004. */
14307 error (_("No MIPS_OPTIONS header found\n"));
14311 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14312 sect
->sh_size
, _("options"));
14315 iopt
= (Elf_Internal_Options
*)
14316 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14319 error (_("Out of memory allocatinf space for MIPS options\n"));
14326 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14328 Elf_External_Options
* eoption
;
14330 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14332 option
->kind
= BYTE_GET (eoption
->kind
);
14333 option
->size
= BYTE_GET (eoption
->size
);
14334 option
->section
= BYTE_GET (eoption
->section
);
14335 option
->info
= BYTE_GET (eoption
->info
);
14337 /* PR 17531: file: ffa0fa3b. */
14338 if (option
->size
< sizeof (* eopt
)
14339 || offset
+ option
->size
> sect
->sh_size
)
14341 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14344 offset
+= option
->size
;
14350 printf (_("\nSection '%s' contains %d entries:\n"),
14351 printable_section_name (sect
), cnt
);
14360 switch (option
->kind
)
14363 /* This shouldn't happen. */
14364 printf (" NULL %d %lx", option
->section
, option
->info
);
14367 printf (" REGINFO ");
14368 if (elf_header
.e_machine
== EM_MIPS
)
14371 Elf32_External_RegInfo
* ereg
;
14372 Elf32_RegInfo reginfo
;
14374 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14375 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14376 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14377 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14378 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14379 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14380 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14382 printf ("GPR %08lx GP 0x%lx\n",
14383 reginfo
.ri_gprmask
,
14384 (unsigned long) reginfo
.ri_gp_value
);
14385 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14386 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14387 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14392 Elf64_External_RegInfo
* ereg
;
14393 Elf64_Internal_RegInfo reginfo
;
14395 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14396 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14397 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14398 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14399 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14400 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14401 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14403 printf ("GPR %08lx GP 0x",
14404 reginfo
.ri_gprmask
);
14405 printf_vma (reginfo
.ri_gp_value
);
14408 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14409 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14410 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14414 case ODK_EXCEPTIONS
:
14415 fputs (" EXCEPTIONS fpe_min(", stdout
);
14416 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14417 fputs (") fpe_max(", stdout
);
14418 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14419 fputs (")", stdout
);
14421 if (option
->info
& OEX_PAGE0
)
14422 fputs (" PAGE0", stdout
);
14423 if (option
->info
& OEX_SMM
)
14424 fputs (" SMM", stdout
);
14425 if (option
->info
& OEX_FPDBUG
)
14426 fputs (" FPDBUG", stdout
);
14427 if (option
->info
& OEX_DISMISS
)
14428 fputs (" DISMISS", stdout
);
14431 fputs (" PAD ", stdout
);
14432 if (option
->info
& OPAD_PREFIX
)
14433 fputs (" PREFIX", stdout
);
14434 if (option
->info
& OPAD_POSTFIX
)
14435 fputs (" POSTFIX", stdout
);
14436 if (option
->info
& OPAD_SYMBOL
)
14437 fputs (" SYMBOL", stdout
);
14440 fputs (" HWPATCH ", stdout
);
14441 if (option
->info
& OHW_R4KEOP
)
14442 fputs (" R4KEOP", stdout
);
14443 if (option
->info
& OHW_R8KPFETCH
)
14444 fputs (" R8KPFETCH", stdout
);
14445 if (option
->info
& OHW_R5KEOP
)
14446 fputs (" R5KEOP", stdout
);
14447 if (option
->info
& OHW_R5KCVTL
)
14448 fputs (" R5KCVTL", stdout
);
14451 fputs (" FILL ", stdout
);
14452 /* XXX Print content of info word? */
14455 fputs (" TAGS ", stdout
);
14456 /* XXX Print content of info word? */
14459 fputs (" HWAND ", stdout
);
14460 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14461 fputs (" R4KEOP_CHECKED", stdout
);
14462 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14463 fputs (" R4KEOP_CLEAN", stdout
);
14466 fputs (" HWOR ", stdout
);
14467 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14468 fputs (" R4KEOP_CHECKED", stdout
);
14469 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14470 fputs (" R4KEOP_CLEAN", stdout
);
14473 printf (" GP_GROUP %#06lx self-contained %#06lx",
14474 option
->info
& OGP_GROUP
,
14475 (option
->info
& OGP_SELF
) >> 16);
14478 printf (" IDENT %#06lx self-contained %#06lx",
14479 option
->info
& OGP_GROUP
,
14480 (option
->info
& OGP_SELF
) >> 16);
14483 /* This shouldn't happen. */
14484 printf (" %3d ??? %d %lx",
14485 option
->kind
, option
->section
, option
->info
);
14489 len
= sizeof (* eopt
);
14490 while (len
< option
->size
)
14492 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14494 if (ISPRINT (datum
))
14495 printf ("%c", datum
);
14497 printf ("\\%03o", datum
);
14500 fputs ("\n", stdout
);
14502 offset
+= option
->size
;
14510 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14512 Elf32_Conflict
* iconf
;
14515 if (dynamic_symbols
== NULL
)
14517 error (_("conflict list found without a dynamic symbol table\n"));
14521 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14524 error (_("Out of memory allocating space for dynamic conflicts\n"));
14530 Elf32_External_Conflict
* econf32
;
14532 econf32
= (Elf32_External_Conflict
*)
14533 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14534 sizeof (* econf32
), _("conflict"));
14538 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14539 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14545 Elf64_External_Conflict
* econf64
;
14547 econf64
= (Elf64_External_Conflict
*)
14548 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14549 sizeof (* econf64
), _("conflict"));
14553 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14554 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14559 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14560 (unsigned long) conflictsno
);
14561 puts (_(" Num: Index Value Name"));
14563 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14565 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14567 if (iconf
[cnt
] >= num_dynamic_syms
)
14568 printf (_("<corrupt symbol index>"));
14571 Elf_Internal_Sym
* psym
;
14573 psym
= & dynamic_symbols
[iconf
[cnt
]];
14574 print_vma (psym
->st_value
, FULL_HEX
);
14576 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14577 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14579 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14587 if (pltgot
!= 0 && local_gotno
!= 0)
14589 bfd_vma ent
, local_end
, global_end
;
14591 unsigned char * data
;
14592 unsigned char * data_end
;
14596 addr_size
= (is_32bit_elf
? 4 : 8);
14597 local_end
= pltgot
+ local_gotno
* addr_size
;
14599 /* PR binutils/17533 file: 012-111227-0.004 */
14600 if (symtabno
< gotsym
)
14602 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14603 (unsigned long) gotsym
, (unsigned long) symtabno
);
14607 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14608 /* PR 17531: file: 54c91a34. */
14609 if (global_end
< local_end
)
14611 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14615 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14616 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14617 global_end
- pltgot
, 1,
14618 _("Global Offset Table data"));
14621 data_end
= data
+ (global_end
- pltgot
);
14623 printf (_("\nPrimary GOT:\n"));
14624 printf (_(" Canonical gp value: "));
14625 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14628 printf (_(" Reserved entries:\n"));
14629 printf (_(" %*s %10s %*s Purpose\n"),
14630 addr_size
* 2, _("Address"), _("Access"),
14631 addr_size
* 2, _("Initial"));
14632 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14633 printf (_(" Lazy resolver\n"));
14634 if (ent
== (bfd_vma
) -1)
14635 goto got_print_fail
;
14637 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14638 >> (addr_size
* 8 - 1)) != 0)
14640 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14641 printf (_(" Module pointer (GNU extension)\n"));
14642 if (ent
== (bfd_vma
) -1)
14643 goto got_print_fail
;
14647 if (ent
< local_end
)
14649 printf (_(" Local entries:\n"));
14650 printf (" %*s %10s %*s\n",
14651 addr_size
* 2, _("Address"), _("Access"),
14652 addr_size
* 2, _("Initial"));
14653 while (ent
< local_end
)
14655 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14657 if (ent
== (bfd_vma
) -1)
14658 goto got_print_fail
;
14663 if (gotsym
< symtabno
)
14667 printf (_(" Global entries:\n"));
14668 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14669 addr_size
* 2, _("Address"),
14671 addr_size
* 2, _("Initial"),
14672 addr_size
* 2, _("Sym.Val."),
14674 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14675 _("Ndx"), _("Name"));
14677 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14679 for (i
= gotsym
; i
< symtabno
; i
++)
14681 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14684 if (dynamic_symbols
== NULL
)
14685 printf (_("<no dynamic symbols>"));
14686 else if (i
< num_dynamic_syms
)
14688 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14690 print_vma (psym
->st_value
, LONG_HEX
);
14691 printf (" %-7s %3s ",
14692 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14693 get_symbol_index_type (psym
->st_shndx
));
14695 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14696 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14698 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14701 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14702 (unsigned long) i
);
14705 if (ent
== (bfd_vma
) -1)
14716 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14719 size_t offset
, rel_offset
;
14720 unsigned long count
, i
;
14721 unsigned char * data
;
14722 int addr_size
, sym_width
;
14723 Elf_Internal_Rela
* rels
;
14725 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14726 if (pltrel
== DT_RELA
)
14728 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14733 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14738 addr_size
= (is_32bit_elf
? 4 : 8);
14739 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14741 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14742 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14743 1, _("Procedure Linkage Table data"));
14747 printf ("\nPLT GOT:\n\n");
14748 printf (_(" Reserved entries:\n"));
14749 printf (_(" %*s %*s Purpose\n"),
14750 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14751 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14752 printf (_(" PLT lazy resolver\n"));
14753 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14754 printf (_(" Module pointer\n"));
14757 printf (_(" Entries:\n"));
14758 printf (" %*s %*s %*s %-7s %3s %s\n",
14759 addr_size
* 2, _("Address"),
14760 addr_size
* 2, _("Initial"),
14761 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14762 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14763 for (i
= 0; i
< count
; i
++)
14765 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14767 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14770 if (idx
>= num_dynamic_syms
)
14771 printf (_("<corrupt symbol index: %lu>"), idx
);
14774 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14776 print_vma (psym
->st_value
, LONG_HEX
);
14777 printf (" %-7s %3s ",
14778 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14779 get_symbol_index_type (psym
->st_shndx
));
14780 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14781 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14783 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14798 process_nds32_specific (FILE * file
)
14800 Elf_Internal_Shdr
*sect
= NULL
;
14802 sect
= find_section (".nds32_e_flags");
14805 unsigned int *flag
;
14807 printf ("\nNDS32 elf flags section:\n");
14808 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14809 sect
->sh_size
, _("NDS32 elf flags section"));
14811 switch ((*flag
) & 0x3)
14814 printf ("(VEC_SIZE):\tNo entry.\n");
14817 printf ("(VEC_SIZE):\t4 bytes\n");
14820 printf ("(VEC_SIZE):\t16 bytes\n");
14823 printf ("(VEC_SIZE):\treserved\n");
14832 process_gnu_liblist (FILE * file
)
14834 Elf_Internal_Shdr
* section
;
14835 Elf_Internal_Shdr
* string_sec
;
14836 Elf32_External_Lib
* elib
;
14838 size_t strtab_size
;
14845 for (i
= 0, section
= section_headers
;
14846 i
< elf_header
.e_shnum
;
14849 switch (section
->sh_type
)
14851 case SHT_GNU_LIBLIST
:
14852 if (section
->sh_link
>= elf_header
.e_shnum
)
14855 elib
= (Elf32_External_Lib
*)
14856 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14857 _("liblist section data"));
14861 string_sec
= section_headers
+ section
->sh_link
;
14863 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14864 string_sec
->sh_size
,
14865 _("liblist string table"));
14867 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14873 strtab_size
= string_sec
->sh_size
;
14875 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14876 printable_section_name (section
),
14877 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14879 puts (_(" Library Time Stamp Checksum Version Flags"));
14881 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14889 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14890 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14891 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14892 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14893 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14895 tmp
= gmtime (&atime
);
14896 snprintf (timebuf
, sizeof (timebuf
),
14897 "%04u-%02u-%02uT%02u:%02u:%02u",
14898 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14899 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14901 printf ("%3lu: ", (unsigned long) cnt
);
14903 printf ("%-20s", liblist
.l_name
< strtab_size
14904 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14906 printf ("%-20.20s", liblist
.l_name
< strtab_size
14907 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14908 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14909 liblist
.l_version
, liblist
.l_flags
);
14920 static const char *
14921 get_note_type (unsigned e_type
)
14923 static char buff
[64];
14925 if (elf_header
.e_type
== ET_CORE
)
14929 return _("NT_AUXV (auxiliary vector)");
14931 return _("NT_PRSTATUS (prstatus structure)");
14933 return _("NT_FPREGSET (floating point registers)");
14935 return _("NT_PRPSINFO (prpsinfo structure)");
14936 case NT_TASKSTRUCT
:
14937 return _("NT_TASKSTRUCT (task structure)");
14939 return _("NT_PRXFPREG (user_xfpregs structure)");
14941 return _("NT_PPC_VMX (ppc Altivec registers)");
14943 return _("NT_PPC_VSX (ppc VSX registers)");
14945 return _("NT_386_TLS (x86 TLS information)");
14946 case NT_386_IOPERM
:
14947 return _("NT_386_IOPERM (x86 I/O permissions)");
14948 case NT_X86_XSTATE
:
14949 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14950 case NT_S390_HIGH_GPRS
:
14951 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14952 case NT_S390_TIMER
:
14953 return _("NT_S390_TIMER (s390 timer register)");
14954 case NT_S390_TODCMP
:
14955 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14956 case NT_S390_TODPREG
:
14957 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14959 return _("NT_S390_CTRS (s390 control registers)");
14960 case NT_S390_PREFIX
:
14961 return _("NT_S390_PREFIX (s390 prefix register)");
14962 case NT_S390_LAST_BREAK
:
14963 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14964 case NT_S390_SYSTEM_CALL
:
14965 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14967 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14968 case NT_S390_VXRS_LOW
:
14969 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14970 case NT_S390_VXRS_HIGH
:
14971 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14973 return _("NT_ARM_VFP (arm VFP registers)");
14975 return _("NT_ARM_TLS (AArch TLS registers)");
14976 case NT_ARM_HW_BREAK
:
14977 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14978 case NT_ARM_HW_WATCH
:
14979 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14981 return _("NT_PSTATUS (pstatus structure)");
14983 return _("NT_FPREGS (floating point registers)");
14985 return _("NT_PSINFO (psinfo structure)");
14987 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14989 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14990 case NT_WIN32PSTATUS
:
14991 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14993 return _("NT_SIGINFO (siginfo_t data)");
14995 return _("NT_FILE (mapped files)");
15003 return _("NT_VERSION (version)");
15005 return _("NT_ARCH (architecture)");
15010 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15015 print_core_note (Elf_Internal_Note
*pnote
)
15017 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15018 bfd_vma count
, page_size
;
15019 unsigned char *descdata
, *filenames
, *descend
;
15021 if (pnote
->type
!= NT_FILE
)
15027 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15028 /* Still "successful". */
15033 if (pnote
->descsz
< 2 * addr_size
)
15035 printf (_(" Malformed note - too short for header\n"));
15039 descdata
= (unsigned char *) pnote
->descdata
;
15040 descend
= descdata
+ pnote
->descsz
;
15042 if (descdata
[pnote
->descsz
- 1] != '\0')
15044 printf (_(" Malformed note - does not end with \\0\n"));
15048 count
= byte_get (descdata
, addr_size
);
15049 descdata
+= addr_size
;
15051 page_size
= byte_get (descdata
, addr_size
);
15052 descdata
+= addr_size
;
15054 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15056 printf (_(" Malformed note - too short for supplied file count\n"));
15060 printf (_(" Page size: "));
15061 print_vma (page_size
, DEC
);
15064 printf (_(" %*s%*s%*s\n"),
15065 (int) (2 + 2 * addr_size
), _("Start"),
15066 (int) (4 + 2 * addr_size
), _("End"),
15067 (int) (4 + 2 * addr_size
), _("Page Offset"));
15068 filenames
= descdata
+ count
* 3 * addr_size
;
15069 while (--count
> 0)
15071 bfd_vma start
, end
, file_ofs
;
15073 if (filenames
== descend
)
15075 printf (_(" Malformed note - filenames end too early\n"));
15079 start
= byte_get (descdata
, addr_size
);
15080 descdata
+= addr_size
;
15081 end
= byte_get (descdata
, addr_size
);
15082 descdata
+= addr_size
;
15083 file_ofs
= byte_get (descdata
, addr_size
);
15084 descdata
+= addr_size
;
15087 print_vma (start
, FULL_HEX
);
15089 print_vma (end
, FULL_HEX
);
15091 print_vma (file_ofs
, FULL_HEX
);
15092 printf ("\n %s\n", filenames
);
15094 filenames
+= 1 + strlen ((char *) filenames
);
15100 static const char *
15101 get_gnu_elf_note_type (unsigned e_type
)
15103 static char buff
[64];
15107 case NT_GNU_ABI_TAG
:
15108 return _("NT_GNU_ABI_TAG (ABI version tag)");
15110 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15111 case NT_GNU_BUILD_ID
:
15112 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15113 case NT_GNU_GOLD_VERSION
:
15114 return _("NT_GNU_GOLD_VERSION (gold version)");
15119 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15124 print_gnu_note (Elf_Internal_Note
*pnote
)
15126 switch (pnote
->type
)
15128 case NT_GNU_BUILD_ID
:
15132 printf (_(" Build ID: "));
15133 for (i
= 0; i
< pnote
->descsz
; ++i
)
15134 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15139 case NT_GNU_ABI_TAG
:
15141 unsigned long os
, major
, minor
, subminor
;
15142 const char *osname
;
15144 /* PR 17531: file: 030-599401-0.004. */
15145 if (pnote
->descsz
< 16)
15147 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15151 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15152 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15153 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15154 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15158 case GNU_ABI_TAG_LINUX
:
15161 case GNU_ABI_TAG_HURD
:
15164 case GNU_ABI_TAG_SOLARIS
:
15165 osname
= "Solaris";
15167 case GNU_ABI_TAG_FREEBSD
:
15168 osname
= "FreeBSD";
15170 case GNU_ABI_TAG_NETBSD
:
15173 case GNU_ABI_TAG_SYLLABLE
:
15174 osname
= "Syllable";
15176 case GNU_ABI_TAG_NACL
:
15180 osname
= "Unknown";
15184 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15185 major
, minor
, subminor
);
15189 case NT_GNU_GOLD_VERSION
:
15193 printf (_(" Version: "));
15194 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15195 printf ("%c", pnote
->descdata
[i
]);
15204 static const char *
15205 get_v850_elf_note_type (enum v850_notes n_type
)
15207 static char buff
[64];
15211 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15212 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15213 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15214 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15215 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15216 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15218 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15224 print_v850_note (Elf_Internal_Note
* pnote
)
15228 if (pnote
->descsz
!= 4)
15230 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15234 printf (_("not set\n"));
15238 switch (pnote
->type
)
15240 case V850_NOTE_ALIGNMENT
:
15243 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15244 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15248 case V850_NOTE_DATA_SIZE
:
15251 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15252 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15256 case V850_NOTE_FPU_INFO
:
15259 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15260 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15264 case V850_NOTE_MMU_INFO
:
15265 case V850_NOTE_CACHE_INFO
:
15266 case V850_NOTE_SIMD_INFO
:
15267 if (val
== EF_RH850_SIMD
)
15269 printf (_("yes\n"));
15275 /* An 'unknown note type' message will already have been displayed. */
15279 printf (_("unknown value: %x\n"), val
);
15283 static const char *
15284 get_netbsd_elfcore_note_type (unsigned e_type
)
15286 static char buff
[64];
15288 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15290 /* NetBSD core "procinfo" structure. */
15291 return _("NetBSD procinfo structure");
15294 /* As of Jan 2002 there are no other machine-independent notes
15295 defined for NetBSD core files. If the note type is less
15296 than the start of the machine-dependent note types, we don't
15299 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15301 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15305 switch (elf_header
.e_machine
)
15307 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15308 and PT_GETFPREGS == mach+2. */
15313 case EM_SPARC32PLUS
:
15317 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15318 return _("PT_GETREGS (reg structure)");
15319 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15320 return _("PT_GETFPREGS (fpreg structure)");
15326 /* On all other arch's, PT_GETREGS == mach+1 and
15327 PT_GETFPREGS == mach+3. */
15331 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15332 return _("PT_GETREGS (reg structure)");
15333 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15334 return _("PT_GETFPREGS (fpreg structure)");
15340 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15341 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15345 static const char *
15346 get_stapsdt_note_type (unsigned e_type
)
15348 static char buff
[64];
15353 return _("NT_STAPSDT (SystemTap probe descriptors)");
15359 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15364 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15366 int addr_size
= is_32bit_elf
? 4 : 8;
15367 char *data
= pnote
->descdata
;
15368 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15369 bfd_vma pc
, base_addr
, semaphore
;
15370 char *provider
, *probe
, *arg_fmt
;
15372 pc
= byte_get ((unsigned char *) data
, addr_size
);
15374 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15376 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15380 data
+= strlen (data
) + 1;
15382 data
+= strlen (data
) + 1;
15384 data
+= strlen (data
) + 1;
15386 printf (_(" Provider: %s\n"), provider
);
15387 printf (_(" Name: %s\n"), probe
);
15388 printf (_(" Location: "));
15389 print_vma (pc
, FULL_HEX
);
15390 printf (_(", Base: "));
15391 print_vma (base_addr
, FULL_HEX
);
15392 printf (_(", Semaphore: "));
15393 print_vma (semaphore
, FULL_HEX
);
15395 printf (_(" Arguments: %s\n"), arg_fmt
);
15397 return data
== data_end
;
15400 static const char *
15401 get_ia64_vms_note_type (unsigned e_type
)
15403 static char buff
[64];
15408 return _("NT_VMS_MHD (module header)");
15410 return _("NT_VMS_LNM (language name)");
15412 return _("NT_VMS_SRC (source files)");
15414 return "NT_VMS_TITLE";
15416 return _("NT_VMS_EIDC (consistency check)");
15417 case NT_VMS_FPMODE
:
15418 return _("NT_VMS_FPMODE (FP mode)");
15419 case NT_VMS_LINKTIME
:
15420 return "NT_VMS_LINKTIME";
15421 case NT_VMS_IMGNAM
:
15422 return _("NT_VMS_IMGNAM (image name)");
15424 return _("NT_VMS_IMGID (image id)");
15425 case NT_VMS_LINKID
:
15426 return _("NT_VMS_LINKID (link id)");
15427 case NT_VMS_IMGBID
:
15428 return _("NT_VMS_IMGBID (build id)");
15429 case NT_VMS_GSTNAM
:
15430 return _("NT_VMS_GSTNAM (sym table name)");
15431 case NT_VMS_ORIG_DYN
:
15432 return "NT_VMS_ORIG_DYN";
15433 case NT_VMS_PATCHTIME
:
15434 return "NT_VMS_PATCHTIME";
15436 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15442 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15444 switch (pnote
->type
)
15447 if (pnote
->descsz
> 36)
15449 size_t l
= strlen (pnote
->descdata
+ 34);
15450 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15451 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15452 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15453 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15456 printf (_(" Invalid size\n"));
15459 printf (_(" Language: %s\n"), pnote
->descdata
);
15462 case NT_VMS_FPMODE
:
15463 printf (_(" Floating Point mode: "));
15464 printf ("0x%016" BFD_VMA_FMT
"x\n",
15465 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15467 case NT_VMS_LINKTIME
:
15468 printf (_(" Link time: "));
15470 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15473 case NT_VMS_PATCHTIME
:
15474 printf (_(" Patch time: "));
15476 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15479 case NT_VMS_ORIG_DYN
:
15480 printf (_(" Major id: %u, minor id: %u\n"),
15481 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15482 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15483 printf (_(" Last modified : "));
15485 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15486 printf (_("\n Link flags : "));
15487 printf ("0x%016" BFD_VMA_FMT
"x\n",
15488 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15489 printf (_(" Header flags: 0x%08x\n"),
15490 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15491 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15494 case NT_VMS_IMGNAM
:
15495 printf (_(" Image name: %s\n"), pnote
->descdata
);
15497 case NT_VMS_GSTNAM
:
15498 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15501 printf (_(" Image id: %s\n"), pnote
->descdata
);
15503 case NT_VMS_LINKID
:
15504 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15512 /* Note that by the ELF standard, the name field is already null byte
15513 terminated, and namesz includes the terminating null byte.
15514 I.E. the value of namesz for the name "FSF" is 4.
15516 If the value of namesz is zero, there is no name present. */
15518 process_note (Elf_Internal_Note
* pnote
)
15520 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15523 if (pnote
->namesz
== 0)
15524 /* If there is no note name, then use the default set of
15525 note type strings. */
15526 nt
= get_note_type (pnote
->type
);
15528 else if (const_strneq (pnote
->namedata
, "GNU"))
15529 /* GNU-specific object file notes. */
15530 nt
= get_gnu_elf_note_type (pnote
->type
);
15532 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15533 /* NetBSD-specific core file notes. */
15534 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15536 else if (strneq (pnote
->namedata
, "SPU/", 4))
15538 /* SPU-specific core file notes. */
15539 nt
= pnote
->namedata
+ 4;
15543 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15544 /* VMS/ia64-specific file notes. */
15545 nt
= get_ia64_vms_note_type (pnote
->type
);
15547 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15548 nt
= get_stapsdt_note_type (pnote
->type
);
15551 /* Don't recognize this note name; just use the default set of
15552 note type strings. */
15553 nt
= get_note_type (pnote
->type
);
15555 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15557 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15558 return print_ia64_vms_note (pnote
);
15559 else if (const_strneq (pnote
->namedata
, "GNU"))
15560 return print_gnu_note (pnote
);
15561 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15562 return print_stapsdt_note (pnote
);
15563 else if (const_strneq (pnote
->namedata
, "CORE"))
15564 return print_core_note (pnote
);
15571 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15573 Elf_External_Note
* pnotes
;
15574 Elf_External_Note
* external
;
15581 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15583 if (pnotes
== NULL
)
15588 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15589 (unsigned long) offset
, (unsigned long) length
);
15590 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15592 end
= (char *) pnotes
+ length
;
15593 while ((char *) external
< end
)
15595 Elf_Internal_Note inote
;
15598 char * temp
= NULL
;
15599 size_t data_remaining
= end
- (char *) external
;
15601 if (!is_ia64_vms ())
15603 /* PR binutils/15191
15604 Make sure that there is enough data to read. */
15605 min_notesz
= offsetof (Elf_External_Note
, name
);
15606 if (data_remaining
< min_notesz
)
15608 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15609 (int) data_remaining
);
15612 inote
.type
= BYTE_GET (external
->type
);
15613 inote
.namesz
= BYTE_GET (external
->namesz
);
15614 inote
.namedata
= external
->name
;
15615 inote
.descsz
= BYTE_GET (external
->descsz
);
15616 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15617 /* PR 17531: file: 3443835e. */
15618 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15620 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15621 inote
.descdata
= inote
.namedata
;
15625 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15626 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15630 Elf64_External_VMS_Note
*vms_external
;
15632 /* PR binutils/15191
15633 Make sure that there is enough data to read. */
15634 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15635 if (data_remaining
< min_notesz
)
15637 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15638 (int) data_remaining
);
15642 vms_external
= (Elf64_External_VMS_Note
*) external
;
15643 inote
.type
= BYTE_GET (vms_external
->type
);
15644 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15645 inote
.namedata
= vms_external
->name
;
15646 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15647 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15648 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15649 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15652 if (inote
.descdata
< (char *) external
+ min_notesz
15653 || next
< (char *) external
+ min_notesz
15654 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15655 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15656 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15657 || data_remaining
< (size_t)(next
- (char *) external
))
15659 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15660 (unsigned long) ((char *) external
- (char *) pnotes
));
15661 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15662 inote
.type
, inote
.namesz
, inote
.descsz
);
15666 external
= (Elf_External_Note
*) next
;
15668 /* Verify that name is null terminated. It appears that at least
15669 one version of Linux (RedHat 6.0) generates corefiles that don't
15670 comply with the ELF spec by failing to include the null byte in
15672 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15674 temp
= (char *) malloc (inote
.namesz
+ 1);
15677 error (_("Out of memory allocating space for inote name\n"));
15682 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15683 temp
[inote
.namesz
] = 0;
15685 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15686 inote
.namedata
= temp
;
15689 res
&= process_note (& inote
);
15704 process_corefile_note_segments (FILE * file
)
15706 Elf_Internal_Phdr
* segment
;
15710 if (! get_program_headers (file
))
15713 for (i
= 0, segment
= program_headers
;
15714 i
< elf_header
.e_phnum
;
15717 if (segment
->p_type
== PT_NOTE
)
15718 res
&= process_corefile_note_segment (file
,
15719 (bfd_vma
) segment
->p_offset
,
15720 (bfd_vma
) segment
->p_filesz
);
15727 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15729 Elf_External_Note
* pnotes
;
15730 Elf_External_Note
* external
;
15737 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15739 if (pnotes
== NULL
)
15743 end
= (char*) pnotes
+ length
;
15745 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15746 (unsigned long) offset
, (unsigned long) length
);
15748 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15750 Elf_External_Note
* next
;
15751 Elf_Internal_Note inote
;
15753 inote
.type
= BYTE_GET (external
->type
);
15754 inote
.namesz
= BYTE_GET (external
->namesz
);
15755 inote
.namedata
= external
->name
;
15756 inote
.descsz
= BYTE_GET (external
->descsz
);
15757 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15758 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15760 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15762 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15763 inote
.descdata
= inote
.namedata
;
15767 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15769 if ( ((char *) next
> end
)
15770 || ((char *) next
< (char *) pnotes
))
15772 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15773 (unsigned long) ((char *) external
- (char *) pnotes
));
15774 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15775 inote
.type
, inote
.namesz
, inote
.descsz
);
15781 /* Prevent out-of-bounds indexing. */
15782 if ( inote
.namedata
+ inote
.namesz
> end
15783 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15785 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15786 (unsigned long) ((char *) external
- (char *) pnotes
));
15787 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15788 inote
.type
, inote
.namesz
, inote
.descsz
);
15792 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15794 if (! print_v850_note (& inote
))
15797 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15798 inote
.namesz
, inote
.descsz
);
15808 process_note_sections (FILE * file
)
15810 Elf_Internal_Shdr
* section
;
15815 for (i
= 0, section
= section_headers
;
15816 i
< elf_header
.e_shnum
&& section
!= NULL
;
15819 if (section
->sh_type
== SHT_NOTE
)
15821 res
&= process_corefile_note_segment (file
,
15822 (bfd_vma
) section
->sh_offset
,
15823 (bfd_vma
) section
->sh_size
);
15827 if (( elf_header
.e_machine
== EM_V800
15828 || elf_header
.e_machine
== EM_V850
15829 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15830 && section
->sh_type
== SHT_RENESAS_INFO
)
15832 res
&= process_v850_notes (file
,
15833 (bfd_vma
) section
->sh_offset
,
15834 (bfd_vma
) section
->sh_size
);
15840 /* Try processing NOTE segments instead. */
15841 return process_corefile_note_segments (file
);
15847 process_notes (FILE * file
)
15849 /* If we have not been asked to display the notes then do nothing. */
15853 if (elf_header
.e_type
!= ET_CORE
)
15854 return process_note_sections (file
);
15856 /* No program headers means no NOTE segment. */
15857 if (elf_header
.e_phnum
> 0)
15858 return process_corefile_note_segments (file
);
15860 printf (_("No note segments present in the core file.\n"));
15865 process_arch_specific (FILE * file
)
15870 switch (elf_header
.e_machine
)
15873 return process_arm_specific (file
);
15875 case EM_MIPS_RS3_LE
:
15876 return process_mips_specific (file
);
15879 return process_nds32_specific (file
);
15882 return process_power_specific (file
);
15886 return process_s390_specific (file
);
15889 case EM_SPARC32PLUS
:
15891 return process_sparc_specific (file
);
15894 return process_tic6x_specific (file
);
15897 return process_msp430x_specific (file
);
15905 get_file_header (FILE * file
)
15907 /* Read in the identity array. */
15908 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15911 /* Determine how to read the rest of the header. */
15912 switch (elf_header
.e_ident
[EI_DATA
])
15914 default: /* fall through */
15915 case ELFDATANONE
: /* fall through */
15917 byte_get
= byte_get_little_endian
;
15918 byte_put
= byte_put_little_endian
;
15921 byte_get
= byte_get_big_endian
;
15922 byte_put
= byte_put_big_endian
;
15926 /* For now we only support 32 bit and 64 bit ELF files. */
15927 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15929 /* Read in the rest of the header. */
15932 Elf32_External_Ehdr ehdr32
;
15934 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15937 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15938 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15939 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15940 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15941 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15942 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15943 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15944 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15945 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15946 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15947 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15948 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15949 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15953 Elf64_External_Ehdr ehdr64
;
15955 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15956 we will not be able to cope with the 64bit data found in
15957 64 ELF files. Detect this now and abort before we start
15958 overwriting things. */
15959 if (sizeof (bfd_vma
) < 8)
15961 error (_("This instance of readelf has been built without support for a\n\
15962 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15966 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15969 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15970 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15971 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15972 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15973 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15974 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15975 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15976 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15977 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15978 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15979 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15980 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15981 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15984 if (elf_header
.e_shoff
)
15986 /* There may be some extensions in the first section header. Don't
15987 bomb if we can't read it. */
15989 get_32bit_section_headers (file
, TRUE
);
15991 get_64bit_section_headers (file
, TRUE
);
15997 /* Process one ELF object file according to the command line options.
15998 This file may actually be stored in an archive. The file is
15999 positioned at the start of the ELF object. */
16002 process_object (char * file_name
, FILE * file
)
16006 if (! get_file_header (file
))
16008 error (_("%s: Failed to read file header\n"), file_name
);
16012 /* Initialise per file variables. */
16013 for (i
= ARRAY_SIZE (version_info
); i
--;)
16014 version_info
[i
] = 0;
16016 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16017 dynamic_info
[i
] = 0;
16018 dynamic_info_DT_GNU_HASH
= 0;
16020 /* Process the file. */
16022 printf (_("\nFile: %s\n"), file_name
);
16024 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16025 Note we do this even if cmdline_dump_sects is empty because we
16026 must make sure that the dump_sets array is zeroed out before each
16027 object file is processed. */
16028 if (num_dump_sects
> num_cmdline_dump_sects
)
16029 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16031 if (num_cmdline_dump_sects
> 0)
16033 if (num_dump_sects
== 0)
16034 /* A sneaky way of allocating the dump_sects array. */
16035 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16037 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16038 memcpy (dump_sects
, cmdline_dump_sects
,
16039 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16042 if (! process_file_header ())
16045 if (! process_section_headers (file
))
16047 /* Without loaded section headers we cannot process lots of
16049 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16051 if (! do_using_dynamic
)
16052 do_syms
= do_dyn_syms
= do_reloc
= 0;
16055 if (! process_section_groups (file
))
16057 /* Without loaded section groups we cannot process unwind. */
16061 if (process_program_headers (file
))
16062 process_dynamic_section (file
);
16064 process_relocs (file
);
16066 process_unwind (file
);
16068 process_symbol_table (file
);
16070 process_syminfo (file
);
16072 process_version_sections (file
);
16074 process_section_contents (file
);
16076 process_notes (file
);
16078 process_gnu_liblist (file
);
16080 process_arch_specific (file
);
16082 if (program_headers
)
16084 free (program_headers
);
16085 program_headers
= NULL
;
16088 if (section_headers
)
16090 free (section_headers
);
16091 section_headers
= NULL
;
16096 free (string_table
);
16097 string_table
= NULL
;
16098 string_table_length
= 0;
16101 if (dynamic_strings
)
16103 free (dynamic_strings
);
16104 dynamic_strings
= NULL
;
16105 dynamic_strings_length
= 0;
16108 if (dynamic_symbols
)
16110 free (dynamic_symbols
);
16111 dynamic_symbols
= NULL
;
16112 num_dynamic_syms
= 0;
16115 if (dynamic_syminfo
)
16117 free (dynamic_syminfo
);
16118 dynamic_syminfo
= NULL
;
16121 if (dynamic_section
)
16123 free (dynamic_section
);
16124 dynamic_section
= NULL
;
16127 if (section_headers_groups
)
16129 free (section_headers_groups
);
16130 section_headers_groups
= NULL
;
16133 if (section_groups
)
16135 struct group_list
* g
;
16136 struct group_list
* next
;
16138 for (i
= 0; i
< group_count
; i
++)
16140 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16147 free (section_groups
);
16148 section_groups
= NULL
;
16151 free_debug_memory ();
16156 /* Process an ELF archive.
16157 On entry the file is positioned just after the ARMAG string. */
16160 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16162 struct archive_info arch
;
16163 struct archive_info nested_arch
;
16169 /* The ARCH structure is used to hold information about this archive. */
16170 arch
.file_name
= NULL
;
16172 arch
.index_array
= NULL
;
16173 arch
.sym_table
= NULL
;
16174 arch
.longnames
= NULL
;
16176 /* The NESTED_ARCH structure is used as a single-item cache of information
16177 about a nested archive (when members of a thin archive reside within
16178 another regular archive file). */
16179 nested_arch
.file_name
= NULL
;
16180 nested_arch
.file
= NULL
;
16181 nested_arch
.index_array
= NULL
;
16182 nested_arch
.sym_table
= NULL
;
16183 nested_arch
.longnames
= NULL
;
16185 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16191 if (do_archive_index
)
16193 if (arch
.sym_table
== NULL
)
16194 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16197 unsigned long i
, l
;
16198 unsigned long current_pos
;
16200 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16201 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16202 current_pos
= ftell (file
);
16204 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16206 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16208 char * member_name
;
16210 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16212 if (member_name
!= NULL
)
16214 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16216 if (qualified_name
!= NULL
)
16218 printf (_("Contents of binary %s at offset "), qualified_name
);
16219 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16221 free (qualified_name
);
16226 if (l
>= arch
.sym_size
)
16228 error (_("%s: end of the symbol table reached before the end of the index\n"),
16232 /* PR 17531: file: 0b6630b2. */
16233 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16234 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16237 if (arch
.uses_64bit_indicies
)
16242 if (l
< arch
.sym_size
)
16243 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16244 file_name
, arch
.sym_size
- l
);
16246 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16248 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16254 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16255 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16256 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16257 && !do_section_groups
&& !do_dyn_syms
)
16259 ret
= 0; /* Archive index only. */
16270 char * qualified_name
;
16272 /* Read the next archive header. */
16273 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16275 error (_("%s: failed to seek to next archive header\n"), file_name
);
16278 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16279 if (got
!= sizeof arch
.arhdr
)
16283 error (_("%s: failed to read archive header\n"), file_name
);
16287 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16289 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16294 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16296 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16297 if (archive_file_size
& 01)
16298 ++archive_file_size
;
16300 name
= get_archive_member_name (&arch
, &nested_arch
);
16303 error (_("%s: bad archive file name\n"), file_name
);
16307 namelen
= strlen (name
);
16309 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16310 if (qualified_name
== NULL
)
16312 error (_("%s: bad archive file name\n"), file_name
);
16317 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16319 /* This is a proxy for an external member of a thin archive. */
16320 FILE * member_file
;
16321 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16322 if (member_file_name
== NULL
)
16328 member_file
= fopen (member_file_name
, "rb");
16329 if (member_file
== NULL
)
16331 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16332 free (member_file_name
);
16337 archive_file_offset
= arch
.nested_member_origin
;
16339 ret
|= process_object (qualified_name
, member_file
);
16341 fclose (member_file
);
16342 free (member_file_name
);
16344 else if (is_thin_archive
)
16346 /* PR 15140: Allow for corrupt thin archives. */
16347 if (nested_arch
.file
== NULL
)
16349 error (_("%s: contains corrupt thin archive: %s\n"),
16355 /* This is a proxy for a member of a nested archive. */
16356 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16358 /* The nested archive file will have been opened and setup by
16359 get_archive_member_name. */
16360 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16362 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16367 ret
|= process_object (qualified_name
, nested_arch
.file
);
16371 archive_file_offset
= arch
.next_arhdr_offset
;
16372 arch
.next_arhdr_offset
+= archive_file_size
;
16374 ret
|= process_object (qualified_name
, file
);
16377 if (dump_sects
!= NULL
)
16381 num_dump_sects
= 0;
16384 free (qualified_name
);
16388 if (nested_arch
.file
!= NULL
)
16389 fclose (nested_arch
.file
);
16390 release_archive (&nested_arch
);
16391 release_archive (&arch
);
16397 process_file (char * file_name
)
16400 struct stat statbuf
;
16401 char armag
[SARMAG
];
16404 if (stat (file_name
, &statbuf
) < 0)
16406 if (errno
== ENOENT
)
16407 error (_("'%s': No such file\n"), file_name
);
16409 error (_("Could not locate '%s'. System error message: %s\n"),
16410 file_name
, strerror (errno
));
16414 if (! S_ISREG (statbuf
.st_mode
))
16416 error (_("'%s' is not an ordinary file\n"), file_name
);
16420 file
= fopen (file_name
, "rb");
16423 error (_("Input file '%s' is not readable.\n"), file_name
);
16427 if (fread (armag
, SARMAG
, 1, file
) != 1)
16429 error (_("%s: Failed to read file's magic number\n"), file_name
);
16434 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16436 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16437 ret
= process_archive (file_name
, file
, FALSE
);
16438 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16439 ret
= process_archive (file_name
, file
, TRUE
);
16442 if (do_archive_index
)
16443 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16447 archive_file_size
= archive_file_offset
= 0;
16448 ret
= process_object (file_name
, file
);
16453 current_file_size
= 0;
16457 #ifdef SUPPORT_DISASSEMBLY
16458 /* Needed by the i386 disassembler. For extra credit, someone could
16459 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16463 print_address (unsigned int addr
, FILE * outfile
)
16465 fprintf (outfile
,"0x%8.8x", addr
);
16468 /* Needed by the i386 disassembler. */
16470 db_task_printsym (unsigned int addr
)
16472 print_address (addr
, stderr
);
16477 main (int argc
, char ** argv
)
16481 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16482 setlocale (LC_MESSAGES
, "");
16484 #if defined (HAVE_SETLOCALE)
16485 setlocale (LC_CTYPE
, "");
16487 bindtextdomain (PACKAGE
, LOCALEDIR
);
16488 textdomain (PACKAGE
);
16490 expandargv (&argc
, &argv
);
16492 parse_args (argc
, argv
);
16494 if (num_dump_sects
> 0)
16496 /* Make a copy of the dump_sects array. */
16497 cmdline_dump_sects
= (dump_type
*)
16498 malloc (num_dump_sects
* sizeof (* dump_sects
));
16499 if (cmdline_dump_sects
== NULL
)
16500 error (_("Out of memory allocating dump request table.\n"));
16503 memcpy (cmdline_dump_sects
, dump_sects
,
16504 num_dump_sects
* sizeof (* dump_sects
));
16505 num_cmdline_dump_sects
= num_dump_sects
;
16509 if (optind
< (argc
- 1))
16511 else if (optind
>= argc
)
16513 warn (_("Nothing to do.\n"));
16518 while (optind
< argc
)
16519 err
|= process_file (argv
[optind
++]);
16521 if (dump_sects
!= NULL
)
16523 if (cmdline_dump_sects
!= NULL
)
16524 free (cmdline_dump_sects
);