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_signed_vma off
= rels
[i
].r_addend
;
1613 /* PR 17531: file: 2e63226f. */
1614 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1615 printf (" + %" BFD_VMA_FMT
"x", off
);
1617 printf (" - %" BFD_VMA_FMT
"x", - off
);
1619 printf (" + %" BFD_VMA_FMT
"x", off
);
1625 bfd_signed_vma off
= rels
[i
].r_addend
;
1627 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1628 /* PR 17531: file: 2e63226f. */
1629 if (off
== ((bfd_signed_vma
) 1) << ((sizeof (bfd_signed_vma
) * 8) - 1))
1630 printf ("%" BFD_VMA_FMT
"x", off
);
1632 printf ("-%" BFD_VMA_FMT
"x", - off
);
1634 printf ("%" BFD_VMA_FMT
"x", off
);
1637 if (elf_header
.e_machine
== EM_SPARCV9
1639 && streq (rtype
, "R_SPARC_OLO10"))
1640 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1645 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1647 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1648 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1649 const char * rtype2
= elf_mips_reloc_type (type2
);
1650 const char * rtype3
= elf_mips_reloc_type (type3
);
1652 printf (" Type2: ");
1655 printf (_("unrecognized: %-7lx"),
1656 (unsigned long) type2
& 0xffffffff);
1658 printf ("%-17.17s", rtype2
);
1660 printf ("\n Type3: ");
1663 printf (_("unrecognized: %-7lx"),
1664 (unsigned long) type3
& 0xffffffff);
1666 printf ("%-17.17s", rtype3
);
1677 get_mips_dynamic_type (unsigned long type
)
1681 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1682 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1683 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1684 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1685 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1686 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1687 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1688 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1689 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1690 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1691 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1692 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1693 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1694 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1695 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1696 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1697 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1698 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1699 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1700 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1701 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1702 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1703 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1704 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1705 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1706 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1707 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1708 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1709 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1710 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1711 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1712 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1713 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1714 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1715 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1716 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1717 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1718 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1719 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1720 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1721 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1722 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1723 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1724 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1725 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1726 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1733 get_sparc64_dynamic_type (unsigned long type
)
1737 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1744 get_ppc_dynamic_type (unsigned long type
)
1748 case DT_PPC_GOT
: return "PPC_GOT";
1749 case DT_PPC_OPT
: return "PPC_OPT";
1756 get_ppc64_dynamic_type (unsigned long type
)
1760 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1761 case DT_PPC64_OPD
: return "PPC64_OPD";
1762 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1763 case DT_PPC64_OPT
: return "PPC64_OPT";
1770 get_parisc_dynamic_type (unsigned long type
)
1774 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1775 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1776 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1777 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1778 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1779 case DT_HP_PREINIT
: return "HP_PREINIT";
1780 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1781 case DT_HP_NEEDED
: return "HP_NEEDED";
1782 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1783 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1784 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1785 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1786 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1787 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1788 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1789 case DT_HP_FILTERED
: return "HP_FILTERED";
1790 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1791 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1792 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1793 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1794 case DT_PLT
: return "PLT";
1795 case DT_PLT_SIZE
: return "PLT_SIZE";
1796 case DT_DLT
: return "DLT";
1797 case DT_DLT_SIZE
: return "DLT_SIZE";
1804 get_ia64_dynamic_type (unsigned long type
)
1808 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1809 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1810 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1811 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1812 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1813 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1814 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1815 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1816 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1817 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1818 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1819 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1820 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1821 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1822 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1823 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1824 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1825 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1826 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1827 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1828 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1829 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1830 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1831 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1832 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1833 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1834 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1835 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1836 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1837 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1838 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1845 get_alpha_dynamic_type (unsigned long type
)
1849 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1856 get_score_dynamic_type (unsigned long type
)
1860 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1861 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1862 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1863 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1864 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1865 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1872 get_tic6x_dynamic_type (unsigned long type
)
1876 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1877 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1878 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1879 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1880 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1881 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1888 get_nios2_dynamic_type (unsigned long type
)
1892 case DT_NIOS2_GP
: return "NIOS2_GP";
1899 get_dynamic_type (unsigned long type
)
1901 static char buff
[64];
1905 case DT_NULL
: return "NULL";
1906 case DT_NEEDED
: return "NEEDED";
1907 case DT_PLTRELSZ
: return "PLTRELSZ";
1908 case DT_PLTGOT
: return "PLTGOT";
1909 case DT_HASH
: return "HASH";
1910 case DT_STRTAB
: return "STRTAB";
1911 case DT_SYMTAB
: return "SYMTAB";
1912 case DT_RELA
: return "RELA";
1913 case DT_RELASZ
: return "RELASZ";
1914 case DT_RELAENT
: return "RELAENT";
1915 case DT_STRSZ
: return "STRSZ";
1916 case DT_SYMENT
: return "SYMENT";
1917 case DT_INIT
: return "INIT";
1918 case DT_FINI
: return "FINI";
1919 case DT_SONAME
: return "SONAME";
1920 case DT_RPATH
: return "RPATH";
1921 case DT_SYMBOLIC
: return "SYMBOLIC";
1922 case DT_REL
: return "REL";
1923 case DT_RELSZ
: return "RELSZ";
1924 case DT_RELENT
: return "RELENT";
1925 case DT_PLTREL
: return "PLTREL";
1926 case DT_DEBUG
: return "DEBUG";
1927 case DT_TEXTREL
: return "TEXTREL";
1928 case DT_JMPREL
: return "JMPREL";
1929 case DT_BIND_NOW
: return "BIND_NOW";
1930 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1931 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1932 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1933 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1934 case DT_RUNPATH
: return "RUNPATH";
1935 case DT_FLAGS
: return "FLAGS";
1937 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1938 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1940 case DT_CHECKSUM
: return "CHECKSUM";
1941 case DT_PLTPADSZ
: return "PLTPADSZ";
1942 case DT_MOVEENT
: return "MOVEENT";
1943 case DT_MOVESZ
: return "MOVESZ";
1944 case DT_FEATURE
: return "FEATURE";
1945 case DT_POSFLAG_1
: return "POSFLAG_1";
1946 case DT_SYMINSZ
: return "SYMINSZ";
1947 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1949 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1950 case DT_CONFIG
: return "CONFIG";
1951 case DT_DEPAUDIT
: return "DEPAUDIT";
1952 case DT_AUDIT
: return "AUDIT";
1953 case DT_PLTPAD
: return "PLTPAD";
1954 case DT_MOVETAB
: return "MOVETAB";
1955 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1957 case DT_VERSYM
: return "VERSYM";
1959 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1960 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1961 case DT_RELACOUNT
: return "RELACOUNT";
1962 case DT_RELCOUNT
: return "RELCOUNT";
1963 case DT_FLAGS_1
: return "FLAGS_1";
1964 case DT_VERDEF
: return "VERDEF";
1965 case DT_VERDEFNUM
: return "VERDEFNUM";
1966 case DT_VERNEED
: return "VERNEED";
1967 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1969 case DT_AUXILIARY
: return "AUXILIARY";
1970 case DT_USED
: return "USED";
1971 case DT_FILTER
: return "FILTER";
1973 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1974 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1975 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1976 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1977 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1978 case DT_GNU_HASH
: return "GNU_HASH";
1981 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1983 const char * result
;
1985 switch (elf_header
.e_machine
)
1988 case EM_MIPS_RS3_LE
:
1989 result
= get_mips_dynamic_type (type
);
1992 result
= get_sparc64_dynamic_type (type
);
1995 result
= get_ppc_dynamic_type (type
);
1998 result
= get_ppc64_dynamic_type (type
);
2001 result
= get_ia64_dynamic_type (type
);
2004 result
= get_alpha_dynamic_type (type
);
2007 result
= get_score_dynamic_type (type
);
2010 result
= get_tic6x_dynamic_type (type
);
2012 case EM_ALTERA_NIOS2
:
2013 result
= get_nios2_dynamic_type (type
);
2023 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2025 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2026 || (elf_header
.e_machine
== EM_PARISC
2027 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2029 const char * result
;
2031 switch (elf_header
.e_machine
)
2034 result
= get_parisc_dynamic_type (type
);
2037 result
= get_ia64_dynamic_type (type
);
2047 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2051 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2058 get_file_type (unsigned e_type
)
2060 static char buff
[32];
2064 case ET_NONE
: return _("NONE (None)");
2065 case ET_REL
: return _("REL (Relocatable file)");
2066 case ET_EXEC
: return _("EXEC (Executable file)");
2067 case ET_DYN
: return _("DYN (Shared object file)");
2068 case ET_CORE
: return _("CORE (Core file)");
2071 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2072 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2073 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2074 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2076 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2082 get_machine_name (unsigned e_machine
)
2084 static char buff
[64]; /* XXX */
2088 case EM_NONE
: return _("None");
2089 case EM_AARCH64
: return "AArch64";
2090 case EM_M32
: return "WE32100";
2091 case EM_SPARC
: return "Sparc";
2092 case EM_SPU
: return "SPU";
2093 case EM_386
: return "Intel 80386";
2094 case EM_68K
: return "MC68000";
2095 case EM_88K
: return "MC88000";
2096 case EM_IAMCU
: return "Intel MCU";
2097 case EM_860
: return "Intel 80860";
2098 case EM_MIPS
: return "MIPS R3000";
2099 case EM_S370
: return "IBM System/370";
2100 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2101 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2102 case EM_PARISC
: return "HPPA";
2103 case EM_PPC_OLD
: return "Power PC (old)";
2104 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2105 case EM_960
: return "Intel 90860";
2106 case EM_PPC
: return "PowerPC";
2107 case EM_PPC64
: return "PowerPC64";
2108 case EM_FR20
: return "Fujitsu FR20";
2109 case EM_FT32
: return "FTDI FT32";
2110 case EM_RH32
: return "TRW RH32";
2111 case EM_MCORE
: return "MCORE";
2112 case EM_ARM
: return "ARM";
2113 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2114 case EM_SH
: return "Renesas / SuperH SH";
2115 case EM_SPARCV9
: return "Sparc v9";
2116 case EM_TRICORE
: return "Siemens Tricore";
2117 case EM_ARC
: return "ARC";
2118 case EM_H8_300
: return "Renesas H8/300";
2119 case EM_H8_300H
: return "Renesas H8/300H";
2120 case EM_H8S
: return "Renesas H8S";
2121 case EM_H8_500
: return "Renesas H8/500";
2122 case EM_IA_64
: return "Intel IA-64";
2123 case EM_MIPS_X
: return "Stanford MIPS-X";
2124 case EM_COLDFIRE
: return "Motorola Coldfire";
2125 case EM_ALPHA
: return "Alpha";
2126 case EM_CYGNUS_D10V
:
2127 case EM_D10V
: return "d10v";
2128 case EM_CYGNUS_D30V
:
2129 case EM_D30V
: return "d30v";
2130 case EM_CYGNUS_M32R
:
2131 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2132 case EM_CYGNUS_V850
:
2133 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2134 case EM_V850
: return "Renesas V850";
2135 case EM_CYGNUS_MN10300
:
2136 case EM_MN10300
: return "mn10300";
2137 case EM_CYGNUS_MN10200
:
2138 case EM_MN10200
: return "mn10200";
2139 case EM_MOXIE
: return "Moxie";
2140 case EM_CYGNUS_FR30
:
2141 case EM_FR30
: return "Fujitsu FR30";
2142 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2144 case EM_PJ
: return "picoJava";
2145 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2146 case EM_PCP
: return "Siemens PCP";
2147 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2148 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2149 case EM_STARCORE
: return "Motorola Star*Core processor";
2150 case EM_ME16
: return "Toyota ME16 processor";
2151 case EM_ST100
: return "STMicroelectronics ST100 processor";
2152 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2153 case EM_PDSP
: return "Sony DSP processor";
2154 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2155 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2156 case EM_FX66
: return "Siemens FX66 microcontroller";
2157 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2158 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2159 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2160 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2161 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2162 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2163 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2164 case EM_SVX
: return "Silicon Graphics SVx";
2165 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2166 case EM_VAX
: return "Digital VAX";
2167 case EM_VISIUM
: return "CDS VISIUMcore processor";
2169 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2170 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2171 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2172 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2173 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2174 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2175 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2176 case EM_PRISM
: return "Vitesse Prism";
2177 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2178 case EM_L1OM
: return "Intel L1OM";
2179 case EM_K1OM
: return "Intel K1OM";
2181 case EM_S390
: return "IBM S/390";
2182 case EM_SCORE
: return "SUNPLUS S+Core";
2183 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2184 case EM_OR1K
: return "OpenRISC 1000";
2185 case EM_ARC_A5
: return "ARC International ARCompact processor";
2186 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2187 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2188 case EM_DLX
: return "OpenDLX";
2190 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2191 case EM_IQ2000
: return "Vitesse IQ2000";
2193 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2194 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2195 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2196 case EM_NS32K
: return "National Semiconductor 32000 series";
2197 case EM_TPC
: return "Tenor Network TPC processor";
2198 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2199 case EM_MAX
: return "MAX Processor";
2200 case EM_CR
: return "National Semiconductor CompactRISC";
2201 case EM_F2MC16
: return "Fujitsu F2MC16";
2202 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2203 case EM_LATTICEMICO32
: return "Lattice Mico32";
2205 case EM_M32C
: return "Renesas M32c";
2206 case EM_MT
: return "Morpho Techologies MT processor";
2207 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2208 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2209 case EM_SEP
: return "Sharp embedded microprocessor";
2210 case EM_ARCA
: return "Arca RISC microprocessor";
2211 case EM_UNICORE
: return "Unicore";
2212 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2213 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2214 case EM_NIOS32
: return "Altera Nios";
2215 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2217 case EM_XC16X
: return "Infineon Technologies xc16x";
2218 case EM_M16C
: return "Renesas M16C series microprocessors";
2219 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2220 case EM_CE
: return "Freescale Communication Engine RISC core";
2221 case EM_TSK3000
: return "Altium TSK3000 core";
2222 case EM_RS08
: return "Freescale RS08 embedded processor";
2223 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2224 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2225 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2226 case EM_SE_C17
: return "Seiko Epson C17 family";
2227 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2228 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2229 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2230 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2231 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2232 case EM_R32C
: return "Renesas R32C series microprocessors";
2233 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2234 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2235 case EM_8051
: return "Intel 8051 and variants";
2236 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2237 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2238 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2239 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2240 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2241 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2242 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2243 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2246 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2247 case EM_RL78
: return "Renesas RL78";
2248 case EM_RX
: return "Renesas RX";
2249 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2250 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2251 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2252 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2253 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2254 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2255 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2256 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2257 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2258 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2259 case EM_CUDA
: return "NVIDIA CUDA architecture";
2260 case EM_XGATE
: return "Motorola XGATE embedded processor";
2262 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2268 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2273 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2274 e_flags
&= ~ EF_ARM_EABIMASK
;
2276 /* Handle "generic" ARM flags. */
2277 if (e_flags
& EF_ARM_RELEXEC
)
2279 strcat (buf
, ", relocatable executable");
2280 e_flags
&= ~ EF_ARM_RELEXEC
;
2283 /* Now handle EABI specific flags. */
2287 strcat (buf
, ", <unrecognized EABI>");
2292 case EF_ARM_EABI_VER1
:
2293 strcat (buf
, ", Version1 EABI");
2298 /* Process flags one bit at a time. */
2299 flag
= e_flags
& - e_flags
;
2304 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2305 strcat (buf
, ", sorted symbol tables");
2315 case EF_ARM_EABI_VER2
:
2316 strcat (buf
, ", Version2 EABI");
2321 /* Process flags one bit at a time. */
2322 flag
= e_flags
& - e_flags
;
2327 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf
, ", sorted symbol tables");
2331 case EF_ARM_DYNSYMSUSESEGIDX
:
2332 strcat (buf
, ", dynamic symbols use segment index");
2335 case EF_ARM_MAPSYMSFIRST
:
2336 strcat (buf
, ", mapping symbols precede others");
2346 case EF_ARM_EABI_VER3
:
2347 strcat (buf
, ", Version3 EABI");
2350 case EF_ARM_EABI_VER4
:
2351 strcat (buf
, ", Version4 EABI");
2356 /* Process flags one bit at a time. */
2357 flag
= e_flags
& - e_flags
;
2363 strcat (buf
, ", BE8");
2367 strcat (buf
, ", LE8");
2378 case EF_ARM_EABI_VER5
:
2379 strcat (buf
, ", Version5 EABI");
2384 /* Process flags one bit at a time. */
2385 flag
= e_flags
& - e_flags
;
2391 strcat (buf
, ", BE8");
2395 strcat (buf
, ", LE8");
2398 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf
, ", soft-float ABI");
2402 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf
, ", hard-float ABI");
2413 case EF_ARM_EABI_UNKNOWN
:
2414 strcat (buf
, ", GNU EABI");
2419 /* Process flags one bit at a time. */
2420 flag
= e_flags
& - e_flags
;
2425 case EF_ARM_INTERWORK
:
2426 strcat (buf
, ", interworking enabled");
2429 case EF_ARM_APCS_26
:
2430 strcat (buf
, ", uses APCS/26");
2433 case EF_ARM_APCS_FLOAT
:
2434 strcat (buf
, ", uses APCS/float");
2438 strcat (buf
, ", position independent");
2442 strcat (buf
, ", 8 bit structure alignment");
2445 case EF_ARM_NEW_ABI
:
2446 strcat (buf
, ", uses new ABI");
2449 case EF_ARM_OLD_ABI
:
2450 strcat (buf
, ", uses old ABI");
2453 case EF_ARM_SOFT_FLOAT
:
2454 strcat (buf
, ", software FP");
2457 case EF_ARM_VFP_FLOAT
:
2458 strcat (buf
, ", VFP");
2461 case EF_ARM_MAVERICK_FLOAT
:
2462 strcat (buf
, ", Maverick FP");
2473 strcat (buf
,_(", <unknown>"));
2477 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2479 --size
; /* Leave space for null terminator. */
2481 switch (e_flags
& EF_AVR_MACH
)
2483 case E_AVR_MACH_AVR1
:
2484 strncat (buf
, ", avr:1", size
);
2486 case E_AVR_MACH_AVR2
:
2487 strncat (buf
, ", avr:2", size
);
2489 case E_AVR_MACH_AVR25
:
2490 strncat (buf
, ", avr:25", size
);
2492 case E_AVR_MACH_AVR3
:
2493 strncat (buf
, ", avr:3", size
);
2495 case E_AVR_MACH_AVR31
:
2496 strncat (buf
, ", avr:31", size
);
2498 case E_AVR_MACH_AVR35
:
2499 strncat (buf
, ", avr:35", size
);
2501 case E_AVR_MACH_AVR4
:
2502 strncat (buf
, ", avr:4", size
);
2504 case E_AVR_MACH_AVR5
:
2505 strncat (buf
, ", avr:5", size
);
2507 case E_AVR_MACH_AVR51
:
2508 strncat (buf
, ", avr:51", size
);
2510 case E_AVR_MACH_AVR6
:
2511 strncat (buf
, ", avr:6", size
);
2513 case E_AVR_MACH_AVRTINY
:
2514 strncat (buf
, ", avr:100", size
);
2516 case E_AVR_MACH_XMEGA1
:
2517 strncat (buf
, ", avr:101", size
);
2519 case E_AVR_MACH_XMEGA2
:
2520 strncat (buf
, ", avr:102", size
);
2522 case E_AVR_MACH_XMEGA3
:
2523 strncat (buf
, ", avr:103", size
);
2525 case E_AVR_MACH_XMEGA4
:
2526 strncat (buf
, ", avr:104", size
);
2528 case E_AVR_MACH_XMEGA5
:
2529 strncat (buf
, ", avr:105", size
);
2531 case E_AVR_MACH_XMEGA6
:
2532 strncat (buf
, ", avr:106", size
);
2534 case E_AVR_MACH_XMEGA7
:
2535 strncat (buf
, ", avr:107", size
);
2538 strncat (buf
, ", avr:<unknown>", size
);
2542 size
-= strlen (buf
);
2543 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2544 strncat (buf
, ", link-relax", size
);
2548 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2557 static const char *ABI_STRINGS
[] =
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
2566 static const char *VER_STRINGS
[] =
2568 "Andes ELF V1.3 or older",
2572 static const char *ARCH_STRINGS
[] =
2581 abi
= EF_NDS_ABI
& e_flags
;
2582 arch
= EF_NDS_ARCH
& e_flags
;
2583 config
= EF_NDS_INST
& e_flags
;
2584 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2586 memset (buf
, 0, size
);
2593 case E_NDS_ABI_V2FP
:
2594 case E_NDS_ABI_AABI
:
2595 case E_NDS_ABI_V2FP_PLUS
:
2596 /* In case there are holes in the array. */
2597 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2601 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2607 case E_NDS32_ELF_VER_1_2
:
2608 case E_NDS32_ELF_VER_1_3
:
2609 case E_NDS32_ELF_VER_1_4
:
2610 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2614 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2618 if (E_NDS_ABI_V0
== abi
)
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2623 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2629 case E_NDS_ARCH_STAR_V1_0
:
2630 case E_NDS_ARCH_STAR_V2_0
:
2631 case E_NDS_ARCH_STAR_V3_0
:
2632 case E_NDS_ARCH_STAR_V3_M
:
2633 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2637 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2646 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2647 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2649 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2650 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2652 if (config
& E_NDS32_HAS_DIV_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2655 if (config
& E_NDS32_HAS_16BIT_INST
)
2656 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2660 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2662 if (version
<= E_NDS32_ELF_VER_1_3
)
2663 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2665 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2668 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2671 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2672 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2674 if (config
& E_NDS32_HAS_16BIT_INST
)
2676 if (version
<= E_NDS32_ELF_VER_1_3
)
2677 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2679 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2683 if (config
& E_NDS32_HAS_EXT_INST
)
2684 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2686 if (config
& E_NDS32_HAS_EXT2_INST
)
2687 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2689 if (config
& E_NDS32_HAS_FPU_INST
)
2692 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2695 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2701 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2709 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2711 case E_NDS32_FPU_REG_8SP_4DP
:
2712 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2714 case E_NDS32_FPU_REG_16SP_8DP
:
2715 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2717 case E_NDS32_FPU_REG_32SP_16DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2720 case E_NDS32_FPU_REG_32SP_32DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2726 if (config
& E_NDS32_HAS_AUDIO_INST
)
2727 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2729 if (config
& E_NDS32_HAS_STRING_INST
)
2730 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2732 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2735 if (config
& E_NDS32_HAS_VIDEO_INST
)
2737 if (version
<= E_NDS32_ELF_VER_1_3
)
2738 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2740 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2743 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2746 if (config
& E_NDS32_HAS_L2C_INST
)
2747 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2751 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2753 static char buf
[1024];
2765 decode_ARM_machine_flags (e_flags
, buf
);
2769 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2773 if (e_flags
& EF_BFIN_PIC
)
2774 strcat (buf
, ", PIC");
2776 if (e_flags
& EF_BFIN_FDPIC
)
2777 strcat (buf
, ", FDPIC");
2779 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2780 strcat (buf
, ", code in L1");
2782 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2783 strcat (buf
, ", data in L1");
2788 switch (e_flags
& EF_FRV_CPU_MASK
)
2790 case EF_FRV_CPU_GENERIC
:
2794 strcat (buf
, ", fr???");
2797 case EF_FRV_CPU_FR300
:
2798 strcat (buf
, ", fr300");
2801 case EF_FRV_CPU_FR400
:
2802 strcat (buf
, ", fr400");
2804 case EF_FRV_CPU_FR405
:
2805 strcat (buf
, ", fr405");
2808 case EF_FRV_CPU_FR450
:
2809 strcat (buf
, ", fr450");
2812 case EF_FRV_CPU_FR500
:
2813 strcat (buf
, ", fr500");
2815 case EF_FRV_CPU_FR550
:
2816 strcat (buf
, ", fr550");
2819 case EF_FRV_CPU_SIMPLE
:
2820 strcat (buf
, ", simple");
2822 case EF_FRV_CPU_TOMCAT
:
2823 strcat (buf
, ", tomcat");
2829 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2830 strcat (buf
, ", m68000");
2831 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2832 strcat (buf
, ", cpu32");
2833 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2834 strcat (buf
, ", fido_a");
2837 char const * isa
= _("unknown");
2838 char const * mac
= _("unknown mac");
2839 char const * additional
= NULL
;
2841 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2843 case EF_M68K_CF_ISA_A_NODIV
:
2845 additional
= ", nodiv";
2847 case EF_M68K_CF_ISA_A
:
2850 case EF_M68K_CF_ISA_A_PLUS
:
2853 case EF_M68K_CF_ISA_B_NOUSP
:
2855 additional
= ", nousp";
2857 case EF_M68K_CF_ISA_B
:
2860 case EF_M68K_CF_ISA_C
:
2863 case EF_M68K_CF_ISA_C_NODIV
:
2865 additional
= ", nodiv";
2868 strcat (buf
, ", cf, isa ");
2871 strcat (buf
, additional
);
2872 if (e_flags
& EF_M68K_CF_FLOAT
)
2873 strcat (buf
, ", float");
2874 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2879 case EF_M68K_CF_MAC
:
2882 case EF_M68K_CF_EMAC
:
2885 case EF_M68K_CF_EMAC_B
:
2898 switch (e_flags
& EF_MEP_CPU_MASK
)
2900 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2901 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2902 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2903 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2904 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2905 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2906 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2909 switch (e_flags
& EF_MEP_COP_MASK
)
2911 case EF_MEP_COP_NONE
: break;
2912 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2913 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2914 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
2915 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
2916 default: strcat (buf
, _("<unknown MeP copro type>")); break;
2919 if (e_flags
& EF_MEP_LIBRARY
)
2920 strcat (buf
, ", Built for Library");
2922 if (e_flags
& EF_MEP_INDEX_MASK
)
2923 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
2924 e_flags
& EF_MEP_INDEX_MASK
);
2926 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
2927 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
2928 e_flags
& ~ EF_MEP_ALL_FLAGS
);
2932 if (e_flags
& EF_PPC_EMB
)
2933 strcat (buf
, ", emb");
2935 if (e_flags
& EF_PPC_RELOCATABLE
)
2936 strcat (buf
, _(", relocatable"));
2938 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2939 strcat (buf
, _(", relocatable-lib"));
2943 if (e_flags
& EF_PPC64_ABI
)
2945 char abi
[] = ", abiv0";
2947 abi
[6] += e_flags
& EF_PPC64_ABI
;
2953 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2954 strcat (buf
, ", RH850 ABI");
2956 if (e_flags
& EF_V800_850E3
)
2957 strcat (buf
, ", V3 architecture");
2959 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2960 strcat (buf
, ", FPU not used");
2962 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2963 strcat (buf
, ", regmode: COMMON");
2965 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2966 strcat (buf
, ", r4 not used");
2968 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2969 strcat (buf
, ", r30 not used");
2971 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2972 strcat (buf
, ", r5 not used");
2974 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2975 strcat (buf
, ", r2 not used");
2977 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2979 switch (e_flags
& - e_flags
)
2981 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2982 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2983 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2984 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2985 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2986 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2987 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2988 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2989 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2990 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2991 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2992 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2999 case EM_CYGNUS_V850
:
3000 switch (e_flags
& EF_V850_ARCH
)
3002 case E_V850E3V5_ARCH
:
3003 strcat (buf
, ", v850e3v5");
3005 case E_V850E2V3_ARCH
:
3006 strcat (buf
, ", v850e2v3");
3009 strcat (buf
, ", v850e2");
3012 strcat (buf
, ", v850e1");
3015 strcat (buf
, ", v850e");
3018 strcat (buf
, ", v850");
3021 strcat (buf
, _(", unknown v850 architecture variant"));
3027 case EM_CYGNUS_M32R
:
3028 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3029 strcat (buf
, ", m32r");
3033 case EM_MIPS_RS3_LE
:
3034 if (e_flags
& EF_MIPS_NOREORDER
)
3035 strcat (buf
, ", noreorder");
3037 if (e_flags
& EF_MIPS_PIC
)
3038 strcat (buf
, ", pic");
3040 if (e_flags
& EF_MIPS_CPIC
)
3041 strcat (buf
, ", cpic");
3043 if (e_flags
& EF_MIPS_UCODE
)
3044 strcat (buf
, ", ugen_reserved");
3046 if (e_flags
& EF_MIPS_ABI2
)
3047 strcat (buf
, ", abi2");
3049 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3050 strcat (buf
, ", odk first");
3052 if (e_flags
& EF_MIPS_32BITMODE
)
3053 strcat (buf
, ", 32bitmode");
3055 if (e_flags
& EF_MIPS_NAN2008
)
3056 strcat (buf
, ", nan2008");
3058 if (e_flags
& EF_MIPS_FP64
)
3059 strcat (buf
, ", fp64");
3061 switch ((e_flags
& EF_MIPS_MACH
))
3063 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3064 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3065 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3066 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3067 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3068 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3069 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3070 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3071 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3072 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3073 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3074 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3075 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3076 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3077 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3078 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3079 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3081 /* We simply ignore the field in this case to avoid confusion:
3082 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3085 default: strcat (buf
, _(", unknown CPU")); break;
3088 switch ((e_flags
& EF_MIPS_ABI
))
3090 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3091 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3092 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3093 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3095 /* We simply ignore the field in this case to avoid confusion:
3096 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3097 This means it is likely to be an o32 file, but not for
3100 default: strcat (buf
, _(", unknown ABI")); break;
3103 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3104 strcat (buf
, ", mdmx");
3106 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3107 strcat (buf
, ", mips16");
3109 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3110 strcat (buf
, ", micromips");
3112 switch ((e_flags
& EF_MIPS_ARCH
))
3114 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3115 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3116 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3117 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3118 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3119 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3120 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3121 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3122 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3123 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3124 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3125 default: strcat (buf
, _(", unknown ISA")); break;
3130 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3134 switch ((e_flags
& EF_SH_MACH_MASK
))
3136 case EF_SH1
: strcat (buf
, ", sh1"); break;
3137 case EF_SH2
: strcat (buf
, ", sh2"); break;
3138 case EF_SH3
: strcat (buf
, ", sh3"); break;
3139 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3140 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3141 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3142 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3143 case EF_SH4
: strcat (buf
, ", sh4"); break;
3144 case EF_SH5
: strcat (buf
, ", sh5"); break;
3145 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3146 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3147 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3148 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3149 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3150 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3151 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3152 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3153 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3154 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3155 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3156 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3157 default: strcat (buf
, _(", unknown ISA")); break;
3160 if (e_flags
& EF_SH_PIC
)
3161 strcat (buf
, ", pic");
3163 if (e_flags
& EF_SH_FDPIC
)
3164 strcat (buf
, ", fdpic");
3168 if (e_flags
& EF_OR1K_NODELAY
)
3169 strcat (buf
, ", no delay");
3173 if (e_flags
& EF_SPARC_32PLUS
)
3174 strcat (buf
, ", v8+");
3176 if (e_flags
& EF_SPARC_SUN_US1
)
3177 strcat (buf
, ", ultrasparcI");
3179 if (e_flags
& EF_SPARC_SUN_US3
)
3180 strcat (buf
, ", ultrasparcIII");
3182 if (e_flags
& EF_SPARC_HAL_R1
)
3183 strcat (buf
, ", halr1");
3185 if (e_flags
& EF_SPARC_LEDATA
)
3186 strcat (buf
, ", ledata");
3188 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3189 strcat (buf
, ", tso");
3191 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3192 strcat (buf
, ", pso");
3194 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3195 strcat (buf
, ", rmo");
3199 switch (e_flags
& EF_PARISC_ARCH
)
3201 case EFA_PARISC_1_0
:
3202 strcpy (buf
, ", PA-RISC 1.0");
3204 case EFA_PARISC_1_1
:
3205 strcpy (buf
, ", PA-RISC 1.1");
3207 case EFA_PARISC_2_0
:
3208 strcpy (buf
, ", PA-RISC 2.0");
3213 if (e_flags
& EF_PARISC_TRAPNIL
)
3214 strcat (buf
, ", trapnil");
3215 if (e_flags
& EF_PARISC_EXT
)
3216 strcat (buf
, ", ext");
3217 if (e_flags
& EF_PARISC_LSB
)
3218 strcat (buf
, ", lsb");
3219 if (e_flags
& EF_PARISC_WIDE
)
3220 strcat (buf
, ", wide");
3221 if (e_flags
& EF_PARISC_NO_KABP
)
3222 strcat (buf
, ", no kabp");
3223 if (e_flags
& EF_PARISC_LAZYSWAP
)
3224 strcat (buf
, ", lazyswap");
3229 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3230 strcat (buf
, ", new calling convention");
3232 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3233 strcat (buf
, ", gnu calling convention");
3237 if ((e_flags
& EF_IA_64_ABI64
))
3238 strcat (buf
, ", 64-bit");
3240 strcat (buf
, ", 32-bit");
3241 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3242 strcat (buf
, ", reduced fp model");
3243 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3244 strcat (buf
, ", no function descriptors, constant gp");
3245 else if ((e_flags
& EF_IA_64_CONS_GP
))
3246 strcat (buf
, ", constant gp");
3247 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3248 strcat (buf
, ", absolute");
3249 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3251 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3252 strcat (buf
, ", vms_linkages");
3253 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3255 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3257 case EF_IA_64_VMS_COMCOD_WARNING
:
3258 strcat (buf
, ", warning");
3260 case EF_IA_64_VMS_COMCOD_ERROR
:
3261 strcat (buf
, ", error");
3263 case EF_IA_64_VMS_COMCOD_ABORT
:
3264 strcat (buf
, ", abort");
3267 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3268 e_flags
& EF_IA_64_VMS_COMCOD
);
3269 strcat (buf
, ", <unknown>");
3275 if ((e_flags
& EF_VAX_NONPIC
))
3276 strcat (buf
, ", non-PIC");
3277 if ((e_flags
& EF_VAX_DFLOAT
))
3278 strcat (buf
, ", D-Float");
3279 if ((e_flags
& EF_VAX_GFLOAT
))
3280 strcat (buf
, ", G-Float");
3284 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3285 strcat (buf
, ", mcm");
3286 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3287 strcat (buf
, ", mcm24");
3288 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3289 strcat (buf
, ", gr6");
3293 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3295 case E_FLAG_RL78_ANY_CPU
: break;
3296 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3297 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3298 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3300 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3301 strcat (buf
, ", 64-bit doubles");
3305 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3306 strcat (buf
, ", 64-bit doubles");
3307 if (e_flags
& E_FLAG_RX_DSP
)
3308 strcat (buf
, ", dsp");
3309 if (e_flags
& E_FLAG_RX_PID
)
3310 strcat (buf
, ", pid");
3311 if (e_flags
& E_FLAG_RX_ABI
)
3312 strcat (buf
, ", RX ABI");
3313 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3314 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3315 ? ", uses String instructions" : ", bans String instructions");
3319 if (e_flags
& EF_S390_HIGH_GPRS
)
3320 strcat (buf
, ", highgprs");
3324 if ((e_flags
& EF_C6000_REL
))
3325 strcat (buf
, ", relocatable module");
3329 strcat (buf
, _(": architecture variant: "));
3330 switch (e_flags
& EF_MSP430_MACH
)
3332 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3333 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3334 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3335 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3336 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3337 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3338 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3339 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3340 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3341 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3342 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3343 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3344 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3345 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3346 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3348 strcat (buf
, _(": unknown")); break;
3351 if (e_flags
& ~ EF_MSP430_MACH
)
3352 strcat (buf
, _(": unknown extra flag bits also present"));
3360 get_osabi_name (unsigned int osabi
)
3362 static char buff
[32];
3366 case ELFOSABI_NONE
: return "UNIX - System V";
3367 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3368 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3369 case ELFOSABI_GNU
: return "UNIX - GNU";
3370 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3371 case ELFOSABI_AIX
: return "UNIX - AIX";
3372 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3373 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3374 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3375 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3376 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3377 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3378 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3379 case ELFOSABI_AROS
: return "AROS";
3380 case ELFOSABI_FENIXOS
: return "FenixOS";
3383 switch (elf_header
.e_machine
)
3388 case ELFOSABI_ARM
: return "ARM";
3399 case ELFOSABI_STANDALONE
: return _("Standalone App");
3408 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3409 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3418 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3424 get_aarch64_segment_type (unsigned long type
)
3428 case PT_AARCH64_ARCHEXT
:
3429 return "AARCH64_ARCHEXT";
3438 get_arm_segment_type (unsigned long type
)
3452 get_mips_segment_type (unsigned long type
)
3456 case PT_MIPS_REGINFO
:
3458 case PT_MIPS_RTPROC
:
3460 case PT_MIPS_OPTIONS
:
3462 case PT_MIPS_ABIFLAGS
:
3472 get_parisc_segment_type (unsigned long type
)
3476 case PT_HP_TLS
: return "HP_TLS";
3477 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3478 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3479 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3480 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3481 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3482 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3483 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3484 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3485 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3486 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3487 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3488 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3489 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3490 case PT_HP_STACK
: return "HP_STACK";
3491 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3492 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3493 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3494 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3503 get_ia64_segment_type (unsigned long type
)
3507 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3508 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3509 case PT_HP_TLS
: return "HP_TLS";
3510 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3511 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3512 case PT_IA_64_HP_STACK
: return "HP_STACK";
3521 get_tic6x_segment_type (unsigned long type
)
3525 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3534 get_segment_type (unsigned long p_type
)
3536 static char buff
[32];
3540 case PT_NULL
: return "NULL";
3541 case PT_LOAD
: return "LOAD";
3542 case PT_DYNAMIC
: return "DYNAMIC";
3543 case PT_INTERP
: return "INTERP";
3544 case PT_NOTE
: return "NOTE";
3545 case PT_SHLIB
: return "SHLIB";
3546 case PT_PHDR
: return "PHDR";
3547 case PT_TLS
: return "TLS";
3549 case PT_GNU_EH_FRAME
:
3550 return "GNU_EH_FRAME";
3551 case PT_GNU_STACK
: return "GNU_STACK";
3552 case PT_GNU_RELRO
: return "GNU_RELRO";
3555 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3557 const char * result
;
3559 switch (elf_header
.e_machine
)
3562 result
= get_aarch64_segment_type (p_type
);
3565 result
= get_arm_segment_type (p_type
);
3568 case EM_MIPS_RS3_LE
:
3569 result
= get_mips_segment_type (p_type
);
3572 result
= get_parisc_segment_type (p_type
);
3575 result
= get_ia64_segment_type (p_type
);
3578 result
= get_tic6x_segment_type (p_type
);
3588 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3590 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3592 const char * result
;
3594 switch (elf_header
.e_machine
)
3597 result
= get_parisc_segment_type (p_type
);
3600 result
= get_ia64_segment_type (p_type
);
3610 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3613 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3620 get_mips_section_type_name (unsigned int sh_type
)
3624 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3625 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3626 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3627 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3628 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3629 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3630 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3631 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3632 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3633 case SHT_MIPS_RELD
: return "MIPS_RELD";
3634 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3635 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3636 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3637 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3638 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3639 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3640 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3641 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3642 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3643 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3644 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3645 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3646 case SHT_MIPS_LINE
: return "MIPS_LINE";
3647 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3648 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3649 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3650 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3651 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3652 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3653 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3654 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3655 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3656 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3657 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3658 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3659 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3660 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3661 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3662 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3663 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3671 get_parisc_section_type_name (unsigned int sh_type
)
3675 case SHT_PARISC_EXT
: return "PARISC_EXT";
3676 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3677 case SHT_PARISC_DOC
: return "PARISC_DOC";
3678 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3679 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3680 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3681 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3689 get_ia64_section_type_name (unsigned int sh_type
)
3691 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3692 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3693 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3697 case SHT_IA_64_EXT
: return "IA_64_EXT";
3698 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3699 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3700 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3701 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3702 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3703 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3704 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3705 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3706 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3714 get_x86_64_section_type_name (unsigned int sh_type
)
3718 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3726 get_aarch64_section_type_name (unsigned int sh_type
)
3730 case SHT_AARCH64_ATTRIBUTES
:
3731 return "AARCH64_ATTRIBUTES";
3739 get_arm_section_type_name (unsigned int sh_type
)
3743 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3744 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3745 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3746 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3747 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3755 get_tic6x_section_type_name (unsigned int sh_type
)
3759 case SHT_C6000_UNWIND
:
3760 return "C6000_UNWIND";
3761 case SHT_C6000_PREEMPTMAP
:
3762 return "C6000_PREEMPTMAP";
3763 case SHT_C6000_ATTRIBUTES
:
3764 return "C6000_ATTRIBUTES";
3769 case SHT_TI_HANDLER
:
3770 return "TI_HANDLER";
3771 case SHT_TI_INITINFO
:
3772 return "TI_INITINFO";
3773 case SHT_TI_PHATTRS
:
3774 return "TI_PHATTRS";
3782 get_msp430x_section_type_name (unsigned int sh_type
)
3786 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3787 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3788 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3789 default: return NULL
;
3794 get_v850_section_type_name (unsigned int sh_type
)
3798 case SHT_V850_SCOMMON
: return "V850 Small Common";
3799 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3800 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3801 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3802 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3803 default: return NULL
;
3808 get_section_type_name (unsigned int sh_type
)
3810 static char buff
[32];
3814 case SHT_NULL
: return "NULL";
3815 case SHT_PROGBITS
: return "PROGBITS";
3816 case SHT_SYMTAB
: return "SYMTAB";
3817 case SHT_STRTAB
: return "STRTAB";
3818 case SHT_RELA
: return "RELA";
3819 case SHT_HASH
: return "HASH";
3820 case SHT_DYNAMIC
: return "DYNAMIC";
3821 case SHT_NOTE
: return "NOTE";
3822 case SHT_NOBITS
: return "NOBITS";
3823 case SHT_REL
: return "REL";
3824 case SHT_SHLIB
: return "SHLIB";
3825 case SHT_DYNSYM
: return "DYNSYM";
3826 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3827 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3828 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3829 case SHT_GNU_HASH
: return "GNU_HASH";
3830 case SHT_GROUP
: return "GROUP";
3831 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3832 case SHT_GNU_verdef
: return "VERDEF";
3833 case SHT_GNU_verneed
: return "VERNEED";
3834 case SHT_GNU_versym
: return "VERSYM";
3835 case 0x6ffffff0: return "VERSYM";
3836 case 0x6ffffffc: return "VERDEF";
3837 case 0x7ffffffd: return "AUXILIARY";
3838 case 0x7fffffff: return "FILTER";
3839 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3842 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3844 const char * result
;
3846 switch (elf_header
.e_machine
)
3849 case EM_MIPS_RS3_LE
:
3850 result
= get_mips_section_type_name (sh_type
);
3853 result
= get_parisc_section_type_name (sh_type
);
3856 result
= get_ia64_section_type_name (sh_type
);
3861 result
= get_x86_64_section_type_name (sh_type
);
3864 result
= get_aarch64_section_type_name (sh_type
);
3867 result
= get_arm_section_type_name (sh_type
);
3870 result
= get_tic6x_section_type_name (sh_type
);
3873 result
= get_msp430x_section_type_name (sh_type
);
3877 case EM_CYGNUS_V850
:
3878 result
= get_v850_section_type_name (sh_type
);
3888 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3890 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3892 const char * result
;
3894 switch (elf_header
.e_machine
)
3897 result
= get_ia64_section_type_name (sh_type
);
3907 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3909 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3911 switch (elf_header
.e_machine
)
3915 case EM_CYGNUS_V850
:
3916 return get_v850_section_type_name (sh_type
);
3921 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3924 /* This message is probably going to be displayed in a 15
3925 character wide field, so put the hex value first. */
3926 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3932 #define OPTION_DEBUG_DUMP 512
3933 #define OPTION_DYN_SYMS 513
3934 #define OPTION_DWARF_DEPTH 514
3935 #define OPTION_DWARF_START 515
3936 #define OPTION_DWARF_CHECK 516
3938 static struct option options
[] =
3940 {"all", no_argument
, 0, 'a'},
3941 {"file-header", no_argument
, 0, 'h'},
3942 {"program-headers", no_argument
, 0, 'l'},
3943 {"headers", no_argument
, 0, 'e'},
3944 {"histogram", no_argument
, 0, 'I'},
3945 {"segments", no_argument
, 0, 'l'},
3946 {"sections", no_argument
, 0, 'S'},
3947 {"section-headers", no_argument
, 0, 'S'},
3948 {"section-groups", no_argument
, 0, 'g'},
3949 {"section-details", no_argument
, 0, 't'},
3950 {"full-section-name",no_argument
, 0, 'N'},
3951 {"symbols", no_argument
, 0, 's'},
3952 {"syms", no_argument
, 0, 's'},
3953 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3954 {"relocs", no_argument
, 0, 'r'},
3955 {"notes", no_argument
, 0, 'n'},
3956 {"dynamic", no_argument
, 0, 'd'},
3957 {"arch-specific", no_argument
, 0, 'A'},
3958 {"version-info", no_argument
, 0, 'V'},
3959 {"use-dynamic", no_argument
, 0, 'D'},
3960 {"unwind", no_argument
, 0, 'u'},
3961 {"archive-index", no_argument
, 0, 'c'},
3962 {"hex-dump", required_argument
, 0, 'x'},
3963 {"relocated-dump", required_argument
, 0, 'R'},
3964 {"string-dump", required_argument
, 0, 'p'},
3965 {"decompress", no_argument
, 0, 'z'},
3966 #ifdef SUPPORT_DISASSEMBLY
3967 {"instruction-dump", required_argument
, 0, 'i'},
3969 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3971 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3972 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3973 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3975 {"version", no_argument
, 0, 'v'},
3976 {"wide", no_argument
, 0, 'W'},
3977 {"help", no_argument
, 0, 'H'},
3978 {0, no_argument
, 0, 0}
3982 usage (FILE * stream
)
3984 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3985 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3986 fprintf (stream
, _(" Options are:\n\
3987 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3988 -h --file-header Display the ELF file header\n\
3989 -l --program-headers Display the program headers\n\
3990 --segments An alias for --program-headers\n\
3991 -S --section-headers Display the sections' header\n\
3992 --sections An alias for --section-headers\n\
3993 -g --section-groups Display the section groups\n\
3994 -t --section-details Display the section details\n\
3995 -e --headers Equivalent to: -h -l -S\n\
3996 -s --syms Display the symbol table\n\
3997 --symbols An alias for --syms\n\
3998 --dyn-syms Display the dynamic symbol table\n\
3999 -n --notes Display the core notes (if present)\n\
4000 -r --relocs Display the relocations (if present)\n\
4001 -u --unwind Display the unwind info (if present)\n\
4002 -d --dynamic Display the dynamic section (if present)\n\
4003 -V --version-info Display the version sections (if present)\n\
4004 -A --arch-specific Display architecture specific information (if any)\n\
4005 -c --archive-index Display the symbol/file index in an archive\n\
4006 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4007 -x --hex-dump=<number|name>\n\
4008 Dump the contents of section <number|name> as bytes\n\
4009 -p --string-dump=<number|name>\n\
4010 Dump the contents of section <number|name> as strings\n\
4011 -R --relocated-dump=<number|name>\n\
4012 Dump the contents of section <number|name> as relocated bytes\n\
4013 -z --decompress Decompress section before dumping it\n\
4014 -w[lLiaprmfFsoRt] or\n\
4015 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4016 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4017 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4019 Display the contents of DWARF2 debug sections\n"));
4020 fprintf (stream
, _("\
4021 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4022 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4024 #ifdef SUPPORT_DISASSEMBLY
4025 fprintf (stream
, _("\
4026 -i --instruction-dump=<number|name>\n\
4027 Disassemble the contents of section <number|name>\n"));
4029 fprintf (stream
, _("\
4030 -I --histogram Display histogram of bucket list lengths\n\
4031 -W --wide Allow output width to exceed 80 characters\n\
4032 @<file> Read options from <file>\n\
4033 -H --help Display this information\n\
4034 -v --version Display the version number of readelf\n"));
4036 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4037 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4039 exit (stream
== stdout
? 0 : 1);
4042 /* Record the fact that the user wants the contents of section number
4043 SECTION to be displayed using the method(s) encoded as flags bits
4044 in TYPE. Note, TYPE can be zero if we are creating the array for
4048 request_dump_bynumber (unsigned int section
, dump_type type
)
4050 if (section
>= num_dump_sects
)
4052 dump_type
* new_dump_sects
;
4054 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4055 sizeof (* dump_sects
));
4057 if (new_dump_sects
== NULL
)
4058 error (_("Out of memory allocating dump request table.\n"));
4061 /* Copy current flag settings. */
4062 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4066 dump_sects
= new_dump_sects
;
4067 num_dump_sects
= section
+ 1;
4072 dump_sects
[section
] |= type
;
4077 /* Request a dump by section name. */
4080 request_dump_byname (const char * section
, dump_type type
)
4082 struct dump_list_entry
* new_request
;
4084 new_request
= (struct dump_list_entry
*)
4085 malloc (sizeof (struct dump_list_entry
));
4087 error (_("Out of memory allocating dump request table.\n"));
4089 new_request
->name
= strdup (section
);
4090 if (!new_request
->name
)
4091 error (_("Out of memory allocating dump request table.\n"));
4093 new_request
->type
= type
;
4095 new_request
->next
= dump_sects_byname
;
4096 dump_sects_byname
= new_request
;
4100 request_dump (dump_type type
)
4106 section
= strtoul (optarg
, & cp
, 0);
4108 if (! *cp
&& section
>= 0)
4109 request_dump_bynumber (section
, type
);
4111 request_dump_byname (optarg
, type
);
4116 parse_args (int argc
, char ** argv
)
4123 while ((c
= getopt_long
4124 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4142 do_section_groups
++;
4150 do_section_groups
++;
4155 do_section_details
++;
4199 request_dump (HEX_DUMP
);
4202 request_dump (STRING_DUMP
);
4205 request_dump (RELOC_DUMP
);
4215 dwarf_select_sections_all ();
4220 dwarf_select_sections_by_letters (optarg
);
4223 case OPTION_DEBUG_DUMP
:
4230 dwarf_select_sections_by_names (optarg
);
4233 case OPTION_DWARF_DEPTH
:
4237 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4240 case OPTION_DWARF_START
:
4244 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4247 case OPTION_DWARF_CHECK
:
4250 case OPTION_DYN_SYMS
:
4253 #ifdef SUPPORT_DISASSEMBLY
4255 request_dump (DISASS_DUMP
);
4259 print_version (program_name
);
4268 /* xgettext:c-format */
4269 error (_("Invalid option '-%c'\n"), c
);
4276 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4277 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4278 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4279 && !do_section_groups
&& !do_archive_index
4285 get_elf_class (unsigned int elf_class
)
4287 static char buff
[32];
4291 case ELFCLASSNONE
: return _("none");
4292 case ELFCLASS32
: return "ELF32";
4293 case ELFCLASS64
: return "ELF64";
4295 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4301 get_data_encoding (unsigned int encoding
)
4303 static char buff
[32];
4307 case ELFDATANONE
: return _("none");
4308 case ELFDATA2LSB
: return _("2's complement, little endian");
4309 case ELFDATA2MSB
: return _("2's complement, big endian");
4311 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4316 /* Decode the data held in 'elf_header'. */
4319 process_file_header (void)
4321 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4322 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4323 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4324 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4327 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4331 init_dwarf_regnames (elf_header
.e_machine
);
4337 printf (_("ELF Header:\n"));
4338 printf (_(" Magic: "));
4339 for (i
= 0; i
< EI_NIDENT
; i
++)
4340 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4342 printf (_(" Class: %s\n"),
4343 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4344 printf (_(" Data: %s\n"),
4345 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4346 printf (_(" Version: %d %s\n"),
4347 elf_header
.e_ident
[EI_VERSION
],
4348 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4350 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4351 ? _("<unknown: %lx>")
4353 printf (_(" OS/ABI: %s\n"),
4354 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4355 printf (_(" ABI Version: %d\n"),
4356 elf_header
.e_ident
[EI_ABIVERSION
]);
4357 printf (_(" Type: %s\n"),
4358 get_file_type (elf_header
.e_type
));
4359 printf (_(" Machine: %s\n"),
4360 get_machine_name (elf_header
.e_machine
));
4361 printf (_(" Version: 0x%lx\n"),
4362 (unsigned long) elf_header
.e_version
);
4364 printf (_(" Entry point address: "));
4365 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4366 printf (_("\n Start of program headers: "));
4367 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4368 printf (_(" (bytes into file)\n Start of section headers: "));
4369 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4370 printf (_(" (bytes into file)\n"));
4372 printf (_(" Flags: 0x%lx%s\n"),
4373 (unsigned long) elf_header
.e_flags
,
4374 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4375 printf (_(" Size of this header: %ld (bytes)\n"),
4376 (long) elf_header
.e_ehsize
);
4377 printf (_(" Size of program headers: %ld (bytes)\n"),
4378 (long) elf_header
.e_phentsize
);
4379 printf (_(" Number of program headers: %ld"),
4380 (long) elf_header
.e_phnum
);
4381 if (section_headers
!= NULL
4382 && elf_header
.e_phnum
== PN_XNUM
4383 && section_headers
[0].sh_info
!= 0)
4384 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4385 putc ('\n', stdout
);
4386 printf (_(" Size of section headers: %ld (bytes)\n"),
4387 (long) elf_header
.e_shentsize
);
4388 printf (_(" Number of section headers: %ld"),
4389 (long) elf_header
.e_shnum
);
4390 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4391 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4392 putc ('\n', stdout
);
4393 printf (_(" Section header string table index: %ld"),
4394 (long) elf_header
.e_shstrndx
);
4395 if (section_headers
!= NULL
4396 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4397 printf (" (%u)", section_headers
[0].sh_link
);
4398 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4399 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4400 printf (_(" <corrupt: out of range>"));
4401 putc ('\n', stdout
);
4404 if (section_headers
!= NULL
)
4406 if (elf_header
.e_phnum
== PN_XNUM
4407 && section_headers
[0].sh_info
!= 0)
4408 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4409 if (elf_header
.e_shnum
== SHN_UNDEF
)
4410 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4411 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4412 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4413 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4414 elf_header
.e_shstrndx
= SHN_UNDEF
;
4415 free (section_headers
);
4416 section_headers
= NULL
;
4423 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4425 Elf32_External_Phdr
* phdrs
;
4426 Elf32_External_Phdr
* external
;
4427 Elf_Internal_Phdr
* internal
;
4429 unsigned int size
= elf_header
.e_phentsize
;
4430 unsigned int num
= elf_header
.e_phnum
;
4432 /* PR binutils/17531: Cope with unexpected section header sizes. */
4433 if (size
== 0 || num
== 0)
4435 if (size
< sizeof * phdrs
)
4437 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4440 if (size
> sizeof * phdrs
)
4441 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4443 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4444 size
, num
, _("program headers"));
4448 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4449 i
< elf_header
.e_phnum
;
4450 i
++, internal
++, external
++)
4452 internal
->p_type
= BYTE_GET (external
->p_type
);
4453 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4454 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4455 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4456 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4457 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4458 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4459 internal
->p_align
= BYTE_GET (external
->p_align
);
4467 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4469 Elf64_External_Phdr
* phdrs
;
4470 Elf64_External_Phdr
* external
;
4471 Elf_Internal_Phdr
* internal
;
4473 unsigned int size
= elf_header
.e_phentsize
;
4474 unsigned int num
= elf_header
.e_phnum
;
4476 /* PR binutils/17531: Cope with unexpected section header sizes. */
4477 if (size
== 0 || num
== 0)
4479 if (size
< sizeof * phdrs
)
4481 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4484 if (size
> sizeof * phdrs
)
4485 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4487 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4488 size
, num
, _("program headers"));
4492 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4493 i
< elf_header
.e_phnum
;
4494 i
++, internal
++, external
++)
4496 internal
->p_type
= BYTE_GET (external
->p_type
);
4497 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4498 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4499 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4500 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4501 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4502 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4503 internal
->p_align
= BYTE_GET (external
->p_align
);
4510 /* Returns 1 if the program headers were read into `program_headers'. */
4513 get_program_headers (FILE * file
)
4515 Elf_Internal_Phdr
* phdrs
;
4517 /* Check cache of prior read. */
4518 if (program_headers
!= NULL
)
4521 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4522 sizeof (Elf_Internal_Phdr
));
4526 error (_("Out of memory reading %u program headers\n"),
4527 elf_header
.e_phnum
);
4532 ? get_32bit_program_headers (file
, phdrs
)
4533 : get_64bit_program_headers (file
, phdrs
))
4535 program_headers
= phdrs
;
4543 /* Returns 1 if the program headers were loaded. */
4546 process_program_headers (FILE * file
)
4548 Elf_Internal_Phdr
* segment
;
4551 if (elf_header
.e_phnum
== 0)
4553 /* PR binutils/12467. */
4554 if (elf_header
.e_phoff
!= 0)
4555 warn (_("possibly corrupt ELF header - it has a non-zero program"
4556 " header offset, but no program headers\n"));
4557 else if (do_segments
)
4558 printf (_("\nThere are no program headers in this file.\n"));
4562 if (do_segments
&& !do_header
)
4564 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4565 printf (_("Entry point "));
4566 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4567 printf (_("\nThere are %d program headers, starting at offset "),
4568 elf_header
.e_phnum
);
4569 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4573 if (! get_program_headers (file
))
4578 if (elf_header
.e_phnum
> 1)
4579 printf (_("\nProgram Headers:\n"));
4581 printf (_("\nProgram Headers:\n"));
4585 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4588 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4592 (_(" Type Offset VirtAddr PhysAddr\n"));
4594 (_(" FileSiz MemSiz Flags Align\n"));
4601 for (i
= 0, segment
= program_headers
;
4602 i
< elf_header
.e_phnum
;
4607 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4611 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4612 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4613 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4614 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4615 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4617 (segment
->p_flags
& PF_R
? 'R' : ' '),
4618 (segment
->p_flags
& PF_W
? 'W' : ' '),
4619 (segment
->p_flags
& PF_X
? 'E' : ' '));
4620 printf ("%#lx", (unsigned long) segment
->p_align
);
4624 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4625 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4628 print_vma (segment
->p_offset
, FULL_HEX
);
4632 print_vma (segment
->p_vaddr
, FULL_HEX
);
4634 print_vma (segment
->p_paddr
, FULL_HEX
);
4637 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4638 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4641 print_vma (segment
->p_filesz
, FULL_HEX
);
4645 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4646 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4649 print_vma (segment
->p_memsz
, FULL_HEX
);
4653 (segment
->p_flags
& PF_R
? 'R' : ' '),
4654 (segment
->p_flags
& PF_W
? 'W' : ' '),
4655 (segment
->p_flags
& PF_X
? 'E' : ' '));
4657 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4658 printf ("%#lx", (unsigned long) segment
->p_align
);
4661 print_vma (segment
->p_align
, PREFIX_HEX
);
4666 print_vma (segment
->p_offset
, FULL_HEX
);
4668 print_vma (segment
->p_vaddr
, FULL_HEX
);
4670 print_vma (segment
->p_paddr
, FULL_HEX
);
4672 print_vma (segment
->p_filesz
, FULL_HEX
);
4674 print_vma (segment
->p_memsz
, FULL_HEX
);
4676 (segment
->p_flags
& PF_R
? 'R' : ' '),
4677 (segment
->p_flags
& PF_W
? 'W' : ' '),
4678 (segment
->p_flags
& PF_X
? 'E' : ' '));
4679 print_vma (segment
->p_align
, HEX
);
4684 putc ('\n', stdout
);
4686 switch (segment
->p_type
)
4690 error (_("more than one dynamic segment\n"));
4692 /* By default, assume that the .dynamic section is the first
4693 section in the DYNAMIC segment. */
4694 dynamic_addr
= segment
->p_offset
;
4695 dynamic_size
= segment
->p_filesz
;
4696 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4697 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4699 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4700 dynamic_addr
= dynamic_size
= 0;
4703 /* Try to locate the .dynamic section. If there is
4704 a section header table, we can easily locate it. */
4705 if (section_headers
!= NULL
)
4707 Elf_Internal_Shdr
* sec
;
4709 sec
= find_section (".dynamic");
4710 if (sec
== NULL
|| sec
->sh_size
== 0)
4712 /* A corresponding .dynamic section is expected, but on
4713 IA-64/OpenVMS it is OK for it to be missing. */
4714 if (!is_ia64_vms ())
4715 error (_("no .dynamic section in the dynamic segment\n"));
4719 if (sec
->sh_type
== SHT_NOBITS
)
4725 dynamic_addr
= sec
->sh_offset
;
4726 dynamic_size
= sec
->sh_size
;
4728 if (dynamic_addr
< segment
->p_offset
4729 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4730 warn (_("the .dynamic section is not contained"
4731 " within the dynamic segment\n"));
4732 else if (dynamic_addr
> segment
->p_offset
)
4733 warn (_("the .dynamic section is not the first section"
4734 " in the dynamic segment.\n"));
4739 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4741 error (_("Unable to find program interpreter name\n"));
4745 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4747 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4748 error (_("Internal error: failed to create format string to display program interpreter\n"));
4750 program_interpreter
[0] = 0;
4751 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4752 error (_("Unable to read program interpreter name\n"));
4755 printf (_(" [Requesting program interpreter: %s]\n"),
4756 program_interpreter
);
4762 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4764 printf (_("\n Section to Segment mapping:\n"));
4765 printf (_(" Segment Sections...\n"));
4767 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4770 Elf_Internal_Shdr
* section
;
4772 segment
= program_headers
+ i
;
4773 section
= section_headers
+ 1;
4775 printf (" %2.2d ", i
);
4777 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4779 if (!ELF_TBSS_SPECIAL (section
, segment
)
4780 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4781 printf ("%s ", printable_section_name (section
));
4792 /* Find the file offset corresponding to VMA by using the program headers. */
4795 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4797 Elf_Internal_Phdr
* seg
;
4799 if (! get_program_headers (file
))
4801 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4805 for (seg
= program_headers
;
4806 seg
< program_headers
+ elf_header
.e_phnum
;
4809 if (seg
->p_type
!= PT_LOAD
)
4812 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4813 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4814 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4817 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4818 (unsigned long) vma
);
4823 /* Allocate memory and load the sections headers into the global pointer
4824 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4825 generate any error messages if the load fails. */
4828 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4830 Elf32_External_Shdr
* shdrs
;
4831 Elf_Internal_Shdr
* internal
;
4833 unsigned int size
= elf_header
.e_shentsize
;
4834 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4836 /* PR binutils/17531: Cope with unexpected section header sizes. */
4837 if (size
== 0 || num
== 0)
4839 if (size
< sizeof * shdrs
)
4842 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4845 if (!probe
&& size
> sizeof * shdrs
)
4846 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4848 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4850 probe
? NULL
: _("section headers"));
4854 if (section_headers
!= NULL
)
4855 free (section_headers
);
4856 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4857 sizeof (Elf_Internal_Shdr
));
4858 if (section_headers
== NULL
)
4861 error (_("Out of memory reading %u section headers\n"), num
);
4865 for (i
= 0, internal
= section_headers
;
4869 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4870 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4871 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4872 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4873 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4874 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4875 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4876 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4877 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4878 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4886 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4888 Elf64_External_Shdr
* shdrs
;
4889 Elf_Internal_Shdr
* internal
;
4891 unsigned int size
= elf_header
.e_shentsize
;
4892 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4894 /* PR binutils/17531: Cope with unexpected section header sizes. */
4895 if (size
== 0 || num
== 0)
4897 if (size
< sizeof * shdrs
)
4900 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4903 if (! probe
&& size
> sizeof * shdrs
)
4904 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4906 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4908 probe
? NULL
: _("section headers"));
4912 if (section_headers
!= NULL
)
4913 free (section_headers
);
4914 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4915 sizeof (Elf_Internal_Shdr
));
4916 if (section_headers
== NULL
)
4919 error (_("Out of memory reading %u section headers\n"), num
);
4923 for (i
= 0, internal
= section_headers
;
4927 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4928 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4929 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4930 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4931 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4932 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4933 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4934 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4935 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4936 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4943 static Elf_Internal_Sym
*
4944 get_32bit_elf_symbols (FILE * file
,
4945 Elf_Internal_Shdr
* section
,
4946 unsigned long * num_syms_return
)
4948 unsigned long number
= 0;
4949 Elf32_External_Sym
* esyms
= NULL
;
4950 Elf_External_Sym_Shndx
* shndx
= NULL
;
4951 Elf_Internal_Sym
* isyms
= NULL
;
4952 Elf_Internal_Sym
* psym
;
4955 if (section
->sh_size
== 0)
4957 if (num_syms_return
!= NULL
)
4958 * num_syms_return
= 0;
4962 /* Run some sanity checks first. */
4963 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4965 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4966 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4970 if (section
->sh_size
> current_file_size
)
4972 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4973 printable_section_name (section
), (unsigned long) section
->sh_size
);
4977 number
= section
->sh_size
/ section
->sh_entsize
;
4979 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4981 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4982 (unsigned long) section
->sh_size
,
4983 printable_section_name (section
),
4984 (unsigned long) section
->sh_entsize
);
4988 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4989 section
->sh_size
, _("symbols"));
4994 if (symtab_shndx_hdr
!= NULL
4995 && (symtab_shndx_hdr
->sh_link
4996 == (unsigned long) (section
- section_headers
)))
4998 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4999 symtab_shndx_hdr
->sh_offset
,
5000 1, symtab_shndx_hdr
->sh_size
,
5001 _("symbol table section indicies"));
5004 /* PR17531: file: heap-buffer-overflow */
5005 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5007 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5008 printable_section_name (symtab_shndx_hdr
),
5009 (unsigned long) symtab_shndx_hdr
->sh_size
,
5010 (unsigned long) section
->sh_size
);
5015 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5019 error (_("Out of memory reading %lu symbols\n"),
5020 (unsigned long) number
);
5024 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5026 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5027 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5028 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5029 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5030 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5032 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5033 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5034 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5035 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5036 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5045 if (num_syms_return
!= NULL
)
5046 * num_syms_return
= isyms
== NULL
? 0 : number
;
5051 static Elf_Internal_Sym
*
5052 get_64bit_elf_symbols (FILE * file
,
5053 Elf_Internal_Shdr
* section
,
5054 unsigned long * num_syms_return
)
5056 unsigned long number
= 0;
5057 Elf64_External_Sym
* esyms
= NULL
;
5058 Elf_External_Sym_Shndx
* shndx
= NULL
;
5059 Elf_Internal_Sym
* isyms
= NULL
;
5060 Elf_Internal_Sym
* psym
;
5063 if (section
->sh_size
== 0)
5065 if (num_syms_return
!= NULL
)
5066 * num_syms_return
= 0;
5070 /* Run some sanity checks first. */
5071 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5073 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5074 printable_section_name (section
),
5075 (unsigned long) section
->sh_entsize
);
5079 if (section
->sh_size
> current_file_size
)
5081 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5082 printable_section_name (section
),
5083 (unsigned long) section
->sh_size
);
5087 number
= section
->sh_size
/ section
->sh_entsize
;
5089 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5091 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5092 (unsigned long) section
->sh_size
,
5093 printable_section_name (section
),
5094 (unsigned long) section
->sh_entsize
);
5098 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5099 section
->sh_size
, _("symbols"));
5103 if (symtab_shndx_hdr
!= NULL
5104 && (symtab_shndx_hdr
->sh_link
5105 == (unsigned long) (section
- section_headers
)))
5107 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5108 symtab_shndx_hdr
->sh_offset
,
5109 1, symtab_shndx_hdr
->sh_size
,
5110 _("symbol table section indicies"));
5113 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5115 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5116 printable_section_name (symtab_shndx_hdr
),
5117 (unsigned long) symtab_shndx_hdr
->sh_size
,
5118 (unsigned long) section
->sh_size
);
5123 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5127 error (_("Out of memory reading %lu symbols\n"),
5128 (unsigned long) number
);
5132 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5134 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5135 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5136 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5137 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5139 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5141 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5142 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5143 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5145 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5146 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5155 if (num_syms_return
!= NULL
)
5156 * num_syms_return
= isyms
== NULL
? 0 : number
;
5162 get_elf_section_flags (bfd_vma sh_flags
)
5164 static char buff
[1024];
5166 int field_size
= is_32bit_elf
? 8 : 16;
5168 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5169 bfd_vma os_flags
= 0;
5170 bfd_vma proc_flags
= 0;
5171 bfd_vma unknown_flags
= 0;
5179 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5180 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5181 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5182 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5183 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5184 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5185 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5186 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5187 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5188 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5189 /* IA-64 specific. */
5190 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5191 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5192 /* IA-64 OpenVMS specific. */
5193 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5194 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5195 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5196 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5197 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5198 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5200 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5201 /* SPARC specific. */
5202 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5203 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5206 if (do_section_details
)
5208 sprintf (buff
, "[%*.*lx]: ",
5209 field_size
, field_size
, (unsigned long) sh_flags
);
5210 p
+= field_size
+ 4;
5217 flag
= sh_flags
& - sh_flags
;
5220 if (do_section_details
)
5224 case SHF_WRITE
: sindex
= 0; break;
5225 case SHF_ALLOC
: sindex
= 1; break;
5226 case SHF_EXECINSTR
: sindex
= 2; break;
5227 case SHF_MERGE
: sindex
= 3; break;
5228 case SHF_STRINGS
: sindex
= 4; break;
5229 case SHF_INFO_LINK
: sindex
= 5; break;
5230 case SHF_LINK_ORDER
: sindex
= 6; break;
5231 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5232 case SHF_GROUP
: sindex
= 8; break;
5233 case SHF_TLS
: sindex
= 9; break;
5234 case SHF_EXCLUDE
: sindex
= 18; break;
5235 case SHF_COMPRESSED
: sindex
= 20; break;
5239 switch (elf_header
.e_machine
)
5242 if (flag
== SHF_IA_64_SHORT
)
5244 else if (flag
== SHF_IA_64_NORECOV
)
5247 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5250 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5251 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5252 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5253 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5254 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5255 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5266 case EM_OLD_SPARCV9
:
5267 case EM_SPARC32PLUS
:
5270 if (flag
== SHF_ORDERED
)
5280 if (p
!= buff
+ field_size
+ 4)
5282 if (size
< (10 + 2))
5284 warn (_("Internal error: not enough buffer room for section flag info"));
5285 return _("<unknown>");
5292 size
-= flags
[sindex
].len
;
5293 p
= stpcpy (p
, flags
[sindex
].str
);
5295 else if (flag
& SHF_MASKOS
)
5297 else if (flag
& SHF_MASKPROC
)
5300 unknown_flags
|= flag
;
5306 case SHF_WRITE
: *p
= 'W'; break;
5307 case SHF_ALLOC
: *p
= 'A'; break;
5308 case SHF_EXECINSTR
: *p
= 'X'; break;
5309 case SHF_MERGE
: *p
= 'M'; break;
5310 case SHF_STRINGS
: *p
= 'S'; break;
5311 case SHF_INFO_LINK
: *p
= 'I'; break;
5312 case SHF_LINK_ORDER
: *p
= 'L'; break;
5313 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5314 case SHF_GROUP
: *p
= 'G'; break;
5315 case SHF_TLS
: *p
= 'T'; break;
5316 case SHF_EXCLUDE
: *p
= 'E'; break;
5317 case SHF_COMPRESSED
: *p
= 'C'; break;
5320 if ((elf_header
.e_machine
== EM_X86_64
5321 || elf_header
.e_machine
== EM_L1OM
5322 || elf_header
.e_machine
== EM_K1OM
)
5323 && flag
== SHF_X86_64_LARGE
)
5325 else if (flag
& SHF_MASKOS
)
5328 sh_flags
&= ~ SHF_MASKOS
;
5330 else if (flag
& SHF_MASKPROC
)
5333 sh_flags
&= ~ SHF_MASKPROC
;
5343 if (do_section_details
)
5347 size
-= 5 + field_size
;
5348 if (p
!= buff
+ field_size
+ 4)
5352 warn (_("Internal error: not enough buffer room for section flag info"));
5353 return _("<unknown>");
5359 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5360 (unsigned long) os_flags
);
5361 p
+= 5 + field_size
;
5365 size
-= 7 + field_size
;
5366 if (p
!= buff
+ field_size
+ 4)
5370 warn (_("Internal error: not enough buffer room for section flag info"));
5371 return _("<unknown>");
5377 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5378 (unsigned long) proc_flags
);
5379 p
+= 7 + field_size
;
5383 size
-= 10 + field_size
;
5384 if (p
!= buff
+ field_size
+ 4)
5388 warn (_("Internal error: not enough buffer room for section flag info"));
5389 return _("<unknown>");
5395 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5396 (unsigned long) unknown_flags
);
5397 p
+= 10 + field_size
;
5406 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5410 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5411 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5412 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5413 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5414 return sizeof (*echdr
);
5418 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5419 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5420 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5421 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5422 return sizeof (*echdr
);
5427 process_section_headers (FILE * file
)
5429 Elf_Internal_Shdr
* section
;
5432 section_headers
= NULL
;
5434 if (elf_header
.e_shnum
== 0)
5436 /* PR binutils/12467. */
5437 if (elf_header
.e_shoff
!= 0)
5438 warn (_("possibly corrupt ELF file header - it has a non-zero"
5439 " section header offset, but no section headers\n"));
5440 else if (do_sections
)
5441 printf (_("\nThere are no sections in this file.\n"));
5446 if (do_sections
&& !do_header
)
5447 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5448 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5452 if (! get_32bit_section_headers (file
, FALSE
))
5455 else if (! get_64bit_section_headers (file
, FALSE
))
5458 /* Read in the string table, so that we have names to display. */
5459 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5460 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5462 section
= section_headers
+ elf_header
.e_shstrndx
;
5464 if (section
->sh_size
!= 0)
5466 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5467 1, section
->sh_size
,
5470 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5474 /* Scan the sections for the dynamic symbol table
5475 and dynamic string table and debug sections. */
5476 dynamic_symbols
= NULL
;
5477 dynamic_strings
= NULL
;
5478 dynamic_syminfo
= NULL
;
5479 symtab_shndx_hdr
= NULL
;
5481 eh_addr_size
= is_32bit_elf
? 4 : 8;
5482 switch (elf_header
.e_machine
)
5485 case EM_MIPS_RS3_LE
:
5486 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5487 FDE addresses. However, the ABI also has a semi-official ILP32
5488 variant for which the normal FDE address size rules apply.
5490 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5491 section, where XX is the size of longs in bits. Unfortunately,
5492 earlier compilers provided no way of distinguishing ILP32 objects
5493 from LP64 objects, so if there's any doubt, we should assume that
5494 the official LP64 form is being used. */
5495 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5496 && find_section (".gcc_compiled_long32") == NULL
)
5502 switch (elf_header
.e_flags
& EF_H8_MACH
)
5504 case E_H8_MACH_H8300
:
5505 case E_H8_MACH_H8300HN
:
5506 case E_H8_MACH_H8300SN
:
5507 case E_H8_MACH_H8300SXN
:
5510 case E_H8_MACH_H8300H
:
5511 case E_H8_MACH_H8300S
:
5512 case E_H8_MACH_H8300SX
:
5520 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5522 case EF_M32C_CPU_M16C
:
5529 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5532 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5533 if (section->sh_entsize != expected_entsize) \
5536 sprintf_vma (buf, section->sh_entsize); \
5537 /* Note: coded this way so that there is a single string for \
5539 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5540 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5541 (unsigned) expected_entsize); \
5542 section->sh_entsize = expected_entsize; \
5547 #define CHECK_ENTSIZE(section, i, type) \
5548 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5549 sizeof (Elf64_External_##type))
5551 for (i
= 0, section
= section_headers
;
5552 i
< elf_header
.e_shnum
;
5555 char * name
= SECTION_NAME (section
);
5557 if (section
->sh_type
== SHT_DYNSYM
)
5559 if (dynamic_symbols
!= NULL
)
5561 error (_("File contains multiple dynamic symbol tables\n"));
5565 CHECK_ENTSIZE (section
, i
, Sym
);
5566 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5568 else if (section
->sh_type
== SHT_STRTAB
5569 && streq (name
, ".dynstr"))
5571 if (dynamic_strings
!= NULL
)
5573 error (_("File contains multiple dynamic string tables\n"));
5577 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5578 1, section
->sh_size
,
5579 _("dynamic strings"));
5580 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5582 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5584 if (symtab_shndx_hdr
!= NULL
)
5586 error (_("File contains multiple symtab shndx tables\n"));
5589 symtab_shndx_hdr
= section
;
5591 else if (section
->sh_type
== SHT_SYMTAB
)
5592 CHECK_ENTSIZE (section
, i
, Sym
);
5593 else if (section
->sh_type
== SHT_GROUP
)
5594 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5595 else if (section
->sh_type
== SHT_REL
)
5596 CHECK_ENTSIZE (section
, i
, Rel
);
5597 else if (section
->sh_type
== SHT_RELA
)
5598 CHECK_ENTSIZE (section
, i
, Rela
);
5599 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5600 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5601 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5602 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5603 || do_debug_addr
|| do_debug_cu_index
)
5604 && (const_strneq (name
, ".debug_")
5605 || const_strneq (name
, ".zdebug_")))
5608 name
+= sizeof (".zdebug_") - 1;
5610 name
+= sizeof (".debug_") - 1;
5613 || (do_debug_info
&& const_strneq (name
, "info"))
5614 || (do_debug_info
&& const_strneq (name
, "types"))
5615 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5616 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5617 || (do_debug_lines
&& const_strneq (name
, "line."))
5618 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5619 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5620 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5621 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5622 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5623 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5624 || (do_debug_frames
&& const_strneq (name
, "frame"))
5625 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5626 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5627 || (do_debug_str
&& const_strneq (name
, "str"))
5628 || (do_debug_loc
&& const_strneq (name
, "loc"))
5629 || (do_debug_addr
&& const_strneq (name
, "addr"))
5630 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5631 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5633 request_dump_bynumber (i
, DEBUG_DUMP
);
5635 /* Linkonce section to be combined with .debug_info at link time. */
5636 else if ((do_debugging
|| do_debug_info
)
5637 && const_strneq (name
, ".gnu.linkonce.wi."))
5638 request_dump_bynumber (i
, DEBUG_DUMP
);
5639 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5640 request_dump_bynumber (i
, DEBUG_DUMP
);
5641 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5642 request_dump_bynumber (i
, DEBUG_DUMP
);
5643 /* Trace sections for Itanium VMS. */
5644 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5645 || do_trace_aranges
)
5646 && const_strneq (name
, ".trace_"))
5648 name
+= sizeof (".trace_") - 1;
5651 || (do_trace_info
&& streq (name
, "info"))
5652 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5653 || (do_trace_aranges
&& streq (name
, "aranges"))
5655 request_dump_bynumber (i
, DEBUG_DUMP
);
5662 if (elf_header
.e_shnum
> 1)
5663 printf (_("\nSection Headers:\n"));
5665 printf (_("\nSection Header:\n"));
5669 if (do_section_details
)
5671 printf (_(" [Nr] Name\n"));
5672 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5676 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5680 if (do_section_details
)
5682 printf (_(" [Nr] Name\n"));
5683 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5687 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5691 if (do_section_details
)
5693 printf (_(" [Nr] Name\n"));
5694 printf (_(" Type Address Offset Link\n"));
5695 printf (_(" Size EntSize Info Align\n"));
5699 printf (_(" [Nr] Name Type Address Offset\n"));
5700 printf (_(" Size EntSize Flags Link Info Align\n"));
5704 if (do_section_details
)
5705 printf (_(" Flags\n"));
5707 for (i
= 0, section
= section_headers
;
5708 i
< elf_header
.e_shnum
;
5711 printf (" [%2u] ", i
);
5712 if (do_section_details
)
5713 printf ("%s\n ", printable_section_name (section
));
5715 print_symbol (-17, SECTION_NAME (section
));
5717 printf (do_wide
? " %-15s " : " %-15.15s ",
5718 get_section_type_name (section
->sh_type
));
5722 const char * link_too_big
= NULL
;
5724 print_vma (section
->sh_addr
, LONG_HEX
);
5726 printf ( " %6.6lx %6.6lx %2.2lx",
5727 (unsigned long) section
->sh_offset
,
5728 (unsigned long) section
->sh_size
,
5729 (unsigned long) section
->sh_entsize
);
5731 if (do_section_details
)
5732 fputs (" ", stdout
);
5734 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5736 if (section
->sh_link
>= elf_header
.e_shnum
)
5739 /* The sh_link value is out of range. Normally this indicates
5740 an error but it can have special values in Solaris binaries. */
5741 switch (elf_header
.e_machine
)
5748 case EM_OLD_SPARCV9
:
5749 case EM_SPARC32PLUS
:
5752 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5753 link_too_big
= "BEFORE";
5754 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5755 link_too_big
= "AFTER";
5762 if (do_section_details
)
5764 if (link_too_big
!= NULL
&& * link_too_big
)
5765 printf ("<%s> ", link_too_big
);
5767 printf ("%2u ", section
->sh_link
);
5768 printf ("%3u %2lu\n", section
->sh_info
,
5769 (unsigned long) section
->sh_addralign
);
5772 printf ("%2u %3u %2lu\n",
5775 (unsigned long) section
->sh_addralign
);
5777 if (link_too_big
&& ! * link_too_big
)
5778 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5779 i
, section
->sh_link
);
5783 print_vma (section
->sh_addr
, LONG_HEX
);
5785 if ((long) section
->sh_offset
== section
->sh_offset
)
5786 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5790 print_vma (section
->sh_offset
, LONG_HEX
);
5793 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5794 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5798 print_vma (section
->sh_size
, LONG_HEX
);
5801 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5802 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5806 print_vma (section
->sh_entsize
, LONG_HEX
);
5809 if (do_section_details
)
5810 fputs (" ", stdout
);
5812 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5814 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5816 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5817 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5820 print_vma (section
->sh_addralign
, DEC
);
5824 else if (do_section_details
)
5826 printf (" %-15.15s ",
5827 get_section_type_name (section
->sh_type
));
5828 print_vma (section
->sh_addr
, LONG_HEX
);
5829 if ((long) section
->sh_offset
== section
->sh_offset
)
5830 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5834 print_vma (section
->sh_offset
, LONG_HEX
);
5836 printf (" %u\n ", section
->sh_link
);
5837 print_vma (section
->sh_size
, LONG_HEX
);
5839 print_vma (section
->sh_entsize
, LONG_HEX
);
5841 printf (" %-16u %lu\n",
5843 (unsigned long) section
->sh_addralign
);
5848 print_vma (section
->sh_addr
, LONG_HEX
);
5849 if ((long) section
->sh_offset
== section
->sh_offset
)
5850 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5854 print_vma (section
->sh_offset
, LONG_HEX
);
5857 print_vma (section
->sh_size
, LONG_HEX
);
5859 print_vma (section
->sh_entsize
, LONG_HEX
);
5861 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5863 printf (" %2u %3u %lu\n",
5866 (unsigned long) section
->sh_addralign
);
5869 if (do_section_details
)
5871 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5872 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5874 /* Minimum section size is 12 bytes for 32-bit compression
5875 header + 12 bytes for compressed data header. */
5876 unsigned char buf
[24];
5877 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5878 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5879 sizeof (buf
), _("compression header")))
5881 Elf_Internal_Chdr chdr
;
5882 get_compression_header (&chdr
, buf
);
5883 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5886 printf (_(" [<unknown>: 0x%x], "),
5888 print_vma (chdr
.ch_size
, LONG_HEX
);
5889 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
5895 if (!do_section_details
)
5897 if (elf_header
.e_machine
== EM_X86_64
5898 || elf_header
.e_machine
== EM_L1OM
5899 || elf_header
.e_machine
== EM_K1OM
)
5900 printf (_("Key to Flags:\n\
5901 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5902 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5903 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5905 printf (_("Key to Flags:\n\
5906 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5907 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5908 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5915 get_group_flags (unsigned int flags
)
5917 static char buff
[32];
5927 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5934 process_section_groups (FILE * file
)
5936 Elf_Internal_Shdr
* section
;
5938 struct group
* group
;
5939 Elf_Internal_Shdr
* symtab_sec
;
5940 Elf_Internal_Shdr
* strtab_sec
;
5941 Elf_Internal_Sym
* symtab
;
5942 unsigned long num_syms
;
5946 /* Don't process section groups unless needed. */
5947 if (!do_unwind
&& !do_section_groups
)
5950 if (elf_header
.e_shnum
== 0)
5952 if (do_section_groups
)
5953 printf (_("\nThere are no sections to group in this file.\n"));
5958 if (section_headers
== NULL
)
5960 error (_("Section headers are not available!\n"));
5961 /* PR 13622: This can happen with a corrupt ELF header. */
5965 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5966 sizeof (struct group
*));
5968 if (section_headers_groups
== NULL
)
5970 error (_("Out of memory reading %u section group headers\n"),
5971 elf_header
.e_shnum
);
5975 /* Scan the sections for the group section. */
5977 for (i
= 0, section
= section_headers
;
5978 i
< elf_header
.e_shnum
;
5980 if (section
->sh_type
== SHT_GROUP
)
5983 if (group_count
== 0)
5985 if (do_section_groups
)
5986 printf (_("\nThere are no section groups in this file.\n"));
5991 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5993 if (section_groups
== NULL
)
5995 error (_("Out of memory reading %lu groups\n"),
5996 (unsigned long) group_count
);
6006 for (i
= 0, section
= section_headers
, group
= section_groups
;
6007 i
< elf_header
.e_shnum
;
6010 if (section
->sh_type
== SHT_GROUP
)
6012 const char * name
= printable_section_name (section
);
6013 const char * group_name
;
6014 unsigned char * start
;
6015 unsigned char * indices
;
6016 unsigned int entry
, j
, size
;
6017 Elf_Internal_Shdr
* sec
;
6018 Elf_Internal_Sym
* sym
;
6020 /* Get the symbol table. */
6021 if (section
->sh_link
>= elf_header
.e_shnum
6022 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6025 error (_("Bad sh_link in group section `%s'\n"), name
);
6029 if (symtab_sec
!= sec
)
6034 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6039 error (_("Corrupt header in group section `%s'\n"), name
);
6043 if (section
->sh_info
>= num_syms
)
6045 error (_("Bad sh_info in group section `%s'\n"), name
);
6049 sym
= symtab
+ section
->sh_info
;
6051 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6053 if (sym
->st_shndx
== 0
6054 || sym
->st_shndx
>= elf_header
.e_shnum
)
6056 error (_("Bad sh_info in group section `%s'\n"), name
);
6060 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6069 /* Get the string table. */
6070 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6079 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6085 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6086 1, strtab_sec
->sh_size
,
6088 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6090 group_name
= sym
->st_name
< strtab_size
6091 ? strtab
+ sym
->st_name
: _("<corrupt>");
6094 /* PR 17531: file: loop. */
6095 if (section
->sh_entsize
> section
->sh_size
)
6097 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6098 printable_section_name (section
),
6099 (unsigned long) section
->sh_entsize
,
6100 (unsigned long) section
->sh_size
);
6104 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6105 1, section
->sh_size
,
6111 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6112 entry
= byte_get (indices
, 4);
6115 if (do_section_groups
)
6117 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6118 get_group_flags (entry
), i
, name
, group_name
, size
);
6120 printf (_(" [Index] Name\n"));
6123 group
->group_index
= i
;
6125 for (j
= 0; j
< size
; j
++)
6127 struct group_list
* g
;
6129 entry
= byte_get (indices
, 4);
6132 if (entry
>= elf_header
.e_shnum
)
6134 static unsigned num_group_errors
= 0;
6136 if (num_group_errors
++ < 10)
6138 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6139 entry
, i
, elf_header
.e_shnum
- 1);
6140 if (num_group_errors
== 10)
6141 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6146 if (section_headers_groups
[entry
] != NULL
)
6150 static unsigned num_errs
= 0;
6152 if (num_errs
++ < 10)
6154 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6156 section_headers_groups
[entry
]->group_index
);
6158 warn (_("Further error messages about already contained group sections suppressed\n"));
6164 /* Intel C/C++ compiler may put section 0 in a
6165 section group. We just warn it the first time
6166 and ignore it afterwards. */
6167 static int warned
= 0;
6170 error (_("section 0 in group section [%5u]\n"),
6171 section_headers_groups
[entry
]->group_index
);
6177 section_headers_groups
[entry
] = group
;
6179 if (do_section_groups
)
6181 sec
= section_headers
+ entry
;
6182 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6185 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6186 g
->section_index
= entry
;
6187 g
->next
= group
->root
;
6205 /* Data used to display dynamic fixups. */
6207 struct ia64_vms_dynfixup
6209 bfd_vma needed_ident
; /* Library ident number. */
6210 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6211 bfd_vma fixup_needed
; /* Index of the library. */
6212 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6213 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6216 /* Data used to display dynamic relocations. */
6218 struct ia64_vms_dynimgrela
6220 bfd_vma img_rela_cnt
; /* Number of relocations. */
6221 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6224 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6228 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6229 const char *strtab
, unsigned int strtab_sz
)
6231 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6233 const char *lib_name
;
6235 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6236 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6237 _("dynamic section image fixups"));
6241 if (fixup
->needed
< strtab_sz
)
6242 lib_name
= strtab
+ fixup
->needed
;
6245 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6246 (unsigned long) fixup
->needed
);
6249 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6250 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6252 (_("Seg Offset Type SymVec DataType\n"));
6254 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6259 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6260 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6261 type
= BYTE_GET (imfs
[i
].type
);
6262 rtype
= elf_ia64_reloc_type (type
);
6264 printf (" 0x%08x ", type
);
6266 printf (" %-32s ", rtype
);
6267 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6268 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6274 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6277 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6279 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6282 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6283 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6284 _("dynamic section image relocations"));
6288 printf (_("\nImage relocs\n"));
6290 (_("Seg Offset Type Addend Seg Sym Off\n"));
6292 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6297 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6298 printf ("%08" BFD_VMA_FMT
"x ",
6299 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6300 type
= BYTE_GET (imrs
[i
].type
);
6301 rtype
= elf_ia64_reloc_type (type
);
6303 printf ("0x%08x ", type
);
6305 printf ("%-31s ", rtype
);
6306 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6307 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6308 printf ("%08" BFD_VMA_FMT
"x\n",
6309 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6315 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6318 process_ia64_vms_dynamic_relocs (FILE *file
)
6320 struct ia64_vms_dynfixup fixup
;
6321 struct ia64_vms_dynimgrela imgrela
;
6322 Elf_Internal_Dyn
*entry
;
6324 bfd_vma strtab_off
= 0;
6325 bfd_vma strtab_sz
= 0;
6326 char *strtab
= NULL
;
6328 memset (&fixup
, 0, sizeof (fixup
));
6329 memset (&imgrela
, 0, sizeof (imgrela
));
6331 /* Note: the order of the entries is specified by the OpenVMS specs. */
6332 for (entry
= dynamic_section
;
6333 entry
< dynamic_section
+ dynamic_nent
;
6336 switch (entry
->d_tag
)
6338 case DT_IA_64_VMS_STRTAB_OFFSET
:
6339 strtab_off
= entry
->d_un
.d_val
;
6342 strtab_sz
= entry
->d_un
.d_val
;
6344 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6345 1, strtab_sz
, _("dynamic string section"));
6348 case DT_IA_64_VMS_NEEDED_IDENT
:
6349 fixup
.needed_ident
= entry
->d_un
.d_val
;
6352 fixup
.needed
= entry
->d_un
.d_val
;
6354 case DT_IA_64_VMS_FIXUP_NEEDED
:
6355 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6357 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6358 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6360 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6361 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6363 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6366 case DT_IA_64_VMS_IMG_RELA_CNT
:
6367 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6369 case DT_IA_64_VMS_IMG_RELA_OFF
:
6370 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6372 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6392 } dynamic_relocations
[] =
6394 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6395 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6396 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6399 /* Process the reloc section. */
6402 process_relocs (FILE * file
)
6404 unsigned long rel_size
;
6405 unsigned long rel_offset
;
6411 if (do_using_dynamic
)
6415 int has_dynamic_reloc
;
6418 has_dynamic_reloc
= 0;
6420 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6422 is_rela
= dynamic_relocations
[i
].rela
;
6423 name
= dynamic_relocations
[i
].name
;
6424 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6425 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6427 has_dynamic_reloc
|= rel_size
;
6429 if (is_rela
== UNKNOWN
)
6431 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6432 switch (dynamic_info
[DT_PLTREL
])
6446 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6447 name
, rel_offset
, rel_size
);
6449 dump_relocations (file
,
6450 offset_from_vma (file
, rel_offset
, rel_size
),
6452 dynamic_symbols
, num_dynamic_syms
,
6453 dynamic_strings
, dynamic_strings_length
,
6459 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6461 if (! has_dynamic_reloc
)
6462 printf (_("\nThere are no dynamic relocations in this file.\n"));
6466 Elf_Internal_Shdr
* section
;
6470 for (i
= 0, section
= section_headers
;
6471 i
< elf_header
.e_shnum
;
6474 if ( section
->sh_type
!= SHT_RELA
6475 && section
->sh_type
!= SHT_REL
)
6478 rel_offset
= section
->sh_offset
;
6479 rel_size
= section
->sh_size
;
6483 Elf_Internal_Shdr
* strsec
;
6486 printf (_("\nRelocation section "));
6488 if (string_table
== NULL
)
6489 printf ("%d", section
->sh_name
);
6491 printf ("'%s'", printable_section_name (section
));
6493 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6494 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6496 is_rela
= section
->sh_type
== SHT_RELA
;
6498 if (section
->sh_link
!= 0
6499 && section
->sh_link
< elf_header
.e_shnum
)
6501 Elf_Internal_Shdr
* symsec
;
6502 Elf_Internal_Sym
* symtab
;
6503 unsigned long nsyms
;
6504 unsigned long strtablen
= 0;
6505 char * strtab
= NULL
;
6507 symsec
= section_headers
+ section
->sh_link
;
6508 if (symsec
->sh_type
!= SHT_SYMTAB
6509 && symsec
->sh_type
!= SHT_DYNSYM
)
6512 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6517 if (symsec
->sh_link
!= 0
6518 && symsec
->sh_link
< elf_header
.e_shnum
)
6520 strsec
= section_headers
+ symsec
->sh_link
;
6522 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6525 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6528 dump_relocations (file
, rel_offset
, rel_size
,
6529 symtab
, nsyms
, strtab
, strtablen
,
6531 symsec
->sh_type
== SHT_DYNSYM
);
6537 dump_relocations (file
, rel_offset
, rel_size
,
6538 NULL
, 0, NULL
, 0, is_rela
, 0);
6545 printf (_("\nThere are no relocations in this file.\n"));
6551 /* An absolute address consists of a section and an offset. If the
6552 section is NULL, the offset itself is the address, otherwise, the
6553 address equals to LOAD_ADDRESS(section) + offset. */
6557 unsigned short section
;
6561 #define ABSADDR(a) \
6563 ? section_headers [(a).section].sh_addr + (a).offset \
6566 /* Find the nearest symbol at or below ADDR. Returns the symbol
6567 name, if found, and the offset from the symbol to ADDR. */
6570 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6571 unsigned long nsyms
,
6572 const char * strtab
,
6573 unsigned long strtab_size
,
6574 struct absaddr addr
,
6575 const char ** symname
,
6578 bfd_vma dist
= 0x100000;
6579 Elf_Internal_Sym
* sym
;
6580 Elf_Internal_Sym
* beg
;
6581 Elf_Internal_Sym
* end
;
6582 Elf_Internal_Sym
* best
= NULL
;
6584 REMOVE_ARCH_BITS (addr
.offset
);
6586 end
= symtab
+ nsyms
;
6592 sym
= beg
+ (end
- beg
) / 2;
6594 value
= sym
->st_value
;
6595 REMOVE_ARCH_BITS (value
);
6597 if (sym
->st_name
!= 0
6598 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6599 && addr
.offset
>= value
6600 && addr
.offset
- value
< dist
)
6603 dist
= addr
.offset
- value
;
6608 if (addr
.offset
< value
)
6616 *symname
= (best
->st_name
>= strtab_size
6617 ? _("<corrupt>") : strtab
+ best
->st_name
);
6623 *offset
= addr
.offset
;
6627 symcmp (const void *p
, const void *q
)
6629 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6630 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6632 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6635 /* Process the unwind section. */
6637 #include "unwind-ia64.h"
6639 struct ia64_unw_table_entry
6641 struct absaddr start
;
6643 struct absaddr info
;
6646 struct ia64_unw_aux_info
6648 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6649 unsigned long table_len
; /* Length of unwind table. */
6650 unsigned char * info
; /* Unwind info. */
6651 unsigned long info_size
; /* Size of unwind info. */
6652 bfd_vma info_addr
; /* Starting address of unwind info. */
6653 bfd_vma seg_base
; /* Starting address of segment. */
6654 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6655 unsigned long nsyms
; /* Number of symbols. */
6656 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6657 unsigned long nfuns
; /* Number of entries in funtab. */
6658 char * strtab
; /* The string table. */
6659 unsigned long strtab_size
; /* Size of string table. */
6663 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6665 struct ia64_unw_table_entry
* tp
;
6666 unsigned long j
, nfuns
;
6669 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6670 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6671 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6672 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6674 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6676 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6680 const unsigned char * dp
;
6681 const unsigned char * head
;
6682 const unsigned char * end
;
6683 const char * procname
;
6685 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6686 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6688 fputs ("\n<", stdout
);
6692 fputs (procname
, stdout
);
6695 printf ("+%lx", (unsigned long) offset
);
6698 fputs (">: [", stdout
);
6699 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6700 fputc ('-', stdout
);
6701 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6702 printf ("], info at +0x%lx\n",
6703 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6705 /* PR 17531: file: 86232b32. */
6706 if (aux
->info
== NULL
)
6709 /* PR 17531: file: 0997b4d1. */
6710 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6712 warn (_("Invalid offset %lx in table entry %ld\n"),
6713 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6717 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6718 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6720 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6721 (unsigned) UNW_VER (stamp
),
6722 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6723 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6724 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6725 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6727 if (UNW_VER (stamp
) != 1)
6729 printf (_("\tUnknown version.\n"));
6734 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6735 /* PR 17531: file: 16ceda89. */
6736 if (end
> aux
->info
+ aux
->info_size
)
6737 end
= aux
->info
+ aux
->info_size
;
6738 for (dp
= head
+ 8; dp
< end
;)
6739 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6746 slurp_ia64_unwind_table (FILE * file
,
6747 struct ia64_unw_aux_info
* aux
,
6748 Elf_Internal_Shdr
* sec
)
6750 unsigned long size
, nrelas
, i
;
6751 Elf_Internal_Phdr
* seg
;
6752 struct ia64_unw_table_entry
* tep
;
6753 Elf_Internal_Shdr
* relsec
;
6754 Elf_Internal_Rela
* rela
;
6755 Elf_Internal_Rela
* rp
;
6756 unsigned char * table
;
6758 Elf_Internal_Sym
* sym
;
6759 const char * relname
;
6763 /* First, find the starting address of the segment that includes
6766 if (elf_header
.e_phnum
)
6768 if (! get_program_headers (file
))
6771 for (seg
= program_headers
;
6772 seg
< program_headers
+ elf_header
.e_phnum
;
6775 if (seg
->p_type
!= PT_LOAD
)
6778 if (sec
->sh_addr
>= seg
->p_vaddr
6779 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6781 aux
->seg_base
= seg
->p_vaddr
;
6787 /* Second, build the unwind table from the contents of the unwind section: */
6788 size
= sec
->sh_size
;
6789 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6794 aux
->table_len
= size
/ (3 * eh_addr_size
);
6795 aux
->table
= (struct ia64_unw_table_entry
*)
6796 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6799 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6801 tep
->start
.section
= SHN_UNDEF
;
6802 tep
->end
.section
= SHN_UNDEF
;
6803 tep
->info
.section
= SHN_UNDEF
;
6804 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6805 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6806 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6807 tep
->start
.offset
+= aux
->seg_base
;
6808 tep
->end
.offset
+= aux
->seg_base
;
6809 tep
->info
.offset
+= aux
->seg_base
;
6813 /* Third, apply any relocations to the unwind table: */
6814 for (relsec
= section_headers
;
6815 relsec
< section_headers
+ elf_header
.e_shnum
;
6818 if (relsec
->sh_type
!= SHT_RELA
6819 || relsec
->sh_info
>= elf_header
.e_shnum
6820 || section_headers
+ relsec
->sh_info
!= sec
)
6823 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6832 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6834 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6835 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6837 /* PR 17531: file: 9fa67536. */
6838 if (relname
== NULL
)
6840 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6844 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6846 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6850 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6852 /* PR 17531: file: 5bc8d9bf. */
6853 if (i
>= aux
->table_len
)
6855 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6859 switch (rp
->r_offset
/ eh_addr_size
% 3)
6862 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6863 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6866 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6867 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6870 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6871 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6885 ia64_process_unwind (FILE * file
)
6887 Elf_Internal_Shdr
* sec
;
6888 Elf_Internal_Shdr
* unwsec
= NULL
;
6889 Elf_Internal_Shdr
* strsec
;
6890 unsigned long i
, unwcount
= 0, unwstart
= 0;
6891 struct ia64_unw_aux_info aux
;
6893 memset (& aux
, 0, sizeof (aux
));
6895 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6897 if (sec
->sh_type
== SHT_SYMTAB
6898 && sec
->sh_link
< elf_header
.e_shnum
)
6900 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6902 strsec
= section_headers
+ sec
->sh_link
;
6903 if (aux
.strtab
!= NULL
)
6905 error (_("Multiple auxillary string tables encountered\n"));
6908 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6911 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6913 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6918 printf (_("\nThere are no unwind sections in this file.\n"));
6920 while (unwcount
-- > 0)
6925 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6926 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6927 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6932 /* We have already counted the number of SHT_IA64_UNWIND
6933 sections so the loop above should never fail. */
6934 assert (unwsec
!= NULL
);
6937 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6939 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6941 /* We need to find which section group it is in. */
6942 struct group_list
* g
;
6944 if (section_headers_groups
== NULL
6945 || section_headers_groups
[i
] == NULL
)
6946 i
= elf_header
.e_shnum
;
6949 g
= section_headers_groups
[i
]->root
;
6951 for (; g
!= NULL
; g
= g
->next
)
6953 sec
= section_headers
+ g
->section_index
;
6955 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6960 i
= elf_header
.e_shnum
;
6963 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6965 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6966 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6967 suffix
= SECTION_NAME (unwsec
) + len
;
6968 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6970 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6971 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6976 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6977 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6978 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6979 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6981 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6982 suffix
= SECTION_NAME (unwsec
) + len
;
6983 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6985 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6986 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6990 if (i
== elf_header
.e_shnum
)
6992 printf (_("\nCould not find unwind info section for "));
6994 if (string_table
== NULL
)
6995 printf ("%d", unwsec
->sh_name
);
6997 printf ("'%s'", printable_section_name (unwsec
));
7001 aux
.info_addr
= sec
->sh_addr
;
7002 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7005 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7007 printf (_("\nUnwind section "));
7009 if (string_table
== NULL
)
7010 printf ("%d", unwsec
->sh_name
);
7012 printf ("'%s'", printable_section_name (unwsec
));
7014 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7015 (unsigned long) unwsec
->sh_offset
,
7016 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7018 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7019 && aux
.table_len
> 0)
7020 dump_ia64_unwind (& aux
);
7023 free ((char *) aux
.table
);
7025 free ((char *) aux
.info
);
7034 free ((char *) aux
.strtab
);
7037 struct hppa_unw_table_entry
7039 struct absaddr start
;
7041 unsigned int Cannot_unwind
:1; /* 0 */
7042 unsigned int Millicode
:1; /* 1 */
7043 unsigned int Millicode_save_sr0
:1; /* 2 */
7044 unsigned int Region_description
:2; /* 3..4 */
7045 unsigned int reserved1
:1; /* 5 */
7046 unsigned int Entry_SR
:1; /* 6 */
7047 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7048 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7049 unsigned int Args_stored
:1; /* 16 */
7050 unsigned int Variable_Frame
:1; /* 17 */
7051 unsigned int Separate_Package_Body
:1; /* 18 */
7052 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7053 unsigned int Stack_Overflow_Check
:1; /* 20 */
7054 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7055 unsigned int Ada_Region
:1; /* 22 */
7056 unsigned int cxx_info
:1; /* 23 */
7057 unsigned int cxx_try_catch
:1; /* 24 */
7058 unsigned int sched_entry_seq
:1; /* 25 */
7059 unsigned int reserved2
:1; /* 26 */
7060 unsigned int Save_SP
:1; /* 27 */
7061 unsigned int Save_RP
:1; /* 28 */
7062 unsigned int Save_MRP_in_frame
:1; /* 29 */
7063 unsigned int extn_ptr_defined
:1; /* 30 */
7064 unsigned int Cleanup_defined
:1; /* 31 */
7066 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7067 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7068 unsigned int Large_frame
:1; /* 2 */
7069 unsigned int Pseudo_SP_Set
:1; /* 3 */
7070 unsigned int reserved4
:1; /* 4 */
7071 unsigned int Total_frame_size
:27; /* 5..31 */
7074 struct hppa_unw_aux_info
7076 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7077 unsigned long table_len
; /* Length of unwind table. */
7078 bfd_vma seg_base
; /* Starting address of segment. */
7079 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7080 unsigned long nsyms
; /* Number of symbols. */
7081 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7082 unsigned long nfuns
; /* Number of entries in funtab. */
7083 char * strtab
; /* The string table. */
7084 unsigned long strtab_size
; /* Size of string table. */
7088 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7090 struct hppa_unw_table_entry
* tp
;
7091 unsigned long j
, nfuns
;
7093 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7094 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7095 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7096 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7098 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7100 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7103 const char * procname
;
7105 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7106 aux
->strtab_size
, tp
->start
, &procname
,
7109 fputs ("\n<", stdout
);
7113 fputs (procname
, stdout
);
7116 printf ("+%lx", (unsigned long) offset
);
7119 fputs (">: [", stdout
);
7120 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7121 fputc ('-', stdout
);
7122 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7125 #define PF(_m) if (tp->_m) printf (#_m " ");
7126 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7129 PF(Millicode_save_sr0
);
7130 /* PV(Region_description); */
7136 PF(Separate_Package_Body
);
7137 PF(Frame_Extension_Millicode
);
7138 PF(Stack_Overflow_Check
);
7139 PF(Two_Instruction_SP_Increment
);
7143 PF(sched_entry_seq
);
7146 PF(Save_MRP_in_frame
);
7147 PF(extn_ptr_defined
);
7148 PF(Cleanup_defined
);
7149 PF(MPE_XL_interrupt_marker
);
7150 PF(HP_UX_interrupt_marker
);
7153 PV(Total_frame_size
);
7164 slurp_hppa_unwind_table (FILE * file
,
7165 struct hppa_unw_aux_info
* aux
,
7166 Elf_Internal_Shdr
* sec
)
7168 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7169 Elf_Internal_Phdr
* seg
;
7170 struct hppa_unw_table_entry
* tep
;
7171 Elf_Internal_Shdr
* relsec
;
7172 Elf_Internal_Rela
* rela
;
7173 Elf_Internal_Rela
* rp
;
7174 unsigned char * table
;
7176 Elf_Internal_Sym
* sym
;
7177 const char * relname
;
7179 /* First, find the starting address of the segment that includes
7182 if (elf_header
.e_phnum
)
7184 if (! get_program_headers (file
))
7187 for (seg
= program_headers
;
7188 seg
< program_headers
+ elf_header
.e_phnum
;
7191 if (seg
->p_type
!= PT_LOAD
)
7194 if (sec
->sh_addr
>= seg
->p_vaddr
7195 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7197 aux
->seg_base
= seg
->p_vaddr
;
7203 /* Second, build the unwind table from the contents of the unwind
7205 size
= sec
->sh_size
;
7206 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7212 nentries
= size
/ unw_ent_size
;
7213 size
= unw_ent_size
* nentries
;
7215 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7216 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7218 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7220 unsigned int tmp1
, tmp2
;
7222 tep
->start
.section
= SHN_UNDEF
;
7223 tep
->end
.section
= SHN_UNDEF
;
7225 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7226 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7227 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7228 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7230 tep
->start
.offset
+= aux
->seg_base
;
7231 tep
->end
.offset
+= aux
->seg_base
;
7233 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7234 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7235 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7236 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7237 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7238 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7239 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7240 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7241 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7242 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7243 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7244 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7245 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7246 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7247 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7248 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7249 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7250 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7251 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7252 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7253 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7254 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7255 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7256 tep
->Cleanup_defined
= tmp1
& 0x1;
7258 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7259 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7260 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7261 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7262 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7263 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7267 /* Third, apply any relocations to the unwind table. */
7268 for (relsec
= section_headers
;
7269 relsec
< section_headers
+ elf_header
.e_shnum
;
7272 if (relsec
->sh_type
!= SHT_RELA
7273 || relsec
->sh_info
>= elf_header
.e_shnum
7274 || section_headers
+ relsec
->sh_info
!= sec
)
7277 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7281 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7283 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7284 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7286 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7287 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7289 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7293 i
= rp
->r_offset
/ unw_ent_size
;
7295 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7298 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7299 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7302 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7303 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7313 aux
->table_len
= nentries
;
7319 hppa_process_unwind (FILE * file
)
7321 struct hppa_unw_aux_info aux
;
7322 Elf_Internal_Shdr
* unwsec
= NULL
;
7323 Elf_Internal_Shdr
* strsec
;
7324 Elf_Internal_Shdr
* sec
;
7327 if (string_table
== NULL
)
7330 memset (& aux
, 0, sizeof (aux
));
7332 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7334 if (sec
->sh_type
== SHT_SYMTAB
7335 && sec
->sh_link
< elf_header
.e_shnum
)
7337 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7339 strsec
= section_headers
+ sec
->sh_link
;
7340 if (aux
.strtab
!= NULL
)
7342 error (_("Multiple auxillary string tables encountered\n"));
7345 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7348 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7350 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7355 printf (_("\nThere are no unwind sections in this file.\n"));
7357 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7359 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7361 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7362 printable_section_name (sec
),
7363 (unsigned long) sec
->sh_offset
,
7364 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7366 slurp_hppa_unwind_table (file
, &aux
, sec
);
7367 if (aux
.table_len
> 0)
7368 dump_hppa_unwind (&aux
);
7371 free ((char *) aux
.table
);
7379 free ((char *) aux
.strtab
);
7384 unsigned char * data
; /* The unwind data. */
7385 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7386 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7387 unsigned long nrelas
; /* The number of relocations. */
7388 unsigned int rel_type
; /* REL or RELA ? */
7389 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7392 struct arm_unw_aux_info
7394 FILE * file
; /* The file containing the unwind sections. */
7395 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7396 unsigned long nsyms
; /* Number of symbols. */
7397 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7398 unsigned long nfuns
; /* Number of these symbols. */
7399 char * strtab
; /* The file's string table. */
7400 unsigned long strtab_size
; /* Size of string table. */
7404 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7405 bfd_vma fn
, struct absaddr addr
)
7407 const char *procname
;
7410 if (addr
.section
== SHN_UNDEF
)
7413 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7414 aux
->strtab_size
, addr
, &procname
,
7417 print_vma (fn
, PREFIX_HEX
);
7421 fputs (" <", stdout
);
7422 fputs (procname
, stdout
);
7425 printf ("+0x%lx", (unsigned long) sym_offset
);
7426 fputc ('>', stdout
);
7433 arm_free_section (struct arm_section
*arm_sec
)
7435 if (arm_sec
->data
!= NULL
)
7436 free (arm_sec
->data
);
7438 if (arm_sec
->rela
!= NULL
)
7439 free (arm_sec
->rela
);
7442 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7443 cached section and install SEC instead.
7444 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7445 and return its valued in * WORDP, relocating if necessary.
7446 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7447 relocation's offset in ADDR.
7448 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7449 into the string table of the symbol associated with the reloc. If no
7450 reloc was applied store -1 there.
7451 5) Return TRUE upon success, FALSE otherwise. */
7454 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7455 struct arm_section
* arm_sec
,
7456 Elf_Internal_Shdr
* sec
,
7457 bfd_vma word_offset
,
7458 unsigned int * wordp
,
7459 struct absaddr
* addr
,
7462 Elf_Internal_Rela
*rp
;
7463 Elf_Internal_Sym
*sym
;
7464 const char * relname
;
7466 bfd_boolean wrapped
;
7468 if (sec
== NULL
|| arm_sec
== NULL
)
7471 addr
->section
= SHN_UNDEF
;
7474 if (sym_name
!= NULL
)
7475 *sym_name
= (bfd_vma
) -1;
7477 /* If necessary, update the section cache. */
7478 if (sec
!= arm_sec
->sec
)
7480 Elf_Internal_Shdr
*relsec
;
7482 arm_free_section (arm_sec
);
7485 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7486 sec
->sh_size
, _("unwind data"));
7487 arm_sec
->rela
= NULL
;
7488 arm_sec
->nrelas
= 0;
7490 for (relsec
= section_headers
;
7491 relsec
< section_headers
+ elf_header
.e_shnum
;
7494 if (relsec
->sh_info
>= elf_header
.e_shnum
7495 || section_headers
+ relsec
->sh_info
!= sec
7496 /* PR 15745: Check the section type as well. */
7497 || (relsec
->sh_type
!= SHT_REL
7498 && relsec
->sh_type
!= SHT_RELA
))
7501 arm_sec
->rel_type
= relsec
->sh_type
;
7502 if (relsec
->sh_type
== SHT_REL
)
7504 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7506 & arm_sec
->rela
, & arm_sec
->nrelas
))
7509 else /* relsec->sh_type == SHT_RELA */
7511 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7513 & arm_sec
->rela
, & arm_sec
->nrelas
))
7519 arm_sec
->next_rela
= arm_sec
->rela
;
7522 /* If there is no unwind data we can do nothing. */
7523 if (arm_sec
->data
== NULL
)
7526 /* If the offset is invalid then fail. */
7527 if (word_offset
> sec
->sh_size
- 4)
7530 /* Get the word at the required offset. */
7531 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7533 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7534 if (arm_sec
->rela
== NULL
)
7540 /* Look through the relocs to find the one that applies to the provided offset. */
7542 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7544 bfd_vma prelval
, offset
;
7546 if (rp
->r_offset
> word_offset
&& !wrapped
)
7551 if (rp
->r_offset
> word_offset
)
7554 if (rp
->r_offset
& 3)
7556 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7557 (unsigned long) rp
->r_offset
);
7561 if (rp
->r_offset
< word_offset
)
7564 /* PR 17531: file: 027-161405-0.004 */
7565 if (aux
->symtab
== NULL
)
7568 if (arm_sec
->rel_type
== SHT_REL
)
7570 offset
= word
& 0x7fffffff;
7571 if (offset
& 0x40000000)
7572 offset
|= ~ (bfd_vma
) 0x7fffffff;
7574 else if (arm_sec
->rel_type
== SHT_RELA
)
7575 offset
= rp
->r_addend
;
7578 error (_("Unknown section relocation type %d encountered\n"),
7583 /* PR 17531 file: 027-1241568-0.004. */
7584 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7586 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7587 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7591 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7592 offset
+= sym
->st_value
;
7593 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7595 /* Check that we are processing the expected reloc type. */
7596 if (elf_header
.e_machine
== EM_ARM
)
7598 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7599 if (relname
== NULL
)
7601 warn (_("Skipping unknown ARM relocation type: %d\n"),
7602 (int) ELF32_R_TYPE (rp
->r_info
));
7606 if (streq (relname
, "R_ARM_NONE"))
7609 if (! streq (relname
, "R_ARM_PREL31"))
7611 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7615 else if (elf_header
.e_machine
== EM_TI_C6000
)
7617 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7618 if (relname
== NULL
)
7620 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7621 (int) ELF32_R_TYPE (rp
->r_info
));
7625 if (streq (relname
, "R_C6000_NONE"))
7628 if (! streq (relname
, "R_C6000_PREL31"))
7630 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7638 /* This function currently only supports ARM and TI unwinders. */
7639 warn (_("Only TI and ARM unwinders are currently supported\n"));
7643 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7644 addr
->section
= sym
->st_shndx
;
7645 addr
->offset
= offset
;
7648 * sym_name
= sym
->st_name
;
7653 arm_sec
->next_rela
= rp
;
7658 static const char *tic6x_unwind_regnames
[16] =
7660 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7661 "A14", "A13", "A12", "A11", "A10",
7662 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7666 decode_tic6x_unwind_regmask (unsigned int mask
)
7670 for (i
= 12; mask
; mask
>>= 1, i
--)
7674 fputs (tic6x_unwind_regnames
[i
], stdout
);
7676 fputs (", ", stdout
);
7682 if (remaining == 0 && more_words) \
7685 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7686 data_offset, & word, & addr, NULL)) \
7692 #define GET_OP(OP) \
7697 (OP) = word >> 24; \
7702 printf (_("[Truncated opcode]\n")); \
7705 printf ("0x%02x ", OP)
7708 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7710 unsigned int remaining
,
7711 unsigned int more_words
,
7712 bfd_vma data_offset
,
7713 Elf_Internal_Shdr
* data_sec
,
7714 struct arm_section
* data_arm_sec
)
7716 struct absaddr addr
;
7718 /* Decode the unwinding instructions. */
7721 unsigned int op
, op2
;
7730 printf (" 0x%02x ", op
);
7732 if ((op
& 0xc0) == 0x00)
7734 int offset
= ((op
& 0x3f) << 2) + 4;
7736 printf (" vsp = vsp + %d", offset
);
7738 else if ((op
& 0xc0) == 0x40)
7740 int offset
= ((op
& 0x3f) << 2) + 4;
7742 printf (" vsp = vsp - %d", offset
);
7744 else if ((op
& 0xf0) == 0x80)
7747 if (op
== 0x80 && op2
== 0)
7748 printf (_("Refuse to unwind"));
7751 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7756 for (i
= 0; i
< 12; i
++)
7757 if (mask
& (1 << i
))
7763 printf ("r%d", 4 + i
);
7768 else if ((op
& 0xf0) == 0x90)
7770 if (op
== 0x9d || op
== 0x9f)
7771 printf (_(" [Reserved]"));
7773 printf (" vsp = r%d", op
& 0x0f);
7775 else if ((op
& 0xf0) == 0xa0)
7777 int end
= 4 + (op
& 0x07);
7782 for (i
= 4; i
<= end
; i
++)
7798 else if (op
== 0xb0)
7799 printf (_(" finish"));
7800 else if (op
== 0xb1)
7803 if (op2
== 0 || (op2
& 0xf0) != 0)
7804 printf (_("[Spare]"));
7807 unsigned int mask
= op2
& 0x0f;
7812 for (i
= 0; i
< 12; i
++)
7813 if (mask
& (1 << i
))
7824 else if (op
== 0xb2)
7826 unsigned char buf
[9];
7827 unsigned int i
, len
;
7828 unsigned long offset
;
7830 for (i
= 0; i
< sizeof (buf
); i
++)
7833 if ((buf
[i
] & 0x80) == 0)
7836 if (i
== sizeof (buf
))
7837 printf (_("corrupt change to vsp"));
7840 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7841 assert (len
== i
+ 1);
7842 offset
= offset
* 4 + 0x204;
7843 printf ("vsp = vsp + %ld", offset
);
7846 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7848 unsigned int first
, last
;
7855 printf ("pop {D%d", first
);
7857 printf ("-D%d", first
+ last
);
7860 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7862 unsigned int count
= op
& 0x07;
7866 printf ("-D%d", 8 + count
);
7869 else if (op
>= 0xc0 && op
<= 0xc5)
7871 unsigned int count
= op
& 0x07;
7873 printf (" pop {wR10");
7875 printf ("-wR%d", 10 + count
);
7878 else if (op
== 0xc6)
7880 unsigned int first
, last
;
7885 printf ("pop {wR%d", first
);
7887 printf ("-wR%d", first
+ last
);
7890 else if (op
== 0xc7)
7893 if (op2
== 0 || (op2
& 0xf0) != 0)
7894 printf (_("[Spare]"));
7897 unsigned int mask
= op2
& 0x0f;
7902 for (i
= 0; i
< 4; i
++)
7903 if (mask
& (1 << i
))
7909 printf ("wCGR%d", i
);
7915 printf (_(" [unsupported opcode]"));
7921 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7923 unsigned int remaining
,
7924 unsigned int more_words
,
7925 bfd_vma data_offset
,
7926 Elf_Internal_Shdr
* data_sec
,
7927 struct arm_section
* data_arm_sec
)
7929 struct absaddr addr
;
7931 /* Decode the unwinding instructions. */
7934 unsigned int op
, op2
;
7943 printf (" 0x%02x ", op
);
7945 if ((op
& 0xc0) == 0x00)
7947 int offset
= ((op
& 0x3f) << 3) + 8;
7948 printf (" sp = sp + %d", offset
);
7950 else if ((op
& 0xc0) == 0x80)
7953 if (op
== 0x80 && op2
== 0)
7954 printf (_("Refuse to unwind"));
7957 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7959 printf ("pop compact {");
7963 decode_tic6x_unwind_regmask (mask
);
7967 else if ((op
& 0xf0) == 0xc0)
7975 unsigned int offset
;
7979 /* Scan entire instruction first so that GET_OP output is not
7980 interleaved with disassembly. */
7982 for (i
= 0; nregs
< (op
& 0xf); i
++)
7988 regpos
[nregs
].offset
= i
* 2;
7989 regpos
[nregs
].reg
= reg
;
7996 regpos
[nregs
].offset
= i
* 2 + 1;
7997 regpos
[nregs
].reg
= reg
;
8002 printf (_("pop frame {"));
8004 for (i
= i
* 2; i
> 0; i
--)
8006 if (regpos
[reg
].offset
== i
- 1)
8008 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8015 fputs (name
, stdout
);
8022 else if (op
== 0xd0)
8023 printf (" MOV FP, SP");
8024 else if (op
== 0xd1)
8025 printf (" __c6xabi_pop_rts");
8026 else if (op
== 0xd2)
8028 unsigned char buf
[9];
8029 unsigned int i
, len
;
8030 unsigned long offset
;
8032 for (i
= 0; i
< sizeof (buf
); i
++)
8035 if ((buf
[i
] & 0x80) == 0)
8038 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8039 if (i
== sizeof (buf
))
8041 printf ("<corrupt sp adjust>\n");
8042 warn (_("Corrupt stack pointer adjustment detected\n"));
8046 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8047 assert (len
== i
+ 1);
8048 offset
= offset
* 8 + 0x408;
8049 printf (_("sp = sp + %ld"), offset
);
8051 else if ((op
& 0xf0) == 0xe0)
8053 if ((op
& 0x0f) == 7)
8056 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8060 printf (_(" [unsupported opcode]"));
8067 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8071 offset
= word
& 0x7fffffff;
8072 if (offset
& 0x40000000)
8073 offset
|= ~ (bfd_vma
) 0x7fffffff;
8075 if (elf_header
.e_machine
== EM_TI_C6000
)
8078 return offset
+ where
;
8082 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8084 unsigned int remaining
,
8085 bfd_vma data_offset
,
8086 Elf_Internal_Shdr
* data_sec
,
8087 struct arm_section
* data_arm_sec
)
8090 unsigned int more_words
= 0;
8091 struct absaddr addr
;
8092 bfd_vma sym_name
= (bfd_vma
) -1;
8096 /* Fetch the first word.
8097 Note - when decoding an object file the address extracted
8098 here will always be 0. So we also pass in the sym_name
8099 parameter so that we can find the symbol associated with
8100 the personality routine. */
8101 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8102 & word
, & addr
, & sym_name
))
8108 if ((word
& 0x80000000) == 0)
8110 /* Expand prel31 for personality routine. */
8112 const char *procname
;
8114 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8115 printf (_(" Personality routine: "));
8117 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8118 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8120 procname
= aux
->strtab
+ sym_name
;
8121 print_vma (fn
, PREFIX_HEX
);
8124 fputs (" <", stdout
);
8125 fputs (procname
, stdout
);
8126 fputc ('>', stdout
);
8130 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8131 fputc ('\n', stdout
);
8133 /* The GCC personality routines use the standard compact
8134 encoding, starting with one byte giving the number of
8136 if (procname
!= NULL
8137 && (const_strneq (procname
, "__gcc_personality_v0")
8138 || const_strneq (procname
, "__gxx_personality_v0")
8139 || const_strneq (procname
, "__gcj_personality_v0")
8140 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8147 printf (_(" [Truncated data]\n"));
8150 more_words
= word
>> 24;
8160 /* ARM EHABI Section 6.3:
8162 An exception-handling table entry for the compact model looks like:
8166 1 0 index Data for personalityRoutine[index] */
8168 if (elf_header
.e_machine
== EM_ARM
8169 && (word
& 0x70000000))
8170 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8172 per_index
= (word
>> 24) & 0x7f;
8173 printf (_(" Compact model index: %d\n"), per_index
);
8180 else if (per_index
< 3)
8182 more_words
= (word
>> 16) & 0xff;
8188 switch (elf_header
.e_machine
)
8193 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8194 data_offset
, data_sec
, data_arm_sec
);
8198 warn (_("Unknown ARM compact model index encountered\n"));
8199 printf (_(" [reserved]\n"));
8206 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8207 data_offset
, data_sec
, data_arm_sec
);
8209 else if (per_index
< 5)
8211 if (((word
>> 17) & 0x7f) == 0x7f)
8212 printf (_(" Restore stack from frame pointer\n"));
8214 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8215 printf (_(" Registers restored: "));
8217 printf (" (compact) ");
8218 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8220 printf (_(" Return register: %s\n"),
8221 tic6x_unwind_regnames
[word
& 0xf]);
8224 printf (_(" [reserved (%d)]\n"), per_index
);
8228 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8229 elf_header
.e_machine
);
8232 /* Decode the descriptors. Not implemented. */
8236 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8238 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8239 unsigned int i
, exidx_len
;
8240 unsigned long j
, nfuns
;
8242 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8243 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8244 exidx_len
= exidx_sec
->sh_size
/ 8;
8246 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8247 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8248 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8249 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8251 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8253 for (i
= 0; i
< exidx_len
; i
++)
8255 unsigned int exidx_fn
, exidx_entry
;
8256 struct absaddr fn_addr
, entry_addr
;
8259 fputc ('\n', stdout
);
8261 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8262 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8263 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8264 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8267 arm_free_section (& exidx_arm_sec
);
8268 arm_free_section (& extab_arm_sec
);
8272 /* ARM EHABI, Section 5:
8273 An index table entry consists of 2 words.
8274 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8275 if (exidx_fn
& 0x80000000)
8276 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8278 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8280 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8281 fputs (": ", stdout
);
8283 if (exidx_entry
== 1)
8285 print_vma (exidx_entry
, PREFIX_HEX
);
8286 fputs (" [cantunwind]\n", stdout
);
8288 else if (exidx_entry
& 0x80000000)
8290 print_vma (exidx_entry
, PREFIX_HEX
);
8291 fputc ('\n', stdout
);
8292 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8296 bfd_vma table
, table_offset
= 0;
8297 Elf_Internal_Shdr
*table_sec
;
8299 fputs ("@", stdout
);
8300 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8301 print_vma (table
, PREFIX_HEX
);
8304 /* Locate the matching .ARM.extab. */
8305 if (entry_addr
.section
!= SHN_UNDEF
8306 && entry_addr
.section
< elf_header
.e_shnum
)
8308 table_sec
= section_headers
+ entry_addr
.section
;
8309 table_offset
= entry_addr
.offset
;
8313 table_sec
= find_section_by_address (table
);
8314 if (table_sec
!= NULL
)
8315 table_offset
= table
- table_sec
->sh_addr
;
8317 if (table_sec
== NULL
)
8319 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8320 (unsigned long) table
);
8323 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8331 arm_free_section (&exidx_arm_sec
);
8332 arm_free_section (&extab_arm_sec
);
8335 /* Used for both ARM and C6X unwinding tables. */
8338 arm_process_unwind (FILE *file
)
8340 struct arm_unw_aux_info aux
;
8341 Elf_Internal_Shdr
*unwsec
= NULL
;
8342 Elf_Internal_Shdr
*strsec
;
8343 Elf_Internal_Shdr
*sec
;
8345 unsigned int sec_type
;
8347 switch (elf_header
.e_machine
)
8350 sec_type
= SHT_ARM_EXIDX
;
8354 sec_type
= SHT_C6000_UNWIND
;
8358 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8359 elf_header
.e_machine
);
8363 if (string_table
== NULL
)
8366 memset (& aux
, 0, sizeof (aux
));
8369 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8371 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8373 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8375 strsec
= section_headers
+ sec
->sh_link
;
8377 /* PR binutils/17531 file: 011-12666-0.004. */
8378 if (aux
.strtab
!= NULL
)
8380 error (_("Multiple string tables found in file.\n"));
8383 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8384 1, strsec
->sh_size
, _("string table"));
8385 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8387 else if (sec
->sh_type
== sec_type
)
8392 printf (_("\nThere are no unwind sections in this file.\n"));
8394 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8396 if (sec
->sh_type
== sec_type
)
8398 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8399 printable_section_name (sec
),
8400 (unsigned long) sec
->sh_offset
,
8401 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8403 dump_arm_unwind (&aux
, sec
);
8410 free ((char *) aux
.strtab
);
8414 process_unwind (FILE * file
)
8416 struct unwind_handler
8419 void (* handler
)(FILE *);
8422 { EM_ARM
, arm_process_unwind
},
8423 { EM_IA_64
, ia64_process_unwind
},
8424 { EM_PARISC
, hppa_process_unwind
},
8425 { EM_TI_C6000
, arm_process_unwind
},
8433 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8434 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8436 handlers
[i
].handler (file
);
8440 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8441 get_machine_name (elf_header
.e_machine
));
8445 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8447 switch (entry
->d_tag
)
8450 if (entry
->d_un
.d_val
== 0)
8454 static const char * opts
[] =
8456 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8457 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8458 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8459 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8465 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8466 if (entry
->d_un
.d_val
& (1 << cnt
))
8468 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8474 case DT_MIPS_IVERSION
:
8475 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8476 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8480 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8481 /* Note: coded this way so that there is a single string for translation. */
8482 printf (_("<corrupt: %s>"), buf
);
8486 case DT_MIPS_TIME_STAMP
:
8490 time_t atime
= entry
->d_un
.d_val
;
8492 tmp
= gmtime (&atime
);
8493 /* PR 17531: file: 6accc532. */
8495 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8497 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8498 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8499 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8500 printf (_("Time Stamp: %s"), timebuf
);
8504 case DT_MIPS_RLD_VERSION
:
8505 case DT_MIPS_LOCAL_GOTNO
:
8506 case DT_MIPS_CONFLICTNO
:
8507 case DT_MIPS_LIBLISTNO
:
8508 case DT_MIPS_SYMTABNO
:
8509 case DT_MIPS_UNREFEXTNO
:
8510 case DT_MIPS_HIPAGENO
:
8511 case DT_MIPS_DELTA_CLASS_NO
:
8512 case DT_MIPS_DELTA_INSTANCE_NO
:
8513 case DT_MIPS_DELTA_RELOC_NO
:
8514 case DT_MIPS_DELTA_SYM_NO
:
8515 case DT_MIPS_DELTA_CLASSSYM_NO
:
8516 case DT_MIPS_COMPACT_SIZE
:
8517 print_vma (entry
->d_un
.d_ptr
, DEC
);
8521 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8527 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8529 switch (entry
->d_tag
)
8531 case DT_HP_DLD_FLAGS
:
8540 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8541 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8542 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8543 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8544 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8545 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8546 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8547 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8548 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8549 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8550 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8551 { DT_HP_GST
, "HP_GST" },
8552 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8553 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8554 { DT_HP_NODELETE
, "HP_NODELETE" },
8555 { DT_HP_GROUP
, "HP_GROUP" },
8556 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8560 bfd_vma val
= entry
->d_un
.d_val
;
8562 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8563 if (val
& flags
[cnt
].bit
)
8567 fputs (flags
[cnt
].str
, stdout
);
8569 val
^= flags
[cnt
].bit
;
8572 if (val
!= 0 || first
)
8576 print_vma (val
, HEX
);
8582 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8590 /* VMS vs Unix time offset and factor. */
8592 #define VMS_EPOCH_OFFSET 35067168000000000LL
8593 #define VMS_GRANULARITY_FACTOR 10000000
8595 /* Display a VMS time in a human readable format. */
8598 print_vms_time (bfd_int64_t vmstime
)
8603 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8604 tm
= gmtime (&unxtime
);
8605 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8606 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8607 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8612 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8614 switch (entry
->d_tag
)
8616 case DT_IA_64_PLT_RESERVE
:
8617 /* First 3 slots reserved. */
8618 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8620 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8623 case DT_IA_64_VMS_LINKTIME
:
8625 print_vms_time (entry
->d_un
.d_val
);
8629 case DT_IA_64_VMS_LNKFLAGS
:
8630 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8631 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8632 printf (" CALL_DEBUG");
8633 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8634 printf (" NOP0BUFS");
8635 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8636 printf (" P0IMAGE");
8637 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8638 printf (" MKTHREADS");
8639 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8640 printf (" UPCALLS");
8641 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8643 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8644 printf (" INITIALIZE");
8645 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8647 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8648 printf (" EXE_INIT");
8649 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8650 printf (" TBK_IN_IMG");
8651 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8652 printf (" DBG_IN_IMG");
8653 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8654 printf (" TBK_IN_DSF");
8655 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8656 printf (" DBG_IN_DSF");
8657 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8658 printf (" SIGNATURES");
8659 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8660 printf (" REL_SEG_OFF");
8664 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8671 get_32bit_dynamic_section (FILE * file
)
8673 Elf32_External_Dyn
* edyn
;
8674 Elf32_External_Dyn
* ext
;
8675 Elf_Internal_Dyn
* entry
;
8677 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8678 dynamic_size
, _("dynamic section"));
8682 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8683 might not have the luxury of section headers. Look for the DT_NULL
8684 terminator to determine the number of entries. */
8685 for (ext
= edyn
, dynamic_nent
= 0;
8686 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8690 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8694 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8696 if (dynamic_section
== NULL
)
8698 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8699 (unsigned long) dynamic_nent
);
8704 for (ext
= edyn
, entry
= dynamic_section
;
8705 entry
< dynamic_section
+ dynamic_nent
;
8708 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8709 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8718 get_64bit_dynamic_section (FILE * file
)
8720 Elf64_External_Dyn
* edyn
;
8721 Elf64_External_Dyn
* ext
;
8722 Elf_Internal_Dyn
* entry
;
8724 /* Read in the data. */
8725 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8726 dynamic_size
, _("dynamic section"));
8730 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8731 might not have the luxury of section headers. Look for the DT_NULL
8732 terminator to determine the number of entries. */
8733 for (ext
= edyn
, dynamic_nent
= 0;
8734 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8735 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8739 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8743 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8745 if (dynamic_section
== NULL
)
8747 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8748 (unsigned long) dynamic_nent
);
8753 /* Convert from external to internal formats. */
8754 for (ext
= edyn
, entry
= dynamic_section
;
8755 entry
< dynamic_section
+ dynamic_nent
;
8758 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8759 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8768 print_dynamic_flags (bfd_vma flags
)
8776 flag
= flags
& - flags
;
8786 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8787 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8788 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8789 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8790 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8791 default: fputs (_("unknown"), stdout
); break;
8797 /* Parse and display the contents of the dynamic section. */
8800 process_dynamic_section (FILE * file
)
8802 Elf_Internal_Dyn
* entry
;
8804 if (dynamic_size
== 0)
8807 printf (_("\nThere is no dynamic section in this file.\n"));
8814 if (! get_32bit_dynamic_section (file
))
8817 else if (! get_64bit_dynamic_section (file
))
8820 /* Find the appropriate symbol table. */
8821 if (dynamic_symbols
== NULL
)
8823 for (entry
= dynamic_section
;
8824 entry
< dynamic_section
+ dynamic_nent
;
8827 Elf_Internal_Shdr section
;
8829 if (entry
->d_tag
!= DT_SYMTAB
)
8832 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8834 /* Since we do not know how big the symbol table is,
8835 we default to reading in the entire file (!) and
8836 processing that. This is overkill, I know, but it
8838 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8840 if (archive_file_offset
!= 0)
8841 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8844 if (fseek (file
, 0, SEEK_END
))
8845 error (_("Unable to seek to end of file!\n"));
8847 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8851 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8853 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8854 section
.sh_name
= string_table_length
;
8856 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8857 if (num_dynamic_syms
< 1)
8859 error (_("Unable to determine the number of symbols to load\n"));
8865 /* Similarly find a string table. */
8866 if (dynamic_strings
== NULL
)
8868 for (entry
= dynamic_section
;
8869 entry
< dynamic_section
+ dynamic_nent
;
8872 unsigned long offset
;
8875 if (entry
->d_tag
!= DT_STRTAB
)
8878 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8880 /* Since we do not know how big the string table is,
8881 we default to reading in the entire file (!) and
8882 processing that. This is overkill, I know, but it
8885 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8887 if (archive_file_offset
!= 0)
8888 str_tab_len
= archive_file_size
- offset
;
8891 if (fseek (file
, 0, SEEK_END
))
8892 error (_("Unable to seek to end of file\n"));
8893 str_tab_len
= ftell (file
) - offset
;
8896 if (str_tab_len
< 1)
8899 (_("Unable to determine the length of the dynamic string table\n"));
8903 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8905 _("dynamic string table"));
8906 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8911 /* And find the syminfo section if available. */
8912 if (dynamic_syminfo
== NULL
)
8914 unsigned long syminsz
= 0;
8916 for (entry
= dynamic_section
;
8917 entry
< dynamic_section
+ dynamic_nent
;
8920 if (entry
->d_tag
== DT_SYMINENT
)
8922 /* Note: these braces are necessary to avoid a syntax
8923 error from the SunOS4 C compiler. */
8924 /* PR binutils/17531: A corrupt file can trigger this test.
8925 So do not use an assert, instead generate an error message. */
8926 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8927 error (_("Bad value (%d) for SYMINENT entry\n"),
8928 (int) entry
->d_un
.d_val
);
8930 else if (entry
->d_tag
== DT_SYMINSZ
)
8931 syminsz
= entry
->d_un
.d_val
;
8932 else if (entry
->d_tag
== DT_SYMINFO
)
8933 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8937 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8939 Elf_External_Syminfo
* extsyminfo
;
8940 Elf_External_Syminfo
* extsym
;
8941 Elf_Internal_Syminfo
* syminfo
;
8943 /* There is a syminfo section. Read the data. */
8944 extsyminfo
= (Elf_External_Syminfo
*)
8945 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8946 _("symbol information"));
8950 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8951 if (dynamic_syminfo
== NULL
)
8953 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8954 (unsigned long) syminsz
);
8958 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8959 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8960 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8961 ++syminfo
, ++extsym
)
8963 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8964 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8971 if (do_dynamic
&& dynamic_addr
)
8972 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8973 dynamic_addr
, (unsigned long) dynamic_nent
);
8975 printf (_(" Tag Type Name/Value\n"));
8977 for (entry
= dynamic_section
;
8978 entry
< dynamic_section
+ dynamic_nent
;
8986 print_vma (entry
->d_tag
, FULL_HEX
);
8987 dtype
= get_dynamic_type (entry
->d_tag
);
8988 printf (" (%s)%*s", dtype
,
8989 ((is_32bit_elf
? 27 : 19)
8990 - (int) strlen (dtype
)),
8994 switch (entry
->d_tag
)
8998 print_dynamic_flags (entry
->d_un
.d_val
);
9008 switch (entry
->d_tag
)
9011 printf (_("Auxiliary library"));
9015 printf (_("Filter library"));
9019 printf (_("Configuration file"));
9023 printf (_("Dependency audit library"));
9027 printf (_("Audit library"));
9031 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9032 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9036 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9045 printf (_("Flags:"));
9047 if (entry
->d_un
.d_val
== 0)
9048 printf (_(" None\n"));
9051 unsigned long int val
= entry
->d_un
.d_val
;
9053 if (val
& DTF_1_PARINIT
)
9055 printf (" PARINIT");
9056 val
^= DTF_1_PARINIT
;
9058 if (val
& DTF_1_CONFEXP
)
9060 printf (" CONFEXP");
9061 val
^= DTF_1_CONFEXP
;
9064 printf (" %lx", val
);
9073 printf (_("Flags:"));
9075 if (entry
->d_un
.d_val
== 0)
9076 printf (_(" None\n"));
9079 unsigned long int val
= entry
->d_un
.d_val
;
9081 if (val
& DF_P1_LAZYLOAD
)
9083 printf (" LAZYLOAD");
9084 val
^= DF_P1_LAZYLOAD
;
9086 if (val
& DF_P1_GROUPPERM
)
9088 printf (" GROUPPERM");
9089 val
^= DF_P1_GROUPPERM
;
9092 printf (" %lx", val
);
9101 printf (_("Flags:"));
9102 if (entry
->d_un
.d_val
== 0)
9103 printf (_(" None\n"));
9106 unsigned long int val
= entry
->d_un
.d_val
;
9113 if (val
& DF_1_GLOBAL
)
9118 if (val
& DF_1_GROUP
)
9123 if (val
& DF_1_NODELETE
)
9125 printf (" NODELETE");
9126 val
^= DF_1_NODELETE
;
9128 if (val
& DF_1_LOADFLTR
)
9130 printf (" LOADFLTR");
9131 val
^= DF_1_LOADFLTR
;
9133 if (val
& DF_1_INITFIRST
)
9135 printf (" INITFIRST");
9136 val
^= DF_1_INITFIRST
;
9138 if (val
& DF_1_NOOPEN
)
9143 if (val
& DF_1_ORIGIN
)
9148 if (val
& DF_1_DIRECT
)
9153 if (val
& DF_1_TRANS
)
9158 if (val
& DF_1_INTERPOSE
)
9160 printf (" INTERPOSE");
9161 val
^= DF_1_INTERPOSE
;
9163 if (val
& DF_1_NODEFLIB
)
9165 printf (" NODEFLIB");
9166 val
^= DF_1_NODEFLIB
;
9168 if (val
& DF_1_NODUMP
)
9173 if (val
& DF_1_CONFALT
)
9175 printf (" CONFALT");
9176 val
^= DF_1_CONFALT
;
9178 if (val
& DF_1_ENDFILTEE
)
9180 printf (" ENDFILTEE");
9181 val
^= DF_1_ENDFILTEE
;
9183 if (val
& DF_1_DISPRELDNE
)
9185 printf (" DISPRELDNE");
9186 val
^= DF_1_DISPRELDNE
;
9188 if (val
& DF_1_DISPRELPND
)
9190 printf (" DISPRELPND");
9191 val
^= DF_1_DISPRELPND
;
9193 if (val
& DF_1_NODIRECT
)
9195 printf (" NODIRECT");
9196 val
^= DF_1_NODIRECT
;
9198 if (val
& DF_1_IGNMULDEF
)
9200 printf (" IGNMULDEF");
9201 val
^= DF_1_IGNMULDEF
;
9203 if (val
& DF_1_NOKSYMS
)
9205 printf (" NOKSYMS");
9206 val
^= DF_1_NOKSYMS
;
9208 if (val
& DF_1_NOHDR
)
9213 if (val
& DF_1_EDITED
)
9218 if (val
& DF_1_NORELOC
)
9220 printf (" NORELOC");
9221 val
^= DF_1_NORELOC
;
9223 if (val
& DF_1_SYMINTPOSE
)
9225 printf (" SYMINTPOSE");
9226 val
^= DF_1_SYMINTPOSE
;
9228 if (val
& DF_1_GLOBAUDIT
)
9230 printf (" GLOBAUDIT");
9231 val
^= DF_1_GLOBAUDIT
;
9233 if (val
& DF_1_SINGLETON
)
9235 printf (" SINGLETON");
9236 val
^= DF_1_SINGLETON
;
9239 printf (" %lx", val
);
9246 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9248 puts (get_dynamic_type (entry
->d_un
.d_val
));
9268 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9274 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9275 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9281 switch (entry
->d_tag
)
9284 printf (_("Shared library: [%s]"), name
);
9286 if (streq (name
, program_interpreter
))
9287 printf (_(" program interpreter"));
9291 printf (_("Library soname: [%s]"), name
);
9295 printf (_("Library rpath: [%s]"), name
);
9299 printf (_("Library runpath: [%s]"), name
);
9303 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9308 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9321 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9325 case DT_INIT_ARRAYSZ
:
9326 case DT_FINI_ARRAYSZ
:
9327 case DT_GNU_CONFLICTSZ
:
9328 case DT_GNU_LIBLISTSZ
:
9331 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9332 printf (_(" (bytes)\n"));
9342 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9355 if (entry
->d_tag
== DT_USED
9356 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9358 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9362 printf (_("Not needed object: [%s]\n"), name
);
9367 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9373 /* The value of this entry is ignored. */
9378 case DT_GNU_PRELINKED
:
9382 time_t atime
= entry
->d_un
.d_val
;
9384 tmp
= gmtime (&atime
);
9385 /* PR 17533 file: 041-1244816-0.004. */
9387 printf (_("<corrupt time val: %lx"),
9388 (unsigned long) atime
);
9390 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9391 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9392 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9398 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9401 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9407 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9408 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9413 switch (elf_header
.e_machine
)
9416 case EM_MIPS_RS3_LE
:
9417 dynamic_section_mips_val (entry
);
9420 dynamic_section_parisc_val (entry
);
9423 dynamic_section_ia64_val (entry
);
9426 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9438 get_ver_flags (unsigned int flags
)
9440 static char buff
[32];
9447 if (flags
& VER_FLG_BASE
)
9448 strcat (buff
, "BASE ");
9450 if (flags
& VER_FLG_WEAK
)
9452 if (flags
& VER_FLG_BASE
)
9453 strcat (buff
, "| ");
9455 strcat (buff
, "WEAK ");
9458 if (flags
& VER_FLG_INFO
)
9460 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9461 strcat (buff
, "| ");
9463 strcat (buff
, "INFO ");
9466 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9467 strcat (buff
, _("| <unknown>"));
9472 /* Display the contents of the version sections. */
9475 process_version_sections (FILE * file
)
9477 Elf_Internal_Shdr
* section
;
9484 for (i
= 0, section
= section_headers
;
9485 i
< elf_header
.e_shnum
;
9488 switch (section
->sh_type
)
9490 case SHT_GNU_verdef
:
9492 Elf_External_Verdef
* edefs
;
9499 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9500 printable_section_name (section
),
9503 printf (_(" Addr: 0x"));
9504 printf_vma (section
->sh_addr
);
9505 printf (_(" Offset: %#08lx Link: %u (%s)"),
9506 (unsigned long) section
->sh_offset
, section
->sh_link
,
9507 printable_section_name_from_index (section
->sh_link
));
9509 edefs
= (Elf_External_Verdef
*)
9510 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9511 _("version definition section"));
9514 endbuf
= (char *) edefs
+ section
->sh_size
;
9516 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9519 Elf_External_Verdef
* edef
;
9520 Elf_Internal_Verdef ent
;
9521 Elf_External_Verdaux
* eaux
;
9522 Elf_Internal_Verdaux aux
;
9526 /* Check for very large indicies. */
9527 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9530 vstart
= ((char *) edefs
) + idx
;
9531 if (vstart
+ sizeof (*edef
) > endbuf
)
9534 edef
= (Elf_External_Verdef
*) vstart
;
9536 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9537 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9538 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9539 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9540 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9541 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9542 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9544 printf (_(" %#06x: Rev: %d Flags: %s"),
9545 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9547 printf (_(" Index: %d Cnt: %d "),
9548 ent
.vd_ndx
, ent
.vd_cnt
);
9550 /* Check for overflow. */
9551 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9554 vstart
+= ent
.vd_aux
;
9556 eaux
= (Elf_External_Verdaux
*) vstart
;
9558 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9559 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9561 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9562 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9564 printf (_("Name index: %ld\n"), aux
.vda_name
);
9566 isum
= idx
+ ent
.vd_aux
;
9568 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9570 /* Check for overflow. */
9571 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9574 isum
+= aux
.vda_next
;
9575 vstart
+= aux
.vda_next
;
9577 eaux
= (Elf_External_Verdaux
*) vstart
;
9578 if (vstart
+ sizeof (*eaux
) > endbuf
)
9581 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9582 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9584 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9585 printf (_(" %#06x: Parent %d: %s\n"),
9586 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9588 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9589 isum
, j
, aux
.vda_name
);
9593 printf (_(" Version def aux past end of section\n"));
9595 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9596 if (idx
+ ent
.vd_next
<= idx
)
9602 if (cnt
< section
->sh_info
)
9603 printf (_(" Version definition past end of section\n"));
9609 case SHT_GNU_verneed
:
9611 Elf_External_Verneed
* eneed
;
9618 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9619 printable_section_name (section
), section
->sh_info
);
9621 printf (_(" Addr: 0x"));
9622 printf_vma (section
->sh_addr
);
9623 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9624 (unsigned long) section
->sh_offset
, section
->sh_link
,
9625 printable_section_name_from_index (section
->sh_link
));
9627 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9628 section
->sh_offset
, 1,
9630 _("Version Needs section"));
9633 endbuf
= (char *) eneed
+ section
->sh_size
;
9635 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9637 Elf_External_Verneed
* entry
;
9638 Elf_Internal_Verneed ent
;
9643 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9646 vstart
= ((char *) eneed
) + idx
;
9647 if (vstart
+ sizeof (*entry
) > endbuf
)
9650 entry
= (Elf_External_Verneed
*) vstart
;
9652 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9653 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9654 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9655 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9656 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9658 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9660 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9661 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9663 printf (_(" File: %lx"), ent
.vn_file
);
9665 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9667 /* Check for overflow. */
9668 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9670 vstart
+= ent
.vn_aux
;
9672 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9674 Elf_External_Vernaux
* eaux
;
9675 Elf_Internal_Vernaux aux
;
9677 if (vstart
+ sizeof (*eaux
) > endbuf
)
9679 eaux
= (Elf_External_Vernaux
*) vstart
;
9681 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9682 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9683 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9684 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9685 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9687 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9688 printf (_(" %#06x: Name: %s"),
9689 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9691 printf (_(" %#06x: Name index: %lx"),
9692 isum
, aux
.vna_name
);
9694 printf (_(" Flags: %s Version: %d\n"),
9695 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9697 /* Check for overflow. */
9698 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9699 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9701 warn (_("Invalid vna_next field of %lx\n"),
9706 isum
+= aux
.vna_next
;
9707 vstart
+= aux
.vna_next
;
9711 warn (_("Missing Version Needs auxillary information\n"));
9713 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9715 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9716 cnt
= section
->sh_info
;
9722 if (cnt
< section
->sh_info
)
9723 warn (_("Missing Version Needs information\n"));
9729 case SHT_GNU_versym
:
9731 Elf_Internal_Shdr
* link_section
;
9734 unsigned char * edata
;
9735 unsigned short * data
;
9737 Elf_Internal_Sym
* symbols
;
9738 Elf_Internal_Shdr
* string_sec
;
9739 unsigned long num_syms
;
9742 if (section
->sh_link
>= elf_header
.e_shnum
)
9745 link_section
= section_headers
+ section
->sh_link
;
9746 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9748 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9753 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9754 if (symbols
== NULL
)
9757 string_sec
= section_headers
+ link_section
->sh_link
;
9759 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9760 string_sec
->sh_size
,
9761 _("version string table"));
9768 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9769 printable_section_name (section
), (unsigned long) total
);
9771 printf (_(" Addr: "));
9772 printf_vma (section
->sh_addr
);
9773 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9774 (unsigned long) section
->sh_offset
, section
->sh_link
,
9775 printable_section_name (link_section
));
9777 off
= offset_from_vma (file
,
9778 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9779 total
* sizeof (short));
9780 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9782 _("version symbol data"));
9790 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9792 for (cnt
= total
; cnt
--;)
9793 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9798 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9801 int check_def
, check_need
;
9804 printf (" %03x:", cnt
);
9806 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9807 switch (data
[cnt
+ j
])
9810 fputs (_(" 0 (*local*) "), stdout
);
9814 fputs (_(" 1 (*global*) "), stdout
);
9818 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9819 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9821 /* If this index value is greater than the size of the symbols
9822 array, break to avoid an out-of-bounds read. */
9823 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9825 warn (_("invalid index into symbol array\n"));
9831 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9832 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9835 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9842 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9844 Elf_Internal_Verneed ivn
;
9845 unsigned long offset
;
9847 offset
= offset_from_vma
9848 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9849 sizeof (Elf_External_Verneed
));
9853 Elf_Internal_Vernaux ivna
;
9854 Elf_External_Verneed evn
;
9855 Elf_External_Vernaux evna
;
9856 unsigned long a_off
;
9858 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9859 _("version need")) == NULL
)
9862 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9863 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9865 a_off
= offset
+ ivn
.vn_aux
;
9869 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9870 1, _("version need aux (2)")) == NULL
)
9877 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9878 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9881 a_off
+= ivna
.vna_next
;
9883 while (ivna
.vna_other
!= data
[cnt
+ j
]
9884 && ivna
.vna_next
!= 0);
9886 if (ivna
.vna_other
== data
[cnt
+ j
])
9888 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9890 if (ivna
.vna_name
>= string_sec
->sh_size
)
9891 name
= _("*invalid*");
9893 name
= strtab
+ ivna
.vna_name
;
9894 nn
+= printf ("(%s%-*s",
9896 12 - (int) strlen (name
),
9902 offset
+= ivn
.vn_next
;
9904 while (ivn
.vn_next
);
9907 if (check_def
&& data
[cnt
+ j
] != 0x8001
9908 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9910 Elf_Internal_Verdef ivd
;
9911 Elf_External_Verdef evd
;
9912 unsigned long offset
;
9914 offset
= offset_from_vma
9915 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9920 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9921 _("version def")) == NULL
)
9924 /* PR 17531: file: 046-1082287-0.004. */
9925 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9930 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9931 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9934 offset
+= ivd
.vd_next
;
9936 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9937 && ivd
.vd_next
!= 0);
9939 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9941 Elf_External_Verdaux evda
;
9942 Elf_Internal_Verdaux ivda
;
9944 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9946 if (get_data (&evda
, file
,
9947 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9949 _("version def aux")) == NULL
)
9952 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9954 if (ivda
.vda_name
>= string_sec
->sh_size
)
9955 name
= _("*invalid*");
9957 name
= strtab
+ ivda
.vda_name
;
9958 nn
+= printf ("(%s%-*s",
9960 12 - (int) strlen (name
),
9966 printf ("%*c", 18 - nn
, ' ');
9984 printf (_("\nNo version information found in this file.\n"));
9990 get_symbol_binding (unsigned int binding
)
9992 static char buff
[32];
9996 case STB_LOCAL
: return "LOCAL";
9997 case STB_GLOBAL
: return "GLOBAL";
9998 case STB_WEAK
: return "WEAK";
10000 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10001 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10003 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10005 if (binding
== STB_GNU_UNIQUE
10006 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10007 /* GNU is still using the default value 0. */
10008 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10010 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10013 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10018 static const char *
10019 get_symbol_type (unsigned int type
)
10021 static char buff
[32];
10025 case STT_NOTYPE
: return "NOTYPE";
10026 case STT_OBJECT
: return "OBJECT";
10027 case STT_FUNC
: return "FUNC";
10028 case STT_SECTION
: return "SECTION";
10029 case STT_FILE
: return "FILE";
10030 case STT_COMMON
: return "COMMON";
10031 case STT_TLS
: return "TLS";
10032 case STT_RELC
: return "RELC";
10033 case STT_SRELC
: return "SRELC";
10035 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10037 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10038 return "THUMB_FUNC";
10040 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10043 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10044 return "PARISC_MILLI";
10046 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10048 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10050 if (elf_header
.e_machine
== EM_PARISC
)
10052 if (type
== STT_HP_OPAQUE
)
10053 return "HP_OPAQUE";
10054 if (type
== STT_HP_STUB
)
10058 if (type
== STT_GNU_IFUNC
10059 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10060 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10061 /* GNU is still using the default value 0. */
10062 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10065 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10068 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10073 static const char *
10074 get_symbol_visibility (unsigned int visibility
)
10076 switch (visibility
)
10078 case STV_DEFAULT
: return "DEFAULT";
10079 case STV_INTERNAL
: return "INTERNAL";
10080 case STV_HIDDEN
: return "HIDDEN";
10081 case STV_PROTECTED
: return "PROTECTED";
10083 error (_("Unrecognized visibility value: %u"), visibility
);
10084 return _("<unknown>");
10088 static const char *
10089 get_mips_symbol_other (unsigned int other
)
10099 case STO_MICROMIPS
:
10100 return "MICROMIPS";
10101 case STO_MICROMIPS
| STO_MIPS_PIC
:
10102 return "MICROMIPS, MIPS PIC";
10110 static const char *
10111 get_ia64_symbol_other (unsigned int other
)
10113 if (is_ia64_vms ())
10115 static char res
[32];
10119 /* Function types is for images and .STB files only. */
10120 switch (elf_header
.e_type
)
10124 switch (VMS_ST_FUNC_TYPE (other
))
10126 case VMS_SFT_CODE_ADDR
:
10127 strcat (res
, " CA");
10129 case VMS_SFT_SYMV_IDX
:
10130 strcat (res
, " VEC");
10133 strcat (res
, " FD");
10135 case VMS_SFT_RESERVE
:
10136 strcat (res
, " RSV");
10139 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10140 VMS_ST_FUNC_TYPE (other
));
10141 strcat (res
, " <unknown>");
10148 switch (VMS_ST_LINKAGE (other
))
10150 case VMS_STL_IGNORE
:
10151 strcat (res
, " IGN");
10153 case VMS_STL_RESERVE
:
10154 strcat (res
, " RSV");
10157 strcat (res
, " STD");
10160 strcat (res
, " LNK");
10163 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10164 VMS_ST_LINKAGE (other
));
10165 strcat (res
, " <unknown>");
10177 static const char *
10178 get_ppc64_symbol_other (unsigned int other
)
10180 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10182 static char buf
[32];
10183 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10184 PPC64_LOCAL_ENTRY_OFFSET (other
));
10190 static const char *
10191 get_symbol_other (unsigned int other
)
10193 const char * result
= NULL
;
10194 static char buff
[32];
10199 switch (elf_header
.e_machine
)
10202 result
= get_mips_symbol_other (other
);
10205 result
= get_ia64_symbol_other (other
);
10208 result
= get_ppc64_symbol_other (other
);
10217 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10221 static const char *
10222 get_symbol_index_type (unsigned int type
)
10224 static char buff
[32];
10228 case SHN_UNDEF
: return "UND";
10229 case SHN_ABS
: return "ABS";
10230 case SHN_COMMON
: return "COM";
10232 if (type
== SHN_IA_64_ANSI_COMMON
10233 && elf_header
.e_machine
== EM_IA_64
10234 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10236 else if ((elf_header
.e_machine
== EM_X86_64
10237 || elf_header
.e_machine
== EM_L1OM
10238 || elf_header
.e_machine
== EM_K1OM
)
10239 && type
== SHN_X86_64_LCOMMON
)
10240 return "LARGE_COM";
10241 else if ((type
== SHN_MIPS_SCOMMON
10242 && elf_header
.e_machine
== EM_MIPS
)
10243 || (type
== SHN_TIC6X_SCOMMON
10244 && elf_header
.e_machine
== EM_TI_C6000
))
10246 else if (type
== SHN_MIPS_SUNDEFINED
10247 && elf_header
.e_machine
== EM_MIPS
)
10249 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10250 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10251 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10252 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10253 else if (type
>= SHN_LORESERVE
)
10254 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10255 else if (type
>= elf_header
.e_shnum
)
10256 sprintf (buff
, _("bad section index[%3d]"), type
);
10258 sprintf (buff
, "%3d", type
);
10266 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10268 unsigned char * e_data
;
10271 /* If the size_t type is smaller than the bfd_size_type, eg because
10272 you are building a 32-bit tool on a 64-bit host, then make sure
10273 that when (number) is cast to (size_t) no information is lost. */
10274 if (sizeof (size_t) < sizeof (bfd_size_type
)
10275 && (bfd_size_type
) ((size_t) number
) != number
)
10277 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10278 (unsigned long long) number
, ent_size
);
10282 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10283 attempting to allocate memory when the read is bound to fail. */
10284 if (ent_size
* number
> current_file_size
)
10286 error (_("Invalid number of dynamic entries: %llu\n"),
10287 (unsigned long long) number
);
10291 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10292 if (e_data
== NULL
)
10294 error (_("Out of memory reading %llu dynamic entries\n"),
10295 (unsigned long long) number
);
10299 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10301 error (_("Unable to read in %llu bytes of dynamic data\n"),
10302 (unsigned long long) (number
* ent_size
));
10307 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10308 if (i_data
== NULL
)
10310 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10311 (unsigned long long) number
);
10317 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10325 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10327 Elf_Internal_Sym
* psym
;
10330 n
= print_vma (si
, DEC_5
);
10332 fputs (&" "[n
], stdout
);
10333 printf (" %3lu: ", hn
);
10335 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10337 printf (_("<No info available for dynamic symbol number %lu>\n"),
10338 (unsigned long) si
);
10342 psym
= dynamic_symbols
+ si
;
10343 print_vma (psym
->st_value
, LONG_HEX
);
10345 print_vma (psym
->st_size
, DEC_5
);
10347 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10348 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10349 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10350 /* Check to see if any other bits in the st_other field are set.
10351 Note - displaying this information disrupts the layout of the
10352 table being generated, but for the moment this case is very
10354 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10355 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10356 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10357 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10358 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10360 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10364 static const char *
10365 get_symbol_version_string (FILE *file
, int is_dynsym
,
10366 const char *strtab
,
10367 unsigned long int strtab_size
,
10368 unsigned int si
, Elf_Internal_Sym
*psym
,
10369 enum versioned_symbol_info
*sym_info
,
10370 unsigned short *vna_other
)
10372 const char *version_string
= NULL
;
10375 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10377 unsigned char data
[2];
10378 unsigned short vers_data
;
10379 unsigned long offset
;
10383 offset
= offset_from_vma
10384 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10385 sizeof data
+ si
* sizeof (vers_data
));
10387 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10388 sizeof (data
), 1, _("version data")) == NULL
)
10391 vers_data
= byte_get (data
, 2);
10393 is_nobits
= (section_headers
!= NULL
10394 && psym
->st_shndx
< elf_header
.e_shnum
10395 && section_headers
[psym
->st_shndx
].sh_type
10398 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10400 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10402 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10403 && (is_nobits
|| ! check_def
))
10405 Elf_External_Verneed evn
;
10406 Elf_Internal_Verneed ivn
;
10407 Elf_Internal_Vernaux ivna
;
10409 /* We must test both. */
10410 offset
= offset_from_vma
10411 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10416 unsigned long vna_off
;
10418 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10419 _("version need")) == NULL
)
10422 ivna
.vna_other
= 0;
10427 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10428 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10430 vna_off
= offset
+ ivn
.vn_aux
;
10434 Elf_External_Vernaux evna
;
10436 if (get_data (&evna
, file
, vna_off
,
10438 _("version need aux (3)")) == NULL
)
10441 ivna
.vna_other
= 0;
10446 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10447 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10448 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10451 vna_off
+= ivna
.vna_next
;
10453 while (ivna
.vna_other
!= vers_data
10454 && ivna
.vna_next
!= 0);
10456 if (ivna
.vna_other
== vers_data
)
10459 offset
+= ivn
.vn_next
;
10461 while (ivn
.vn_next
!= 0);
10463 if (ivna
.vna_other
== vers_data
)
10465 *sym_info
= symbol_undefined
;
10466 *vna_other
= ivna
.vna_other
;
10467 version_string
= (ivna
.vna_name
< strtab_size
10468 ? strtab
+ ivna
.vna_name
10472 else if (! is_nobits
)
10473 error (_("bad dynamic symbol\n"));
10480 if (vers_data
!= 0x8001
10481 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10483 Elf_Internal_Verdef ivd
;
10484 Elf_Internal_Verdaux ivda
;
10485 Elf_External_Verdaux evda
;
10488 off
= offset_from_vma
10490 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10491 sizeof (Elf_External_Verdef
));
10495 Elf_External_Verdef evd
;
10497 if (get_data (&evd
, file
, off
, sizeof (evd
),
10498 1, _("version def")) == NULL
)
10506 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10507 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10508 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10511 off
+= ivd
.vd_next
;
10513 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10514 && ivd
.vd_next
!= 0);
10516 off
-= ivd
.vd_next
;
10519 if (get_data (&evda
, file
, off
, sizeof (evda
),
10520 1, _("version def aux")) == NULL
)
10521 return version_string
;
10523 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10525 if (psym
->st_name
!= ivda
.vda_name
)
10527 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10528 ? symbol_hidden
: symbol_public
);
10529 version_string
= (ivda
.vda_name
< strtab_size
10530 ? strtab
+ ivda
.vda_name
10537 return version_string
;
10540 /* Dump the symbol table. */
10542 process_symbol_table (FILE * file
)
10544 Elf_Internal_Shdr
* section
;
10545 bfd_size_type nbuckets
= 0;
10546 bfd_size_type nchains
= 0;
10547 bfd_vma
* buckets
= NULL
;
10548 bfd_vma
* chains
= NULL
;
10549 bfd_vma ngnubuckets
= 0;
10550 bfd_vma
* gnubuckets
= NULL
;
10551 bfd_vma
* gnuchains
= NULL
;
10552 bfd_vma gnusymidx
= 0;
10553 bfd_size_type ngnuchains
= 0;
10555 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10558 if (dynamic_info
[DT_HASH
]
10560 || (do_using_dynamic
10562 && dynamic_strings
!= NULL
)))
10564 unsigned char nb
[8];
10565 unsigned char nc
[8];
10566 unsigned int hash_ent_size
= 4;
10568 if ((elf_header
.e_machine
== EM_ALPHA
10569 || elf_header
.e_machine
== EM_S390
10570 || elf_header
.e_machine
== EM_S390_OLD
)
10571 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10575 (archive_file_offset
10576 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10577 sizeof nb
+ sizeof nc
)),
10580 error (_("Unable to seek to start of dynamic information\n"));
10584 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10586 error (_("Failed to read in number of buckets\n"));
10590 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10592 error (_("Failed to read in number of chains\n"));
10596 nbuckets
= byte_get (nb
, hash_ent_size
);
10597 nchains
= byte_get (nc
, hash_ent_size
);
10599 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10600 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10603 if (buckets
== NULL
|| chains
== NULL
)
10605 if (do_using_dynamic
)
10616 if (dynamic_info_DT_GNU_HASH
10618 || (do_using_dynamic
10620 && dynamic_strings
!= NULL
)))
10622 unsigned char nb
[16];
10623 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10624 bfd_vma buckets_vma
;
10627 (archive_file_offset
10628 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10632 error (_("Unable to seek to start of dynamic information\n"));
10636 if (fread (nb
, 16, 1, file
) != 1)
10638 error (_("Failed to read in number of buckets\n"));
10642 ngnubuckets
= byte_get (nb
, 4);
10643 gnusymidx
= byte_get (nb
+ 4, 4);
10644 bitmaskwords
= byte_get (nb
+ 8, 4);
10645 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10647 buckets_vma
+= bitmaskwords
* 4;
10649 buckets_vma
+= bitmaskwords
* 8;
10652 (archive_file_offset
10653 + offset_from_vma (file
, buckets_vma
, 4)),
10656 error (_("Unable to seek to start of dynamic information\n"));
10660 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10662 if (gnubuckets
== NULL
)
10665 for (i
= 0; i
< ngnubuckets
; i
++)
10666 if (gnubuckets
[i
] != 0)
10668 if (gnubuckets
[i
] < gnusymidx
)
10671 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10672 maxchain
= gnubuckets
[i
];
10675 if (maxchain
== 0xffffffff)
10678 maxchain
-= gnusymidx
;
10681 (archive_file_offset
10682 + offset_from_vma (file
, buckets_vma
10683 + 4 * (ngnubuckets
+ maxchain
), 4)),
10686 error (_("Unable to seek to start of dynamic information\n"));
10692 if (fread (nb
, 4, 1, file
) != 1)
10694 error (_("Failed to determine last chain length\n"));
10698 if (maxchain
+ 1 == 0)
10703 while ((byte_get (nb
, 4) & 1) == 0);
10706 (archive_file_offset
10707 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10710 error (_("Unable to seek to start of dynamic information\n"));
10714 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10715 ngnuchains
= maxchain
;
10718 if (gnuchains
== NULL
)
10723 if (do_using_dynamic
)
10728 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10730 && do_using_dynamic
10731 && dynamic_strings
!= NULL
10732 && dynamic_symbols
!= NULL
)
10736 if (dynamic_info
[DT_HASH
])
10740 printf (_("\nSymbol table for image:\n"));
10742 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10744 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10746 for (hn
= 0; hn
< nbuckets
; hn
++)
10751 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10752 print_dynamic_symbol (si
, hn
);
10756 if (dynamic_info_DT_GNU_HASH
)
10758 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10760 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10762 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10764 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10765 if (gnubuckets
[hn
] != 0)
10767 bfd_vma si
= gnubuckets
[hn
];
10768 bfd_vma off
= si
- gnusymidx
;
10772 print_dynamic_symbol (si
, hn
);
10775 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10779 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10780 && section_headers
!= NULL
)
10784 for (i
= 0, section
= section_headers
;
10785 i
< elf_header
.e_shnum
;
10789 char * strtab
= NULL
;
10790 unsigned long int strtab_size
= 0;
10791 Elf_Internal_Sym
* symtab
;
10792 Elf_Internal_Sym
* psym
;
10793 unsigned long num_syms
;
10795 if ((section
->sh_type
!= SHT_SYMTAB
10796 && section
->sh_type
!= SHT_DYNSYM
)
10798 && section
->sh_type
== SHT_SYMTAB
))
10801 if (section
->sh_entsize
== 0)
10803 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10804 printable_section_name (section
));
10808 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10809 printable_section_name (section
),
10810 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10813 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10815 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10817 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10818 if (symtab
== NULL
)
10821 if (section
->sh_link
== elf_header
.e_shstrndx
)
10823 strtab
= string_table
;
10824 strtab_size
= string_table_length
;
10826 else if (section
->sh_link
< elf_header
.e_shnum
)
10828 Elf_Internal_Shdr
* string_sec
;
10830 string_sec
= section_headers
+ section
->sh_link
;
10832 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10833 1, string_sec
->sh_size
,
10834 _("string table"));
10835 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10838 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10840 const char *version_string
;
10841 enum versioned_symbol_info sym_info
;
10842 unsigned short vna_other
;
10844 printf ("%6d: ", si
);
10845 print_vma (psym
->st_value
, LONG_HEX
);
10847 print_vma (psym
->st_size
, DEC_5
);
10848 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10849 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10850 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10851 /* Check to see if any other bits in the st_other field are set.
10852 Note - displaying this information disrupts the layout of the
10853 table being generated, but for the moment this case is very rare. */
10854 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10855 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10856 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10857 print_symbol (25, psym
->st_name
< strtab_size
10858 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10861 = get_symbol_version_string (file
,
10862 section
->sh_type
== SHT_DYNSYM
,
10863 strtab
, strtab_size
, si
,
10864 psym
, &sym_info
, &vna_other
);
10865 if (version_string
)
10867 if (sym_info
== symbol_undefined
)
10868 printf ("@%s (%d)", version_string
, vna_other
);
10870 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10878 if (strtab
!= string_table
)
10884 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10886 if (do_histogram
&& buckets
!= NULL
)
10888 unsigned long * lengths
;
10889 unsigned long * counts
;
10892 unsigned long maxlength
= 0;
10893 unsigned long nzero_counts
= 0;
10894 unsigned long nsyms
= 0;
10895 unsigned long chained
;
10897 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10898 (unsigned long) nbuckets
);
10900 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10901 if (lengths
== NULL
)
10903 error (_("Out of memory allocating space for histogram buckets\n"));
10907 printf (_(" Length Number %% of total Coverage\n"));
10908 for (hn
= 0; hn
< nbuckets
; ++hn
)
10910 for (si
= buckets
[hn
], chained
= 0;
10911 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10912 si
= chains
[si
], ++chained
)
10915 if (maxlength
< ++lengths
[hn
])
10919 /* PR binutils/17531: A corrupt binary could contain broken
10920 histogram data. Do not go into an infinite loop trying
10922 if (chained
> nchains
)
10924 error (_("histogram chain is corrupt\n"));
10929 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10930 if (counts
== NULL
)
10933 error (_("Out of memory allocating space for histogram counts\n"));
10937 for (hn
= 0; hn
< nbuckets
; ++hn
)
10938 ++counts
[lengths
[hn
]];
10943 printf (" 0 %-10lu (%5.1f%%)\n",
10944 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10945 for (i
= 1; i
<= maxlength
; ++i
)
10947 nzero_counts
+= counts
[i
] * i
;
10948 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10949 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10950 (nzero_counts
* 100.0) / nsyms
);
10958 if (buckets
!= NULL
)
10964 if (do_histogram
&& gnubuckets
!= NULL
)
10966 unsigned long * lengths
;
10967 unsigned long * counts
;
10969 unsigned long maxlength
= 0;
10970 unsigned long nzero_counts
= 0;
10971 unsigned long nsyms
= 0;
10973 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10974 (unsigned long) ngnubuckets
);
10976 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10977 if (lengths
== NULL
)
10979 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10983 printf (_(" Length Number %% of total Coverage\n"));
10985 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10986 if (gnubuckets
[hn
] != 0)
10988 bfd_vma off
, length
= 1;
10990 for (off
= gnubuckets
[hn
] - gnusymidx
;
10991 /* PR 17531 file: 010-77222-0.004. */
10992 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10995 lengths
[hn
] = length
;
10996 if (length
> maxlength
)
10997 maxlength
= length
;
11001 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11002 if (counts
== NULL
)
11005 error (_("Out of memory allocating space for gnu histogram counts\n"));
11009 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11010 ++counts
[lengths
[hn
]];
11012 if (ngnubuckets
> 0)
11015 printf (" 0 %-10lu (%5.1f%%)\n",
11016 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11017 for (j
= 1; j
<= maxlength
; ++j
)
11019 nzero_counts
+= counts
[j
] * j
;
11020 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11021 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11022 (nzero_counts
* 100.0) / nsyms
);
11036 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11040 if (dynamic_syminfo
== NULL
11042 /* No syminfo, this is ok. */
11045 /* There better should be a dynamic symbol section. */
11046 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11050 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11051 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11053 printf (_(" Num: Name BoundTo Flags\n"));
11054 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11056 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11058 printf ("%4d: ", i
);
11059 if (i
>= num_dynamic_syms
)
11060 printf (_("<corrupt index>"));
11061 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11062 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11064 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11067 switch (dynamic_syminfo
[i
].si_boundto
)
11069 case SYMINFO_BT_SELF
:
11070 fputs ("SELF ", stdout
);
11072 case SYMINFO_BT_PARENT
:
11073 fputs ("PARENT ", stdout
);
11076 if (dynamic_syminfo
[i
].si_boundto
> 0
11077 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11078 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11080 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11084 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11088 if (flags
& SYMINFO_FLG_DIRECT
)
11089 printf (" DIRECT");
11090 if (flags
& SYMINFO_FLG_PASSTHRU
)
11091 printf (" PASSTHRU");
11092 if (flags
& SYMINFO_FLG_COPY
)
11094 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11095 printf (" LAZYLOAD");
11103 /* Check to see if the given reloc needs to be handled in a target specific
11104 manner. If so then process the reloc and return TRUE otherwise return
11108 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11109 unsigned char * start
,
11110 Elf_Internal_Sym
* symtab
)
11112 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11114 switch (elf_header
.e_machine
)
11117 case EM_MSP430_OLD
:
11119 static Elf_Internal_Sym
* saved_sym
= NULL
;
11121 switch (reloc_type
)
11123 case 10: /* R_MSP430_SYM_DIFF */
11124 if (uses_msp430x_relocs ())
11126 case 21: /* R_MSP430X_SYM_DIFF */
11127 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11130 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11131 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11132 goto handle_sym_diff
;
11134 case 5: /* R_MSP430_16_BYTE */
11135 case 9: /* R_MSP430_8 */
11136 if (uses_msp430x_relocs ())
11138 goto handle_sym_diff
;
11140 case 2: /* R_MSP430_ABS16 */
11141 case 15: /* R_MSP430X_ABS16 */
11142 if (! uses_msp430x_relocs ())
11144 goto handle_sym_diff
;
11147 if (saved_sym
!= NULL
)
11151 value
= reloc
->r_addend
11152 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11153 - saved_sym
->st_value
);
11155 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11163 if (saved_sym
!= NULL
)
11164 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11171 case EM_CYGNUS_MN10300
:
11173 static Elf_Internal_Sym
* saved_sym
= NULL
;
11175 switch (reloc_type
)
11177 case 34: /* R_MN10300_ALIGN */
11179 case 33: /* R_MN10300_SYM_DIFF */
11180 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11182 case 1: /* R_MN10300_32 */
11183 case 2: /* R_MN10300_16 */
11184 if (saved_sym
!= NULL
)
11188 value
= reloc
->r_addend
11189 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11190 - saved_sym
->st_value
);
11192 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11199 if (saved_sym
!= NULL
)
11200 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11208 static bfd_vma saved_sym1
= 0;
11209 static bfd_vma saved_sym2
= 0;
11210 static bfd_vma value
;
11212 switch (reloc_type
)
11214 case 0x80: /* R_RL78_SYM. */
11215 saved_sym1
= saved_sym2
;
11216 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11217 saved_sym2
+= reloc
->r_addend
;
11220 case 0x83: /* R_RL78_OPsub. */
11221 value
= saved_sym1
- saved_sym2
;
11222 saved_sym2
= saved_sym1
= 0;
11226 case 0x41: /* R_RL78_ABS32. */
11227 byte_put (start
+ reloc
->r_offset
, value
, 4);
11231 case 0x43: /* R_RL78_ABS16. */
11232 byte_put (start
+ reloc
->r_offset
, value
, 2);
11246 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11247 DWARF debug sections. This is a target specific test. Note - we do not
11248 go through the whole including-target-headers-multiple-times route, (as
11249 we have already done with <elf/h8.h>) because this would become very
11250 messy and even then this function would have to contain target specific
11251 information (the names of the relocs instead of their numeric values).
11252 FIXME: This is not the correct way to solve this problem. The proper way
11253 is to have target specific reloc sizing and typing functions created by
11254 the reloc-macros.h header, in the same way that it already creates the
11255 reloc naming functions. */
11258 is_32bit_abs_reloc (unsigned int reloc_type
)
11260 switch (elf_header
.e_machine
)
11264 return reloc_type
== 1; /* R_386_32. */
11266 return reloc_type
== 1; /* R_68K_32. */
11268 return reloc_type
== 1; /* R_860_32. */
11270 return reloc_type
== 2; /* R_960_32. */
11272 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11274 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11276 return reloc_type
== 1; /* R_ARC_32. */
11278 return reloc_type
== 2; /* R_ARM_ABS32 */
11281 return reloc_type
== 1;
11282 case EM_ADAPTEVA_EPIPHANY
:
11283 return reloc_type
== 3;
11285 return reloc_type
== 0x12; /* R_byte4_data. */
11287 return reloc_type
== 3; /* R_CRIS_32. */
11289 return reloc_type
== 3; /* R_CR16_NUM32. */
11291 return reloc_type
== 15; /* R_CRX_NUM32. */
11292 case EM_CYGNUS_FRV
:
11293 return reloc_type
== 1;
11294 case EM_CYGNUS_D10V
:
11296 return reloc_type
== 6; /* R_D10V_32. */
11297 case EM_CYGNUS_D30V
:
11299 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11301 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11302 case EM_CYGNUS_FR30
:
11304 return reloc_type
== 3; /* R_FR30_32. */
11306 return reloc_type
== 1; /* R_FT32_32. */
11310 return reloc_type
== 1; /* R_H8_DIR32. */
11312 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11313 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11316 return reloc_type
== 2; /* R_IP2K_32. */
11318 return reloc_type
== 2; /* R_IQ2000_32. */
11319 case EM_LATTICEMICO32
:
11320 return reloc_type
== 3; /* R_LM32_32. */
11323 return reloc_type
== 3; /* R_M32C_32. */
11325 return reloc_type
== 34; /* R_M32R_32_RELA. */
11327 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11328 case EM_CYGNUS_MEP
:
11329 return reloc_type
== 4; /* R_MEP_32. */
11331 return reloc_type
== 2; /* R_METAG_ADDR32. */
11332 case EM_MICROBLAZE
:
11333 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11335 return reloc_type
== 2; /* R_MIPS_32. */
11337 return reloc_type
== 4; /* R_MMIX_32. */
11338 case EM_CYGNUS_MN10200
:
11340 return reloc_type
== 1; /* R_MN10200_32. */
11341 case EM_CYGNUS_MN10300
:
11343 return reloc_type
== 1; /* R_MN10300_32. */
11345 return reloc_type
== 1; /* R_MOXIE_32. */
11346 case EM_MSP430_OLD
:
11348 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11350 return reloc_type
== 2; /* R_MT_32. */
11352 return reloc_type
== 20; /* R_NDS32_RELA. */
11353 case EM_ALTERA_NIOS2
:
11354 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11356 return reloc_type
== 1; /* R_NIOS_32. */
11358 return reloc_type
== 1; /* R_OR1K_32. */
11360 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11361 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11364 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11366 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11368 return reloc_type
== 1; /* R_PPC_ADDR32. */
11370 return reloc_type
== 1; /* R_RL78_DIR32. */
11372 return reloc_type
== 1; /* R_RX_DIR32. */
11374 return reloc_type
== 1; /* R_I370_ADDR31. */
11377 return reloc_type
== 4; /* R_S390_32. */
11379 return reloc_type
== 8; /* R_SCORE_ABS32. */
11381 return reloc_type
== 1; /* R_SH_DIR32. */
11382 case EM_SPARC32PLUS
:
11385 return reloc_type
== 3 /* R_SPARC_32. */
11386 || reloc_type
== 23; /* R_SPARC_UA32. */
11388 return reloc_type
== 6; /* R_SPU_ADDR32 */
11390 return reloc_type
== 1; /* R_C6000_ABS32. */
11392 return reloc_type
== 2; /* R_TILEGX_32. */
11394 return reloc_type
== 1; /* R_TILEPRO_32. */
11395 case EM_CYGNUS_V850
:
11397 return reloc_type
== 6; /* R_V850_ABS32. */
11399 return reloc_type
== 0x33; /* R_V810_WORD. */
11401 return reloc_type
== 1; /* R_VAX_32. */
11403 return reloc_type
== 3; /* R_VISIUM_32. */
11407 return reloc_type
== 10; /* R_X86_64_32. */
11410 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11412 return reloc_type
== 4; /* R_XGATE_32. */
11414 return reloc_type
== 1; /* R_XSTROMY16_32. */
11415 case EM_XTENSA_OLD
:
11417 return reloc_type
== 1; /* R_XTENSA_32. */
11420 static unsigned int prev_warn
= 0;
11422 /* Avoid repeating the same warning multiple times. */
11423 if (prev_warn
!= elf_header
.e_machine
)
11424 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11425 elf_header
.e_machine
);
11426 prev_warn
= elf_header
.e_machine
;
11432 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11433 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11436 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11438 switch (elf_header
.e_machine
)
11442 return reloc_type
== 2; /* R_386_PC32. */
11444 return reloc_type
== 4; /* R_68K_PC32. */
11446 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11447 case EM_ADAPTEVA_EPIPHANY
:
11448 return reloc_type
== 6;
11450 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11452 return reloc_type
== 3; /* R_ARM_REL32 */
11453 case EM_MICROBLAZE
:
11454 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11456 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11458 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11460 return reloc_type
== 26; /* R_PPC_REL32. */
11462 return reloc_type
== 26; /* R_PPC64_REL32. */
11465 return reloc_type
== 5; /* R_390_PC32. */
11467 return reloc_type
== 2; /* R_SH_REL32. */
11468 case EM_SPARC32PLUS
:
11471 return reloc_type
== 6; /* R_SPARC_DISP32. */
11473 return reloc_type
== 13; /* R_SPU_REL32. */
11475 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11477 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11479 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11483 return reloc_type
== 2; /* R_X86_64_PC32. */
11484 case EM_XTENSA_OLD
:
11486 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11488 /* Do not abort or issue an error message here. Not all targets use
11489 pc-relative 32-bit relocs in their DWARF debug information and we
11490 have already tested for target coverage in is_32bit_abs_reloc. A
11491 more helpful warning message will be generated by apply_relocations
11492 anyway, so just return. */
11497 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11498 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11501 is_64bit_abs_reloc (unsigned int reloc_type
)
11503 switch (elf_header
.e_machine
)
11506 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11508 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11510 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11512 return reloc_type
== 80; /* R_PARISC_DIR64. */
11514 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11515 case EM_SPARC32PLUS
:
11518 return reloc_type
== 54; /* R_SPARC_UA64. */
11522 return reloc_type
== 1; /* R_X86_64_64. */
11525 return reloc_type
== 22; /* R_S390_64. */
11527 return reloc_type
== 1; /* R_TILEGX_64. */
11529 return reloc_type
== 18; /* R_MIPS_64. */
11535 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11536 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11539 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11541 switch (elf_header
.e_machine
)
11544 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11546 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11548 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11550 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11552 return reloc_type
== 44; /* R_PPC64_REL64. */
11553 case EM_SPARC32PLUS
:
11556 return reloc_type
== 46; /* R_SPARC_DISP64. */
11560 return reloc_type
== 24; /* R_X86_64_PC64. */
11563 return reloc_type
== 23; /* R_S390_PC64. */
11565 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11571 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11572 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11575 is_24bit_abs_reloc (unsigned int reloc_type
)
11577 switch (elf_header
.e_machine
)
11579 case EM_CYGNUS_MN10200
:
11581 return reloc_type
== 4; /* R_MN10200_24. */
11587 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11588 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11591 is_16bit_abs_reloc (unsigned int reloc_type
)
11593 switch (elf_header
.e_machine
)
11597 return reloc_type
== 4; /* R_AVR_16. */
11598 case EM_ADAPTEVA_EPIPHANY
:
11599 return reloc_type
== 5;
11600 case EM_CYGNUS_D10V
:
11602 return reloc_type
== 3; /* R_D10V_16. */
11606 return reloc_type
== R_H8_DIR16
;
11609 return reloc_type
== 1; /* R_IP2K_16. */
11612 return reloc_type
== 1; /* R_M32C_16 */
11614 if (uses_msp430x_relocs ())
11615 return reloc_type
== 2; /* R_MSP430_ABS16. */
11616 case EM_MSP430_OLD
:
11617 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11619 return reloc_type
== 19; /* R_NDS32_RELA. */
11620 case EM_ALTERA_NIOS2
:
11621 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11623 return reloc_type
== 9; /* R_NIOS_16. */
11625 return reloc_type
== 2; /* R_OR1K_16. */
11627 return reloc_type
== 2; /* R_C6000_ABS16. */
11630 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11631 case EM_CYGNUS_MN10200
:
11633 return reloc_type
== 2; /* R_MN10200_16. */
11634 case EM_CYGNUS_MN10300
:
11636 return reloc_type
== 2; /* R_MN10300_16. */
11638 return reloc_type
== 2; /* R_VISIUM_16. */
11640 return reloc_type
== 3; /* R_XGATE_16. */
11646 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11647 relocation entries (possibly formerly used for SHT_GROUP sections). */
11650 is_none_reloc (unsigned int reloc_type
)
11652 switch (elf_header
.e_machine
)
11654 case EM_68K
: /* R_68K_NONE. */
11655 case EM_386
: /* R_386_NONE. */
11656 case EM_SPARC32PLUS
:
11658 case EM_SPARC
: /* R_SPARC_NONE. */
11659 case EM_MIPS
: /* R_MIPS_NONE. */
11660 case EM_PARISC
: /* R_PARISC_NONE. */
11661 case EM_ALPHA
: /* R_ALPHA_NONE. */
11662 case EM_ADAPTEVA_EPIPHANY
:
11663 case EM_PPC
: /* R_PPC_NONE. */
11664 case EM_PPC64
: /* R_PPC64_NONE. */
11665 case EM_ARM
: /* R_ARM_NONE. */
11666 case EM_IA_64
: /* R_IA64_NONE. */
11667 case EM_SH
: /* R_SH_NONE. */
11669 case EM_S390
: /* R_390_NONE. */
11670 case EM_CRIS
: /* R_CRIS_NONE. */
11671 case EM_X86_64
: /* R_X86_64_NONE. */
11672 case EM_L1OM
: /* R_X86_64_NONE. */
11673 case EM_K1OM
: /* R_X86_64_NONE. */
11674 case EM_MN10300
: /* R_MN10300_NONE. */
11675 case EM_FT32
: /* R_FT32_NONE. */
11676 case EM_MOXIE
: /* R_MOXIE_NONE. */
11677 case EM_M32R
: /* R_M32R_NONE. */
11678 case EM_TI_C6000
:/* R_C6000_NONE. */
11679 case EM_TILEGX
: /* R_TILEGX_NONE. */
11680 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11682 case EM_C166
: /* R_XC16X_NONE. */
11683 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11684 case EM_NIOS32
: /* R_NIOS_NONE. */
11685 case EM_OR1K
: /* R_OR1K_NONE. */
11686 return reloc_type
== 0;
11688 return reloc_type
== 0 || reloc_type
== 256;
11690 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11691 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11692 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11693 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11694 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11695 case EM_XTENSA_OLD
:
11697 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11698 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11699 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11700 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11702 return reloc_type
== 3; /* R_METAG_NONE. */
11707 /* Returns TRUE if there is a relocation against
11708 section NAME at OFFSET bytes. */
11711 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11713 Elf_Internal_Rela
* relocs
;
11714 Elf_Internal_Rela
* rp
;
11716 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11719 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11721 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11722 if (rp
->r_offset
== offset
)
11728 /* Apply relocations to a section.
11729 Note: So far support has been added only for those relocations
11730 which can be found in debug sections.
11731 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11732 loaded relocs. It is then the caller's responsibility to free them.
11733 FIXME: Add support for more relocations ? */
11736 apply_relocations (void * file
,
11737 const Elf_Internal_Shdr
* section
,
11738 unsigned char * start
,
11739 bfd_size_type size
,
11740 void ** relocs_return
,
11741 unsigned long * num_relocs_return
)
11743 Elf_Internal_Shdr
* relsec
;
11744 unsigned char * end
= start
+ size
;
11746 if (relocs_return
!= NULL
)
11748 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11749 * num_relocs_return
= 0;
11752 if (elf_header
.e_type
!= ET_REL
)
11755 /* Find the reloc section associated with the section. */
11756 for (relsec
= section_headers
;
11757 relsec
< section_headers
+ elf_header
.e_shnum
;
11760 bfd_boolean is_rela
;
11761 unsigned long num_relocs
;
11762 Elf_Internal_Rela
* relocs
;
11763 Elf_Internal_Rela
* rp
;
11764 Elf_Internal_Shdr
* symsec
;
11765 Elf_Internal_Sym
* symtab
;
11766 unsigned long num_syms
;
11767 Elf_Internal_Sym
* sym
;
11769 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11770 || relsec
->sh_info
>= elf_header
.e_shnum
11771 || section_headers
+ relsec
->sh_info
!= section
11772 || relsec
->sh_size
== 0
11773 || relsec
->sh_link
>= elf_header
.e_shnum
)
11776 is_rela
= relsec
->sh_type
== SHT_RELA
;
11780 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11781 relsec
->sh_size
, & relocs
, & num_relocs
))
11786 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11787 relsec
->sh_size
, & relocs
, & num_relocs
))
11791 /* SH uses RELA but uses in place value instead of the addend field. */
11792 if (elf_header
.e_machine
== EM_SH
)
11795 symsec
= section_headers
+ relsec
->sh_link
;
11796 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11798 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11801 unsigned int reloc_type
;
11802 unsigned int reloc_size
;
11803 unsigned char * rloc
;
11804 unsigned long sym_index
;
11806 reloc_type
= get_reloc_type (rp
->r_info
);
11808 if (target_specific_reloc_handling (rp
, start
, symtab
))
11810 else if (is_none_reloc (reloc_type
))
11812 else if (is_32bit_abs_reloc (reloc_type
)
11813 || is_32bit_pcrel_reloc (reloc_type
))
11815 else if (is_64bit_abs_reloc (reloc_type
)
11816 || is_64bit_pcrel_reloc (reloc_type
))
11818 else if (is_24bit_abs_reloc (reloc_type
))
11820 else if (is_16bit_abs_reloc (reloc_type
))
11824 static unsigned int prev_reloc
= 0;
11825 if (reloc_type
!= prev_reloc
)
11826 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11827 reloc_type
, printable_section_name (section
));
11828 prev_reloc
= reloc_type
;
11832 rloc
= start
+ rp
->r_offset
;
11833 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11835 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11836 (unsigned long) rp
->r_offset
,
11837 printable_section_name (section
));
11841 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11842 if (sym_index
>= num_syms
)
11844 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11845 sym_index
, printable_section_name (section
));
11848 sym
= symtab
+ sym_index
;
11850 /* If the reloc has a symbol associated with it,
11851 make sure that it is of an appropriate type.
11853 Relocations against symbols without type can happen.
11854 Gcc -feliminate-dwarf2-dups may generate symbols
11855 without type for debug info.
11857 Icc generates relocations against function symbols
11858 instead of local labels.
11860 Relocations against object symbols can happen, eg when
11861 referencing a global array. For an example of this see
11862 the _clz.o binary in libgcc.a. */
11864 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11866 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11867 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11868 (long int)(rp
- relocs
),
11869 printable_section_name (relsec
));
11875 addend
+= rp
->r_addend
;
11876 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11877 partial_inplace. */
11879 || (elf_header
.e_machine
== EM_XTENSA
11880 && reloc_type
== 1)
11881 || ((elf_header
.e_machine
== EM_PJ
11882 || elf_header
.e_machine
== EM_PJ_OLD
)
11883 && reloc_type
== 1)
11884 || ((elf_header
.e_machine
== EM_D30V
11885 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11886 && reloc_type
== 12))
11887 addend
+= byte_get (rloc
, reloc_size
);
11889 if (is_32bit_pcrel_reloc (reloc_type
)
11890 || is_64bit_pcrel_reloc (reloc_type
))
11892 /* On HPPA, all pc-relative relocations are biased by 8. */
11893 if (elf_header
.e_machine
== EM_PARISC
)
11895 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11899 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11906 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
11907 * num_relocs_return
= num_relocs
;
11916 #ifdef SUPPORT_DISASSEMBLY
11918 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11920 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11922 /* FIXME: XXX -- to be done --- XXX */
11928 /* Reads in the contents of SECTION from FILE, returning a pointer
11929 to a malloc'ed buffer or NULL if something went wrong. */
11932 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11934 bfd_size_type num_bytes
;
11936 num_bytes
= section
->sh_size
;
11938 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11940 printf (_("\nSection '%s' has no data to dump.\n"),
11941 printable_section_name (section
));
11945 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11946 _("section contents"));
11949 /* Uncompresses a section that was compressed using zlib, in place. */
11952 uncompress_section_contents (unsigned char **buffer
,
11953 dwarf_size_type uncompressed_size
,
11954 dwarf_size_type
*size
)
11956 dwarf_size_type compressed_size
= *size
;
11957 unsigned char * compressed_buffer
= *buffer
;
11958 unsigned char * uncompressed_buffer
;
11962 /* It is possible the section consists of several compressed
11963 buffers concatenated together, so we uncompress in a loop. */
11964 /* PR 18313: The state field in the z_stream structure is supposed
11965 to be invisible to the user (ie us), but some compilers will
11966 still complain about it being used without initialisation. So
11967 we first zero the entire z_stream structure and then set the fields
11969 memset (& strm
, 0, sizeof strm
);
11970 strm
.avail_in
= compressed_size
;
11971 strm
.next_in
= (Bytef
*) compressed_buffer
;
11972 strm
.avail_out
= uncompressed_size
;
11973 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11975 rc
= inflateInit (& strm
);
11976 while (strm
.avail_in
> 0)
11980 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11981 + (uncompressed_size
- strm
.avail_out
));
11982 rc
= inflate (&strm
, Z_FINISH
);
11983 if (rc
!= Z_STREAM_END
)
11985 rc
= inflateReset (& strm
);
11987 rc
= inflateEnd (& strm
);
11989 || strm
.avail_out
!= 0)
11992 *buffer
= uncompressed_buffer
;
11993 *size
= uncompressed_size
;
11997 free (uncompressed_buffer
);
11998 /* Indicate decompression failure. */
12004 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12006 Elf_Internal_Shdr
* relsec
;
12007 bfd_size_type num_bytes
;
12008 unsigned char * data
;
12009 unsigned char * end
;
12010 unsigned char * real_start
;
12011 unsigned char * start
;
12012 bfd_boolean some_strings_shown
;
12014 real_start
= start
= (unsigned char *) get_section_contents (section
,
12018 num_bytes
= section
->sh_size
;
12020 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12022 if (decompress_dumps
)
12024 dwarf_size_type new_size
= num_bytes
;
12025 dwarf_size_type uncompressed_size
= 0;
12027 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12029 Elf_Internal_Chdr chdr
;
12030 unsigned int compression_header_size
12031 = get_compression_header (& chdr
, (unsigned char *) start
);
12033 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
12034 && chdr
.ch_addralign
== section
->sh_addralign
)
12036 uncompressed_size
= chdr
.ch_size
;
12037 start
+= compression_header_size
;
12038 new_size
-= compression_header_size
;
12041 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12043 /* Read the zlib header. In this case, it should be "ZLIB"
12044 followed by the uncompressed section size, 8 bytes in
12045 big-endian order. */
12046 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12047 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12048 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12049 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12050 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12051 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12052 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12053 uncompressed_size
+= start
[11];
12058 if (uncompressed_size
12059 && uncompress_section_contents (& start
,
12060 uncompressed_size
, & new_size
))
12061 num_bytes
= new_size
;
12064 /* If the section being dumped has relocations against it the user might
12065 be expecting these relocations to have been applied. Check for this
12066 case and issue a warning message in order to avoid confusion.
12067 FIXME: Maybe we ought to have an option that dumps a section with
12068 relocs applied ? */
12069 for (relsec
= section_headers
;
12070 relsec
< section_headers
+ elf_header
.e_shnum
;
12073 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12074 || relsec
->sh_info
>= elf_header
.e_shnum
12075 || section_headers
+ relsec
->sh_info
!= section
12076 || relsec
->sh_size
== 0
12077 || relsec
->sh_link
>= elf_header
.e_shnum
)
12080 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12085 end
= start
+ num_bytes
;
12086 some_strings_shown
= FALSE
;
12090 while (!ISPRINT (* data
))
12091 if (++ data
>= end
)
12096 size_t maxlen
= end
- data
;
12099 /* PR 11128: Use two separate invocations in order to work
12100 around bugs in the Solaris 8 implementation of printf. */
12101 printf (" [%6tx] ", data
- start
);
12103 printf (" [%6Ix] ", (size_t) (data
- start
));
12107 print_symbol ((int) maxlen
, (const char *) data
);
12109 data
+= strnlen ((const char *) data
, maxlen
);
12113 printf (_("<corrupt>\n"));
12116 some_strings_shown
= TRUE
;
12120 if (! some_strings_shown
)
12121 printf (_(" No strings found in this section."));
12129 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12131 bfd_boolean relocate
)
12133 Elf_Internal_Shdr
* relsec
;
12134 bfd_size_type bytes
;
12135 bfd_size_type section_size
;
12137 unsigned char * data
;
12138 unsigned char * real_start
;
12139 unsigned char * start
;
12141 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12144 section_size
= section
->sh_size
;
12146 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12148 if (decompress_dumps
)
12150 dwarf_size_type new_size
= section_size
;
12151 dwarf_size_type uncompressed_size
= 0;
12153 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12155 Elf_Internal_Chdr chdr
;
12156 unsigned int compression_header_size
12157 = get_compression_header (& chdr
, start
);
12159 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
12160 && chdr
.ch_addralign
== section
->sh_addralign
)
12162 uncompressed_size
= chdr
.ch_size
;
12163 start
+= compression_header_size
;
12164 new_size
-= compression_header_size
;
12167 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12169 /* Read the zlib header. In this case, it should be "ZLIB"
12170 followed by the uncompressed section size, 8 bytes in
12171 big-endian order. */
12172 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12173 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12174 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12175 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12176 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12177 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12178 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12179 uncompressed_size
+= start
[11];
12184 if (uncompressed_size
12185 && uncompress_section_contents (& start
, uncompressed_size
,
12187 section_size
= new_size
;
12192 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12196 /* If the section being dumped has relocations against it the user might
12197 be expecting these relocations to have been applied. Check for this
12198 case and issue a warning message in order to avoid confusion.
12199 FIXME: Maybe we ought to have an option that dumps a section with
12200 relocs applied ? */
12201 for (relsec
= section_headers
;
12202 relsec
< section_headers
+ elf_header
.e_shnum
;
12205 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12206 || relsec
->sh_info
>= elf_header
.e_shnum
12207 || section_headers
+ relsec
->sh_info
!= section
12208 || relsec
->sh_size
== 0
12209 || relsec
->sh_link
>= elf_header
.e_shnum
)
12212 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12217 addr
= section
->sh_addr
;
12218 bytes
= section_size
;
12227 lbytes
= (bytes
> 16 ? 16 : bytes
);
12229 printf (" 0x%8.8lx ", (unsigned long) addr
);
12231 for (j
= 0; j
< 16; j
++)
12234 printf ("%2.2x", data
[j
]);
12242 for (j
= 0; j
< lbytes
; j
++)
12245 if (k
>= ' ' && k
< 0x7f)
12264 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12265 const Elf_Internal_Shdr
* sec
, void * file
)
12267 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12270 /* If it is already loaded, do nothing. */
12271 if (section
->start
!= NULL
)
12274 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12275 section
->address
= sec
->sh_addr
;
12276 section
->user_data
= NULL
;
12277 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12279 sec
->sh_size
, buf
);
12280 if (section
->start
== NULL
)
12284 unsigned char *start
= section
->start
;
12285 dwarf_size_type size
= sec
->sh_size
;
12286 dwarf_size_type uncompressed_size
= 0;
12288 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12290 Elf_Internal_Chdr chdr
;
12291 unsigned int compression_header_size
12292 = get_compression_header (&chdr
, start
);
12293 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
12294 || chdr
.ch_addralign
!= sec
->sh_addralign
)
12296 uncompressed_size
= chdr
.ch_size
;
12297 start
+= compression_header_size
;
12298 size
-= compression_header_size
;
12300 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12302 /* Read the zlib header. In this case, it should be "ZLIB"
12303 followed by the uncompressed section size, 8 bytes in
12304 big-endian order. */
12305 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12306 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12307 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12308 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12309 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12310 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12311 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12312 uncompressed_size
+= start
[11];
12317 if (uncompressed_size
12318 && uncompress_section_contents (&start
, uncompressed_size
,
12321 /* Free the compressed buffer, update the section buffer
12322 and the section size if uncompress is successful. */
12323 free (section
->start
);
12324 section
->start
= start
;
12326 section
->size
= size
;
12329 if (section
->start
== NULL
)
12332 if (debug_displays
[debug
].relocate
)
12333 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12334 & section
->reloc_info
, & section
->num_relocs
);
12337 section
->reloc_info
= NULL
;
12338 section
->num_relocs
= 0;
12344 /* If this is not NULL, load_debug_section will only look for sections
12345 within the list of sections given here. */
12346 unsigned int *section_subset
= NULL
;
12349 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12351 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12352 Elf_Internal_Shdr
* sec
;
12354 /* Locate the debug section. */
12355 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12357 section
->name
= section
->uncompressed_name
;
12360 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12362 section
->name
= section
->compressed_name
;
12367 /* If we're loading from a subset of sections, and we've loaded
12368 a section matching this name before, it's likely that it's a
12370 if (section_subset
!= NULL
)
12371 free_debug_section (debug
);
12373 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12377 free_debug_section (enum dwarf_section_display_enum debug
)
12379 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12381 if (section
->start
== NULL
)
12384 free ((char *) section
->start
);
12385 section
->start
= NULL
;
12386 section
->address
= 0;
12391 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12393 char * name
= SECTION_NAME (section
);
12394 const char * print_name
= printable_section_name (section
);
12395 bfd_size_type length
;
12399 length
= section
->sh_size
;
12402 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12405 if (section
->sh_type
== SHT_NOBITS
)
12407 /* There is no point in dumping the contents of a debugging section
12408 which has the NOBITS type - the bits in the file will be random.
12409 This can happen when a file containing a .eh_frame section is
12410 stripped with the --only-keep-debug command line option. */
12411 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12416 if (const_strneq (name
, ".gnu.linkonce.wi."))
12417 name
= ".debug_info";
12419 /* See if we know how to display the contents of this section. */
12420 for (i
= 0; i
< max
; i
++)
12421 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12422 || (i
== line
&& const_strneq (name
, ".debug_line."))
12423 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12425 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12426 int secondary
= (section
!= find_section (name
));
12429 free_debug_section ((enum dwarf_section_display_enum
) i
);
12431 if (i
== line
&& const_strneq (name
, ".debug_line."))
12433 else if (streq (sec
->uncompressed_name
, name
))
12434 sec
->name
= sec
->uncompressed_name
;
12436 sec
->name
= sec
->compressed_name
;
12437 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12440 /* If this debug section is part of a CU/TU set in a .dwp file,
12441 restrict load_debug_section to the sections in that set. */
12442 section_subset
= find_cu_tu_set (file
, shndx
);
12444 result
&= debug_displays
[i
].display (sec
, file
);
12446 section_subset
= NULL
;
12448 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12449 free_debug_section ((enum dwarf_section_display_enum
) i
);
12457 printf (_("Unrecognized debug section: %s\n"), print_name
);
12464 /* Set DUMP_SECTS for all sections where dumps were requested
12465 based on section name. */
12468 initialise_dumps_byname (void)
12470 struct dump_list_entry
* cur
;
12472 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12477 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12478 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12480 request_dump_bynumber (i
, cur
->type
);
12485 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12491 process_section_contents (FILE * file
)
12493 Elf_Internal_Shdr
* section
;
12499 initialise_dumps_byname ();
12501 for (i
= 0, section
= section_headers
;
12502 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12505 #ifdef SUPPORT_DISASSEMBLY
12506 if (dump_sects
[i
] & DISASS_DUMP
)
12507 disassemble_section (section
, file
);
12509 if (dump_sects
[i
] & HEX_DUMP
)
12510 dump_section_as_bytes (section
, file
, FALSE
);
12512 if (dump_sects
[i
] & RELOC_DUMP
)
12513 dump_section_as_bytes (section
, file
, TRUE
);
12515 if (dump_sects
[i
] & STRING_DUMP
)
12516 dump_section_as_strings (section
, file
);
12518 if (dump_sects
[i
] & DEBUG_DUMP
)
12519 display_debug_section (i
, section
, file
);
12522 /* Check to see if the user requested a
12523 dump of a section that does not exist. */
12524 while (i
++ < num_dump_sects
)
12526 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12530 process_mips_fpe_exception (int mask
)
12535 if (mask
& OEX_FPU_INEX
)
12536 fputs ("INEX", stdout
), first
= 0;
12537 if (mask
& OEX_FPU_UFLO
)
12538 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12539 if (mask
& OEX_FPU_OFLO
)
12540 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12541 if (mask
& OEX_FPU_DIV0
)
12542 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12543 if (mask
& OEX_FPU_INVAL
)
12544 printf ("%sINVAL", first
? "" : "|");
12547 fputs ("0", stdout
);
12550 /* Display's the value of TAG at location P. If TAG is
12551 greater than 0 it is assumed to be an unknown tag, and
12552 a message is printed to this effect. Otherwise it is
12553 assumed that a message has already been printed.
12555 If the bottom bit of TAG is set it assumed to have a
12556 string value, otherwise it is assumed to have an integer
12559 Returns an updated P pointing to the first unread byte
12560 beyond the end of TAG's value.
12562 Reads at or beyond END will not be made. */
12564 static unsigned char *
12565 display_tag_value (int tag
,
12567 const unsigned char * const end
)
12572 printf (" Tag_unknown_%d: ", tag
);
12576 warn (_("<corrupt tag>\n"));
12580 /* PR 17531 file: 027-19978-0.004. */
12581 size_t maxlen
= (end
- p
) - 1;
12586 print_symbol ((int) maxlen
, (const char *) p
);
12587 p
+= strnlen ((char *) p
, maxlen
) + 1;
12591 printf (_("<corrupt string tag>"));
12592 p
= (unsigned char *) end
;
12600 val
= read_uleb128 (p
, &len
, end
);
12602 printf ("%ld (0x%lx)\n", val
, val
);
12609 /* ARM EABI attributes section. */
12614 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12616 const char ** table
;
12617 } arm_attr_public_tag
;
12619 static const char * arm_attr_tag_CPU_arch
[] =
12620 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12621 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12622 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12623 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12624 {"No", "Thumb-1", "Thumb-2"};
12625 static const char * arm_attr_tag_FP_arch
[] =
12626 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12627 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12628 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12629 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12630 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12631 static const char * arm_attr_tag_PCS_config
[] =
12632 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12633 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12634 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12635 {"V6", "SB", "TLS", "Unused"};
12636 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12637 {"Absolute", "PC-relative", "SB-relative", "None"};
12638 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12639 {"Absolute", "PC-relative", "None"};
12640 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12641 {"None", "direct", "GOT-indirect"};
12642 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12643 {"None", "??? 1", "2", "??? 3", "4"};
12644 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12645 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12646 {"Unused", "Needed", "Sign only"};
12647 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12648 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12649 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12650 {"Unused", "Finite", "RTABI", "IEEE 754"};
12651 static const char * arm_attr_tag_ABI_enum_size
[] =
12652 {"Unused", "small", "int", "forced to int"};
12653 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12654 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12655 static const char * arm_attr_tag_ABI_VFP_args
[] =
12656 {"AAPCS", "VFP registers", "custom", "compatible"};
12657 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12658 {"AAPCS", "WMMX registers", "custom"};
12659 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12660 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12661 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12662 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12663 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12664 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12665 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12666 static const char * arm_attr_tag_FP_HP_extension
[] =
12667 {"Not Allowed", "Allowed"};
12668 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12669 {"None", "IEEE 754", "Alternative Format"};
12670 static const char * arm_attr_tag_MPextension_use
[] =
12671 {"Not Allowed", "Allowed"};
12672 static const char * arm_attr_tag_DIV_use
[] =
12673 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12674 "Allowed in v7-A with integer division extension"};
12675 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12676 static const char * arm_attr_tag_Virtualization_use
[] =
12677 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12678 "TrustZone and Virtualization Extensions"};
12679 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12680 {"Not Allowed", "Allowed"};
12682 #define LOOKUP(id, name) \
12683 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12684 static arm_attr_public_tag arm_attr_public_tags
[] =
12686 {4, "CPU_raw_name", 1, NULL
},
12687 {5, "CPU_name", 1, NULL
},
12688 LOOKUP(6, CPU_arch
),
12689 {7, "CPU_arch_profile", 0, NULL
},
12690 LOOKUP(8, ARM_ISA_use
),
12691 LOOKUP(9, THUMB_ISA_use
),
12692 LOOKUP(10, FP_arch
),
12693 LOOKUP(11, WMMX_arch
),
12694 LOOKUP(12, Advanced_SIMD_arch
),
12695 LOOKUP(13, PCS_config
),
12696 LOOKUP(14, ABI_PCS_R9_use
),
12697 LOOKUP(15, ABI_PCS_RW_data
),
12698 LOOKUP(16, ABI_PCS_RO_data
),
12699 LOOKUP(17, ABI_PCS_GOT_use
),
12700 LOOKUP(18, ABI_PCS_wchar_t
),
12701 LOOKUP(19, ABI_FP_rounding
),
12702 LOOKUP(20, ABI_FP_denormal
),
12703 LOOKUP(21, ABI_FP_exceptions
),
12704 LOOKUP(22, ABI_FP_user_exceptions
),
12705 LOOKUP(23, ABI_FP_number_model
),
12706 {24, "ABI_align_needed", 0, NULL
},
12707 {25, "ABI_align_preserved", 0, NULL
},
12708 LOOKUP(26, ABI_enum_size
),
12709 LOOKUP(27, ABI_HardFP_use
),
12710 LOOKUP(28, ABI_VFP_args
),
12711 LOOKUP(29, ABI_WMMX_args
),
12712 LOOKUP(30, ABI_optimization_goals
),
12713 LOOKUP(31, ABI_FP_optimization_goals
),
12714 {32, "compatibility", 0, NULL
},
12715 LOOKUP(34, CPU_unaligned_access
),
12716 LOOKUP(36, FP_HP_extension
),
12717 LOOKUP(38, ABI_FP_16bit_format
),
12718 LOOKUP(42, MPextension_use
),
12719 LOOKUP(44, DIV_use
),
12720 {64, "nodefaults", 0, NULL
},
12721 {65, "also_compatible_with", 0, NULL
},
12722 LOOKUP(66, T2EE_use
),
12723 {67, "conformance", 1, NULL
},
12724 LOOKUP(68, Virtualization_use
),
12725 LOOKUP(70, MPextension_use_legacy
)
12729 static unsigned char *
12730 display_arm_attribute (unsigned char * p
,
12731 const unsigned char * const end
)
12736 arm_attr_public_tag
* attr
;
12740 tag
= read_uleb128 (p
, &len
, end
);
12743 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12745 if (arm_attr_public_tags
[i
].tag
== tag
)
12747 attr
= &arm_attr_public_tags
[i
];
12754 printf (" Tag_%s: ", attr
->name
);
12755 switch (attr
->type
)
12760 case 7: /* Tag_CPU_arch_profile. */
12761 val
= read_uleb128 (p
, &len
, end
);
12765 case 0: printf (_("None\n")); break;
12766 case 'A': printf (_("Application\n")); break;
12767 case 'R': printf (_("Realtime\n")); break;
12768 case 'M': printf (_("Microcontroller\n")); break;
12769 case 'S': printf (_("Application or Realtime\n")); break;
12770 default: printf ("??? (%d)\n", val
); break;
12774 case 24: /* Tag_align_needed. */
12775 val
= read_uleb128 (p
, &len
, end
);
12779 case 0: printf (_("None\n")); break;
12780 case 1: printf (_("8-byte\n")); break;
12781 case 2: printf (_("4-byte\n")); break;
12782 case 3: printf ("??? 3\n"); break;
12785 printf (_("8-byte and up to %d-byte extended\n"),
12788 printf ("??? (%d)\n", val
);
12793 case 25: /* Tag_align_preserved. */
12794 val
= read_uleb128 (p
, &len
, end
);
12798 case 0: printf (_("None\n")); break;
12799 case 1: printf (_("8-byte, except leaf SP\n")); break;
12800 case 2: printf (_("8-byte\n")); break;
12801 case 3: printf ("??? 3\n"); break;
12804 printf (_("8-byte and up to %d-byte extended\n"),
12807 printf ("??? (%d)\n", val
);
12812 case 32: /* Tag_compatibility. */
12814 val
= read_uleb128 (p
, &len
, end
);
12816 printf (_("flag = %d, vendor = "), val
);
12819 size_t maxlen
= (end
- p
) - 1;
12821 print_symbol ((int) maxlen
, (const char *) p
);
12822 p
+= strnlen ((char *) p
, maxlen
) + 1;
12826 printf (_("<corrupt>"));
12827 p
= (unsigned char *) end
;
12833 case 64: /* Tag_nodefaults. */
12834 /* PR 17531: file: 001-505008-0.01. */
12837 printf (_("True\n"));
12840 case 65: /* Tag_also_compatible_with. */
12841 val
= read_uleb128 (p
, &len
, end
);
12843 if (val
== 6 /* Tag_CPU_arch. */)
12845 val
= read_uleb128 (p
, &len
, end
);
12847 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12848 printf ("??? (%d)\n", val
);
12850 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12854 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12859 printf (_("<unknown: %d>\n"), tag
);
12865 return display_tag_value (-1, p
, end
);
12867 return display_tag_value (0, p
, end
);
12870 assert (attr
->type
& 0x80);
12871 val
= read_uleb128 (p
, &len
, end
);
12873 type
= attr
->type
& 0x7f;
12875 printf ("??? (%d)\n", val
);
12877 printf ("%s\n", attr
->table
[val
]);
12882 return display_tag_value (tag
, p
, end
);
12885 static unsigned char *
12886 display_gnu_attribute (unsigned char * p
,
12887 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12888 const unsigned char * const end
)
12894 tag
= read_uleb128 (p
, &len
, end
);
12897 /* Tag_compatibility is the only generic GNU attribute defined at
12901 val
= read_uleb128 (p
, &len
, end
);
12904 printf (_("flag = %d, vendor = "), val
);
12907 printf (_("<corrupt>\n"));
12908 warn (_("corrupt vendor attribute\n"));
12914 size_t maxlen
= (end
- p
) - 1;
12916 print_symbol ((int) maxlen
, (const char *) p
);
12917 p
+= strnlen ((char *) p
, maxlen
) + 1;
12921 printf (_("<corrupt>"));
12922 p
= (unsigned char *) end
;
12929 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12930 return display_proc_gnu_attribute (p
, tag
, end
);
12932 return display_tag_value (tag
, p
, end
);
12935 static unsigned char *
12936 display_power_gnu_attribute (unsigned char * p
,
12938 const unsigned char * const end
)
12943 if (tag
== Tag_GNU_Power_ABI_FP
)
12945 val
= read_uleb128 (p
, &len
, end
);
12947 printf (" Tag_GNU_Power_ABI_FP: ");
12952 printf (_("Hard or soft float\n"));
12955 printf (_("Hard float\n"));
12958 printf (_("Soft float\n"));
12961 printf (_("Single-precision hard float\n"));
12964 printf ("??? (%d)\n", val
);
12970 if (tag
== Tag_GNU_Power_ABI_Vector
)
12972 val
= read_uleb128 (p
, &len
, end
);
12974 printf (" Tag_GNU_Power_ABI_Vector: ");
12978 printf (_("Any\n"));
12981 printf (_("Generic\n"));
12984 printf ("AltiVec\n");
12990 printf ("??? (%d)\n", val
);
12996 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13000 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13004 val
= read_uleb128 (p
, &len
, end
);
13006 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13010 printf (_("Any\n"));
13013 printf ("r3/r4\n");
13016 printf (_("Memory\n"));
13019 printf ("??? (%d)\n", val
);
13025 return display_tag_value (tag
& 1, p
, end
);
13028 static unsigned char *
13029 display_s390_gnu_attribute (unsigned char * p
,
13031 const unsigned char * const end
)
13036 if (tag
== Tag_GNU_S390_ABI_Vector
)
13038 val
= read_uleb128 (p
, &len
, end
);
13040 printf (" Tag_GNU_S390_ABI_Vector: ");
13045 printf (_("any\n"));
13048 printf (_("software\n"));
13051 printf (_("hardware\n"));
13054 printf ("??? (%d)\n", val
);
13060 return display_tag_value (tag
& 1, p
, end
);
13064 display_sparc_hwcaps (int mask
)
13070 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13071 fputs ("mul32", stdout
), first
= 0;
13072 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13073 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13074 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13075 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13076 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13077 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13078 if (mask
& ELF_SPARC_HWCAP_POPC
)
13079 printf ("%spopc", first
? "" : "|"), first
= 0;
13080 if (mask
& ELF_SPARC_HWCAP_VIS
)
13081 printf ("%svis", first
? "" : "|"), first
= 0;
13082 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13083 printf ("%svis2", first
? "" : "|"), first
= 0;
13084 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13085 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13086 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13087 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13088 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13089 printf ("%svis3", first
? "" : "|"), first
= 0;
13090 if (mask
& ELF_SPARC_HWCAP_HPC
)
13091 printf ("%shpc", first
? "" : "|"), first
= 0;
13092 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13093 printf ("%srandom", first
? "" : "|"), first
= 0;
13094 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13095 printf ("%strans", first
? "" : "|"), first
= 0;
13096 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13097 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13098 if (mask
& ELF_SPARC_HWCAP_IMA
)
13099 printf ("%sima", first
? "" : "|"), first
= 0;
13100 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13101 printf ("%scspare", first
? "" : "|"), first
= 0;
13104 fputc ('0', stdout
);
13105 fputc ('\n', stdout
);
13109 display_sparc_hwcaps2 (int mask
)
13115 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13116 fputs ("fjathplus", stdout
), first
= 0;
13117 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13118 printf ("%svis3b", first
? "" : "|"), first
= 0;
13119 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13120 printf ("%sadp", first
? "" : "|"), first
= 0;
13121 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13122 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13123 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13124 printf ("%smwait", first
? "" : "|"), first
= 0;
13125 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13126 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13127 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13128 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13129 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13130 printf ("%snsec", first
? "" : "|"), first
= 0;
13131 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13132 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13133 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13134 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13135 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13136 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13139 fputc ('0', stdout
);
13140 fputc ('\n', stdout
);
13143 static unsigned char *
13144 display_sparc_gnu_attribute (unsigned char * p
,
13146 const unsigned char * const end
)
13151 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13153 val
= read_uleb128 (p
, &len
, end
);
13155 printf (" Tag_GNU_Sparc_HWCAPS: ");
13156 display_sparc_hwcaps (val
);
13159 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13161 val
= read_uleb128 (p
, &len
, end
);
13163 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13164 display_sparc_hwcaps2 (val
);
13168 return display_tag_value (tag
, p
, end
);
13172 print_mips_fp_abi_value (int val
)
13176 case Val_GNU_MIPS_ABI_FP_ANY
:
13177 printf (_("Hard or soft float\n"));
13179 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13180 printf (_("Hard float (double precision)\n"));
13182 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13183 printf (_("Hard float (single precision)\n"));
13185 case Val_GNU_MIPS_ABI_FP_SOFT
:
13186 printf (_("Soft float\n"));
13188 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13189 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13191 case Val_GNU_MIPS_ABI_FP_XX
:
13192 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13194 case Val_GNU_MIPS_ABI_FP_64
:
13195 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13197 case Val_GNU_MIPS_ABI_FP_64A
:
13198 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13201 printf ("??? (%d)\n", val
);
13206 static unsigned char *
13207 display_mips_gnu_attribute (unsigned char * p
,
13209 const unsigned char * const end
)
13211 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13216 val
= read_uleb128 (p
, &len
, end
);
13218 printf (" Tag_GNU_MIPS_ABI_FP: ");
13220 print_mips_fp_abi_value (val
);
13225 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13230 val
= read_uleb128 (p
, &len
, end
);
13232 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13236 case Val_GNU_MIPS_ABI_MSA_ANY
:
13237 printf (_("Any MSA or not\n"));
13239 case Val_GNU_MIPS_ABI_MSA_128
:
13240 printf (_("128-bit MSA\n"));
13243 printf ("??? (%d)\n", val
);
13249 return display_tag_value (tag
& 1, p
, end
);
13252 static unsigned char *
13253 display_tic6x_attribute (unsigned char * p
,
13254 const unsigned char * const end
)
13260 tag
= read_uleb128 (p
, &len
, end
);
13266 val
= read_uleb128 (p
, &len
, end
);
13268 printf (" Tag_ISA: ");
13272 case C6XABI_Tag_ISA_none
:
13273 printf (_("None\n"));
13275 case C6XABI_Tag_ISA_C62X
:
13278 case C6XABI_Tag_ISA_C67X
:
13281 case C6XABI_Tag_ISA_C67XP
:
13282 printf ("C67x+\n");
13284 case C6XABI_Tag_ISA_C64X
:
13287 case C6XABI_Tag_ISA_C64XP
:
13288 printf ("C64x+\n");
13290 case C6XABI_Tag_ISA_C674X
:
13291 printf ("C674x\n");
13294 printf ("??? (%d)\n", val
);
13299 case Tag_ABI_wchar_t
:
13300 val
= read_uleb128 (p
, &len
, end
);
13302 printf (" Tag_ABI_wchar_t: ");
13306 printf (_("Not used\n"));
13309 printf (_("2 bytes\n"));
13312 printf (_("4 bytes\n"));
13315 printf ("??? (%d)\n", val
);
13320 case Tag_ABI_stack_align_needed
:
13321 val
= read_uleb128 (p
, &len
, end
);
13323 printf (" Tag_ABI_stack_align_needed: ");
13327 printf (_("8-byte\n"));
13330 printf (_("16-byte\n"));
13333 printf ("??? (%d)\n", val
);
13338 case Tag_ABI_stack_align_preserved
:
13339 val
= read_uleb128 (p
, &len
, end
);
13341 printf (" Tag_ABI_stack_align_preserved: ");
13345 printf (_("8-byte\n"));
13348 printf (_("16-byte\n"));
13351 printf ("??? (%d)\n", val
);
13357 val
= read_uleb128 (p
, &len
, end
);
13359 printf (" Tag_ABI_DSBT: ");
13363 printf (_("DSBT addressing not used\n"));
13366 printf (_("DSBT addressing used\n"));
13369 printf ("??? (%d)\n", val
);
13375 val
= read_uleb128 (p
, &len
, end
);
13377 printf (" Tag_ABI_PID: ");
13381 printf (_("Data addressing position-dependent\n"));
13384 printf (_("Data addressing position-independent, GOT near DP\n"));
13387 printf (_("Data addressing position-independent, GOT far from DP\n"));
13390 printf ("??? (%d)\n", val
);
13396 val
= read_uleb128 (p
, &len
, end
);
13398 printf (" Tag_ABI_PIC: ");
13402 printf (_("Code addressing position-dependent\n"));
13405 printf (_("Code addressing position-independent\n"));
13408 printf ("??? (%d)\n", val
);
13413 case Tag_ABI_array_object_alignment
:
13414 val
= read_uleb128 (p
, &len
, end
);
13416 printf (" Tag_ABI_array_object_alignment: ");
13420 printf (_("8-byte\n"));
13423 printf (_("4-byte\n"));
13426 printf (_("16-byte\n"));
13429 printf ("??? (%d)\n", val
);
13434 case Tag_ABI_array_object_align_expected
:
13435 val
= read_uleb128 (p
, &len
, end
);
13437 printf (" Tag_ABI_array_object_align_expected: ");
13441 printf (_("8-byte\n"));
13444 printf (_("4-byte\n"));
13447 printf (_("16-byte\n"));
13450 printf ("??? (%d)\n", val
);
13455 case Tag_ABI_compatibility
:
13457 val
= read_uleb128 (p
, &len
, end
);
13459 printf (" Tag_ABI_compatibility: ");
13460 printf (_("flag = %d, vendor = "), val
);
13463 size_t maxlen
= (end
- p
) - 1;
13465 print_symbol ((int) maxlen
, (const char *) p
);
13466 p
+= strnlen ((char *) p
, maxlen
) + 1;
13470 printf (_("<corrupt>"));
13471 p
= (unsigned char *) end
;
13477 case Tag_ABI_conformance
:
13479 printf (" Tag_ABI_conformance: \"");
13482 size_t maxlen
= (end
- p
) - 1;
13484 print_symbol ((int) maxlen
, (const char *) p
);
13485 p
+= strnlen ((char *) p
, maxlen
) + 1;
13489 printf (_("<corrupt>"));
13490 p
= (unsigned char *) end
;
13497 return display_tag_value (tag
, p
, end
);
13501 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13503 unsigned long addr
= 0;
13504 size_t bytes
= end
- p
;
13511 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13513 printf (" 0x%8.8lx ", addr
);
13515 for (j
= 0; j
< 16; j
++)
13518 printf ("%2.2x", p
[j
]);
13526 for (j
= 0; j
< lbytes
; j
++)
13529 if (k
>= ' ' && k
< 0x7f)
13545 static unsigned char *
13546 display_msp430x_attribute (unsigned char * p
,
13547 const unsigned char * const end
)
13553 tag
= read_uleb128 (p
, & len
, end
);
13558 case OFBA_MSPABI_Tag_ISA
:
13559 val
= read_uleb128 (p
, &len
, end
);
13561 printf (" Tag_ISA: ");
13564 case 0: printf (_("None\n")); break;
13565 case 1: printf (_("MSP430\n")); break;
13566 case 2: printf (_("MSP430X\n")); break;
13567 default: printf ("??? (%d)\n", val
); break;
13571 case OFBA_MSPABI_Tag_Code_Model
:
13572 val
= read_uleb128 (p
, &len
, end
);
13574 printf (" Tag_Code_Model: ");
13577 case 0: printf (_("None\n")); break;
13578 case 1: printf (_("Small\n")); break;
13579 case 2: printf (_("Large\n")); break;
13580 default: printf ("??? (%d)\n", val
); break;
13584 case OFBA_MSPABI_Tag_Data_Model
:
13585 val
= read_uleb128 (p
, &len
, end
);
13587 printf (" Tag_Data_Model: ");
13590 case 0: printf (_("None\n")); break;
13591 case 1: printf (_("Small\n")); break;
13592 case 2: printf (_("Large\n")); break;
13593 case 3: printf (_("Restricted Large\n")); break;
13594 default: printf ("??? (%d)\n", val
); break;
13599 printf (_(" <unknown tag %d>: "), tag
);
13606 size_t maxlen
= (end
- p
) - 1;
13608 print_symbol ((int) maxlen
, (const char *) p
);
13609 p
+= strnlen ((char *) p
, maxlen
) + 1;
13613 printf (_("<corrupt>"));
13614 p
= (unsigned char *) end
;
13620 val
= read_uleb128 (p
, &len
, end
);
13622 printf ("%d (0x%x)\n", val
, val
);
13632 process_attributes (FILE * file
,
13633 const char * public_name
,
13634 unsigned int proc_type
,
13635 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13636 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13638 Elf_Internal_Shdr
* sect
;
13641 /* Find the section header so that we get the size. */
13642 for (i
= 0, sect
= section_headers
;
13643 i
< elf_header
.e_shnum
;
13646 unsigned char * contents
;
13649 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13652 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13653 sect
->sh_size
, _("attributes"));
13654 if (contents
== NULL
)
13660 bfd_vma section_len
;
13662 section_len
= sect
->sh_size
- 1;
13665 while (section_len
> 0)
13668 unsigned int namelen
;
13669 bfd_boolean public_section
;
13670 bfd_boolean gnu_section
;
13672 if (section_len
<= 4)
13674 error (_("Tag section ends prematurely\n"));
13677 attr_len
= byte_get (p
, 4);
13680 if (attr_len
> section_len
)
13682 error (_("Bad attribute length (%u > %u)\n"),
13683 (unsigned) attr_len
, (unsigned) section_len
);
13684 attr_len
= section_len
;
13686 /* PR 17531: file: 001-101425-0.004 */
13687 else if (attr_len
< 5)
13689 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13693 section_len
-= attr_len
;
13696 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13697 if (namelen
== 0 || namelen
>= attr_len
)
13699 error (_("Corrupt attribute section name\n"));
13703 printf (_("Attribute Section: "));
13704 print_symbol (INT_MAX
, (const char *) p
);
13707 if (public_name
&& streq ((char *) p
, public_name
))
13708 public_section
= TRUE
;
13710 public_section
= FALSE
;
13712 if (streq ((char *) p
, "gnu"))
13713 gnu_section
= TRUE
;
13715 gnu_section
= FALSE
;
13718 attr_len
-= namelen
;
13720 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13725 unsigned char * end
;
13727 /* PR binutils/17531: Safe handling of corrupt files. */
13730 error (_("Unused bytes at end of section\n"));
13736 size
= byte_get (p
, 4);
13737 if (size
> attr_len
)
13739 error (_("Bad subsection length (%u > %u)\n"),
13740 (unsigned) size
, (unsigned) attr_len
);
13743 /* PR binutils/17531: Safe handling of corrupt files. */
13746 error (_("Bad subsection length (%u < 6)\n"),
13753 end
= p
+ size
- 1;
13754 assert (end
<= contents
+ sect
->sh_size
);
13760 printf (_("File Attributes\n"));
13763 printf (_("Section Attributes:"));
13766 printf (_("Symbol Attributes:"));
13772 val
= read_uleb128 (p
, &j
, end
);
13776 printf (" %d", val
);
13781 printf (_("Unknown tag: %d\n"), tag
);
13782 public_section
= FALSE
;
13786 if (public_section
&& display_pub_attribute
!= NULL
)
13789 p
= display_pub_attribute (p
, end
);
13792 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13795 p
= display_gnu_attribute (p
,
13796 display_proc_gnu_attribute
,
13802 printf (_(" Unknown attribute:\n"));
13803 display_raw_attribute (p
, end
);
13812 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13820 process_arm_specific (FILE * file
)
13822 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13823 display_arm_attribute
, NULL
);
13827 process_power_specific (FILE * file
)
13829 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13830 display_power_gnu_attribute
);
13834 process_s390_specific (FILE * file
)
13836 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13837 display_s390_gnu_attribute
);
13841 process_sparc_specific (FILE * file
)
13843 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13844 display_sparc_gnu_attribute
);
13848 process_tic6x_specific (FILE * file
)
13850 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13851 display_tic6x_attribute
, NULL
);
13855 process_msp430x_specific (FILE * file
)
13857 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13858 display_msp430x_attribute
, NULL
);
13861 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13862 Print the Address, Access and Initial fields of an entry at VMA ADDR
13863 and return the VMA of the next entry, or -1 if there was a problem.
13864 Does not read from DATA_END or beyond. */
13867 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13868 unsigned char * data_end
)
13871 print_vma (addr
, LONG_HEX
);
13873 if (addr
< pltgot
+ 0xfff0)
13874 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13876 printf ("%10s", "");
13879 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13883 unsigned char * from
= data
+ addr
- pltgot
;
13885 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13887 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13888 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13889 return (bfd_vma
) -1;
13893 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13894 print_vma (entry
, LONG_HEX
);
13897 return addr
+ (is_32bit_elf
? 4 : 8);
13900 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13901 PLTGOT. Print the Address and Initial fields of an entry at VMA
13902 ADDR and return the VMA of the next entry. */
13905 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13908 print_vma (addr
, LONG_HEX
);
13911 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13916 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13917 print_vma (entry
, LONG_HEX
);
13919 return addr
+ (is_32bit_elf
? 4 : 8);
13923 print_mips_ases (unsigned int mask
)
13925 if (mask
& AFL_ASE_DSP
)
13926 fputs ("\n\tDSP ASE", stdout
);
13927 if (mask
& AFL_ASE_DSPR2
)
13928 fputs ("\n\tDSP R2 ASE", stdout
);
13929 if (mask
& AFL_ASE_EVA
)
13930 fputs ("\n\tEnhanced VA Scheme", stdout
);
13931 if (mask
& AFL_ASE_MCU
)
13932 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13933 if (mask
& AFL_ASE_MDMX
)
13934 fputs ("\n\tMDMX ASE", stdout
);
13935 if (mask
& AFL_ASE_MIPS3D
)
13936 fputs ("\n\tMIPS-3D ASE", stdout
);
13937 if (mask
& AFL_ASE_MT
)
13938 fputs ("\n\tMT ASE", stdout
);
13939 if (mask
& AFL_ASE_SMARTMIPS
)
13940 fputs ("\n\tSmartMIPS ASE", stdout
);
13941 if (mask
& AFL_ASE_VIRT
)
13942 fputs ("\n\tVZ ASE", stdout
);
13943 if (mask
& AFL_ASE_MSA
)
13944 fputs ("\n\tMSA ASE", stdout
);
13945 if (mask
& AFL_ASE_MIPS16
)
13946 fputs ("\n\tMIPS16 ASE", stdout
);
13947 if (mask
& AFL_ASE_MICROMIPS
)
13948 fputs ("\n\tMICROMIPS ASE", stdout
);
13949 if (mask
& AFL_ASE_XPA
)
13950 fputs ("\n\tXPA ASE", stdout
);
13952 fprintf (stdout
, "\n\t%s", _("None"));
13953 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13954 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13958 print_mips_isa_ext (unsigned int isa_ext
)
13963 fputs (_("None"), stdout
);
13966 fputs ("RMI XLR", stdout
);
13968 case AFL_EXT_OCTEON3
:
13969 fputs ("Cavium Networks Octeon3", stdout
);
13971 case AFL_EXT_OCTEON2
:
13972 fputs ("Cavium Networks Octeon2", stdout
);
13974 case AFL_EXT_OCTEONP
:
13975 fputs ("Cavium Networks OcteonP", stdout
);
13977 case AFL_EXT_LOONGSON_3A
:
13978 fputs ("Loongson 3A", stdout
);
13980 case AFL_EXT_OCTEON
:
13981 fputs ("Cavium Networks Octeon", stdout
);
13984 fputs ("Toshiba R5900", stdout
);
13987 fputs ("MIPS R4650", stdout
);
13990 fputs ("LSI R4010", stdout
);
13993 fputs ("NEC VR4100", stdout
);
13996 fputs ("Toshiba R3900", stdout
);
13998 case AFL_EXT_10000
:
13999 fputs ("MIPS R10000", stdout
);
14002 fputs ("Broadcom SB-1", stdout
);
14005 fputs ("NEC VR4111/VR4181", stdout
);
14008 fputs ("NEC VR4120", stdout
);
14011 fputs ("NEC VR5400", stdout
);
14014 fputs ("NEC VR5500", stdout
);
14016 case AFL_EXT_LOONGSON_2E
:
14017 fputs ("ST Microelectronics Loongson 2E", stdout
);
14019 case AFL_EXT_LOONGSON_2F
:
14020 fputs ("ST Microelectronics Loongson 2F", stdout
);
14023 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14028 get_mips_reg_size (int reg_size
)
14030 return (reg_size
== AFL_REG_NONE
) ? 0
14031 : (reg_size
== AFL_REG_32
) ? 32
14032 : (reg_size
== AFL_REG_64
) ? 64
14033 : (reg_size
== AFL_REG_128
) ? 128
14038 process_mips_specific (FILE * file
)
14040 Elf_Internal_Dyn
* entry
;
14041 Elf_Internal_Shdr
*sect
= NULL
;
14042 size_t liblist_offset
= 0;
14043 size_t liblistno
= 0;
14044 size_t conflictsno
= 0;
14045 size_t options_offset
= 0;
14046 size_t conflicts_offset
= 0;
14047 size_t pltrelsz
= 0;
14049 bfd_vma pltgot
= 0;
14050 bfd_vma mips_pltgot
= 0;
14051 bfd_vma jmprel
= 0;
14052 bfd_vma local_gotno
= 0;
14053 bfd_vma gotsym
= 0;
14054 bfd_vma symtabno
= 0;
14056 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14057 display_mips_gnu_attribute
);
14059 sect
= find_section (".MIPS.abiflags");
14063 Elf_External_ABIFlags_v0
*abiflags_ext
;
14064 Elf_Internal_ABIFlags_v0 abiflags_in
;
14066 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14067 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14070 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14071 sect
->sh_size
, _("MIPS ABI Flags section"));
14074 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14075 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14076 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14077 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14078 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14079 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14080 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14081 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14082 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14083 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14084 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14086 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14087 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14088 if (abiflags_in
.isa_rev
> 1)
14089 printf ("r%d", abiflags_in
.isa_rev
);
14090 printf ("\nGPR size: %d",
14091 get_mips_reg_size (abiflags_in
.gpr_size
));
14092 printf ("\nCPR1 size: %d",
14093 get_mips_reg_size (abiflags_in
.cpr1_size
));
14094 printf ("\nCPR2 size: %d",
14095 get_mips_reg_size (abiflags_in
.cpr2_size
));
14096 fputs ("\nFP ABI: ", stdout
);
14097 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14098 fputs ("ISA Extension: ", stdout
);
14099 print_mips_isa_ext (abiflags_in
.isa_ext
);
14100 fputs ("\nASEs:", stdout
);
14101 print_mips_ases (abiflags_in
.ases
);
14102 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14103 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14104 fputc ('\n', stdout
);
14105 free (abiflags_ext
);
14110 /* We have a lot of special sections. Thanks SGI! */
14111 if (dynamic_section
== NULL
)
14112 /* No information available. */
14115 for (entry
= dynamic_section
;
14116 /* PR 17531 file: 012-50589-0.004. */
14117 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14119 switch (entry
->d_tag
)
14121 case DT_MIPS_LIBLIST
:
14123 = offset_from_vma (file
, entry
->d_un
.d_val
,
14124 liblistno
* sizeof (Elf32_External_Lib
));
14126 case DT_MIPS_LIBLISTNO
:
14127 liblistno
= entry
->d_un
.d_val
;
14129 case DT_MIPS_OPTIONS
:
14130 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14132 case DT_MIPS_CONFLICT
:
14134 = offset_from_vma (file
, entry
->d_un
.d_val
,
14135 conflictsno
* sizeof (Elf32_External_Conflict
));
14137 case DT_MIPS_CONFLICTNO
:
14138 conflictsno
= entry
->d_un
.d_val
;
14141 pltgot
= entry
->d_un
.d_ptr
;
14143 case DT_MIPS_LOCAL_GOTNO
:
14144 local_gotno
= entry
->d_un
.d_val
;
14146 case DT_MIPS_GOTSYM
:
14147 gotsym
= entry
->d_un
.d_val
;
14149 case DT_MIPS_SYMTABNO
:
14150 symtabno
= entry
->d_un
.d_val
;
14152 case DT_MIPS_PLTGOT
:
14153 mips_pltgot
= entry
->d_un
.d_ptr
;
14156 pltrel
= entry
->d_un
.d_val
;
14159 pltrelsz
= entry
->d_un
.d_val
;
14162 jmprel
= entry
->d_un
.d_ptr
;
14168 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14170 Elf32_External_Lib
* elib
;
14173 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14175 sizeof (Elf32_External_Lib
),
14176 _("liblist section data"));
14179 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14180 (unsigned long) liblistno
);
14181 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14184 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14191 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14192 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14193 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14194 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14195 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14197 tmp
= gmtime (&atime
);
14198 snprintf (timebuf
, sizeof (timebuf
),
14199 "%04u-%02u-%02uT%02u:%02u:%02u",
14200 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14201 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14203 printf ("%3lu: ", (unsigned long) cnt
);
14204 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14205 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14207 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14208 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14209 liblist
.l_version
);
14211 if (liblist
.l_flags
== 0)
14215 static const struct
14222 { " EXACT_MATCH", LL_EXACT_MATCH
},
14223 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14224 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14225 { " EXPORTS", LL_EXPORTS
},
14226 { " DELAY_LOAD", LL_DELAY_LOAD
},
14227 { " DELTA", LL_DELTA
}
14229 int flags
= liblist
.l_flags
;
14232 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14233 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14235 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14236 flags
^= l_flags_vals
[fcnt
].bit
;
14239 printf (" %#x", (unsigned int) flags
);
14249 if (options_offset
!= 0)
14251 Elf_External_Options
* eopt
;
14252 Elf_Internal_Options
* iopt
;
14253 Elf_Internal_Options
* option
;
14256 sect
= section_headers
;
14258 /* Find the section header so that we get the size. */
14259 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14260 /* PR 17533 file: 012-277276-0.004. */
14263 error (_("No MIPS_OPTIONS header found\n"));
14267 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14268 sect
->sh_size
, _("options"));
14271 iopt
= (Elf_Internal_Options
*)
14272 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14275 error (_("Out of memory allocatinf space for MIPS options\n"));
14282 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14284 Elf_External_Options
* eoption
;
14286 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14288 option
->kind
= BYTE_GET (eoption
->kind
);
14289 option
->size
= BYTE_GET (eoption
->size
);
14290 option
->section
= BYTE_GET (eoption
->section
);
14291 option
->info
= BYTE_GET (eoption
->info
);
14293 /* PR 17531: file: ffa0fa3b. */
14294 if (option
->size
< sizeof (* eopt
)
14295 || offset
+ option
->size
> sect
->sh_size
)
14297 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14300 offset
+= option
->size
;
14306 printf (_("\nSection '%s' contains %d entries:\n"),
14307 printable_section_name (sect
), cnt
);
14316 switch (option
->kind
)
14319 /* This shouldn't happen. */
14320 printf (" NULL %d %lx", option
->section
, option
->info
);
14323 printf (" REGINFO ");
14324 if (elf_header
.e_machine
== EM_MIPS
)
14327 Elf32_External_RegInfo
* ereg
;
14328 Elf32_RegInfo reginfo
;
14330 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14331 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14332 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14333 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14334 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14335 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14336 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14338 printf ("GPR %08lx GP 0x%lx\n",
14339 reginfo
.ri_gprmask
,
14340 (unsigned long) reginfo
.ri_gp_value
);
14341 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14342 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14343 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14348 Elf64_External_RegInfo
* ereg
;
14349 Elf64_Internal_RegInfo reginfo
;
14351 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14352 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14353 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14354 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14355 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14356 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14357 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14359 printf ("GPR %08lx GP 0x",
14360 reginfo
.ri_gprmask
);
14361 printf_vma (reginfo
.ri_gp_value
);
14364 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14365 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14366 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14370 case ODK_EXCEPTIONS
:
14371 fputs (" EXCEPTIONS fpe_min(", stdout
);
14372 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14373 fputs (") fpe_max(", stdout
);
14374 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14375 fputs (")", stdout
);
14377 if (option
->info
& OEX_PAGE0
)
14378 fputs (" PAGE0", stdout
);
14379 if (option
->info
& OEX_SMM
)
14380 fputs (" SMM", stdout
);
14381 if (option
->info
& OEX_FPDBUG
)
14382 fputs (" FPDBUG", stdout
);
14383 if (option
->info
& OEX_DISMISS
)
14384 fputs (" DISMISS", stdout
);
14387 fputs (" PAD ", stdout
);
14388 if (option
->info
& OPAD_PREFIX
)
14389 fputs (" PREFIX", stdout
);
14390 if (option
->info
& OPAD_POSTFIX
)
14391 fputs (" POSTFIX", stdout
);
14392 if (option
->info
& OPAD_SYMBOL
)
14393 fputs (" SYMBOL", stdout
);
14396 fputs (" HWPATCH ", stdout
);
14397 if (option
->info
& OHW_R4KEOP
)
14398 fputs (" R4KEOP", stdout
);
14399 if (option
->info
& OHW_R8KPFETCH
)
14400 fputs (" R8KPFETCH", stdout
);
14401 if (option
->info
& OHW_R5KEOP
)
14402 fputs (" R5KEOP", stdout
);
14403 if (option
->info
& OHW_R5KCVTL
)
14404 fputs (" R5KCVTL", stdout
);
14407 fputs (" FILL ", stdout
);
14408 /* XXX Print content of info word? */
14411 fputs (" TAGS ", stdout
);
14412 /* XXX Print content of info word? */
14415 fputs (" HWAND ", stdout
);
14416 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14417 fputs (" R4KEOP_CHECKED", stdout
);
14418 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14419 fputs (" R4KEOP_CLEAN", stdout
);
14422 fputs (" HWOR ", stdout
);
14423 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14424 fputs (" R4KEOP_CHECKED", stdout
);
14425 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14426 fputs (" R4KEOP_CLEAN", stdout
);
14429 printf (" GP_GROUP %#06lx self-contained %#06lx",
14430 option
->info
& OGP_GROUP
,
14431 (option
->info
& OGP_SELF
) >> 16);
14434 printf (" IDENT %#06lx self-contained %#06lx",
14435 option
->info
& OGP_GROUP
,
14436 (option
->info
& OGP_SELF
) >> 16);
14439 /* This shouldn't happen. */
14440 printf (" %3d ??? %d %lx",
14441 option
->kind
, option
->section
, option
->info
);
14445 len
= sizeof (* eopt
);
14446 while (len
< option
->size
)
14448 char datum
= * ((char *) eopt
+ offset
+ len
);
14450 if (ISPRINT (datum
))
14451 printf ("%c", datum
);
14453 printf ("\\%03o", datum
);
14456 fputs ("\n", stdout
);
14458 offset
+= option
->size
;
14466 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14468 Elf32_Conflict
* iconf
;
14471 if (dynamic_symbols
== NULL
)
14473 error (_("conflict list found without a dynamic symbol table\n"));
14477 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14480 error (_("Out of memory allocating space for dynamic conflicts\n"));
14486 Elf32_External_Conflict
* econf32
;
14488 econf32
= (Elf32_External_Conflict
*)
14489 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14490 sizeof (* econf32
), _("conflict"));
14494 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14495 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14501 Elf64_External_Conflict
* econf64
;
14503 econf64
= (Elf64_External_Conflict
*)
14504 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14505 sizeof (* econf64
), _("conflict"));
14509 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14510 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14515 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14516 (unsigned long) conflictsno
);
14517 puts (_(" Num: Index Value Name"));
14519 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14521 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14523 if (iconf
[cnt
] >= num_dynamic_syms
)
14524 printf (_("<corrupt symbol index>"));
14527 Elf_Internal_Sym
* psym
;
14529 psym
= & dynamic_symbols
[iconf
[cnt
]];
14530 print_vma (psym
->st_value
, FULL_HEX
);
14532 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14533 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14535 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14543 if (pltgot
!= 0 && local_gotno
!= 0)
14545 bfd_vma ent
, local_end
, global_end
;
14547 unsigned char * data
;
14548 unsigned char * data_end
;
14552 addr_size
= (is_32bit_elf
? 4 : 8);
14553 local_end
= pltgot
+ local_gotno
* addr_size
;
14555 /* PR binutils/17533 file: 012-111227-0.004 */
14556 if (symtabno
< gotsym
)
14558 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14559 (unsigned long) gotsym
, (unsigned long) symtabno
);
14563 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14564 /* PR 17531: file: 54c91a34. */
14565 if (global_end
< local_end
)
14567 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14571 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14572 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14573 global_end
- pltgot
, 1,
14574 _("Global Offset Table data"));
14577 data_end
= data
+ (global_end
- pltgot
);
14579 printf (_("\nPrimary GOT:\n"));
14580 printf (_(" Canonical gp value: "));
14581 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14584 printf (_(" Reserved entries:\n"));
14585 printf (_(" %*s %10s %*s Purpose\n"),
14586 addr_size
* 2, _("Address"), _("Access"),
14587 addr_size
* 2, _("Initial"));
14588 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14589 printf (_(" Lazy resolver\n"));
14590 if (ent
== (bfd_vma
) -1)
14591 goto got_print_fail
;
14593 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14594 >> (addr_size
* 8 - 1)) != 0)
14596 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14597 printf (_(" Module pointer (GNU extension)\n"));
14598 if (ent
== (bfd_vma
) -1)
14599 goto got_print_fail
;
14603 if (ent
< local_end
)
14605 printf (_(" Local entries:\n"));
14606 printf (" %*s %10s %*s\n",
14607 addr_size
* 2, _("Address"), _("Access"),
14608 addr_size
* 2, _("Initial"));
14609 while (ent
< local_end
)
14611 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14613 if (ent
== (bfd_vma
) -1)
14614 goto got_print_fail
;
14619 if (gotsym
< symtabno
)
14623 printf (_(" Global entries:\n"));
14624 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14625 addr_size
* 2, _("Address"),
14627 addr_size
* 2, _("Initial"),
14628 addr_size
* 2, _("Sym.Val."),
14630 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14631 _("Ndx"), _("Name"));
14633 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14635 for (i
= gotsym
; i
< symtabno
; i
++)
14637 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14640 if (dynamic_symbols
== NULL
)
14641 printf (_("<no dynamic symbols>"));
14642 else if (i
< num_dynamic_syms
)
14644 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14646 print_vma (psym
->st_value
, LONG_HEX
);
14647 printf (" %-7s %3s ",
14648 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14649 get_symbol_index_type (psym
->st_shndx
));
14651 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14652 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14654 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14657 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14658 (unsigned long) i
);
14661 if (ent
== (bfd_vma
) -1)
14672 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14675 size_t offset
, rel_offset
;
14676 unsigned long count
, i
;
14677 unsigned char * data
;
14678 int addr_size
, sym_width
;
14679 Elf_Internal_Rela
* rels
;
14681 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14682 if (pltrel
== DT_RELA
)
14684 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14689 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14694 addr_size
= (is_32bit_elf
? 4 : 8);
14695 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14697 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14698 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14699 1, _("Procedure Linkage Table data"));
14703 printf ("\nPLT GOT:\n\n");
14704 printf (_(" Reserved entries:\n"));
14705 printf (_(" %*s %*s Purpose\n"),
14706 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14707 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14708 printf (_(" PLT lazy resolver\n"));
14709 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14710 printf (_(" Module pointer\n"));
14713 printf (_(" Entries:\n"));
14714 printf (" %*s %*s %*s %-7s %3s %s\n",
14715 addr_size
* 2, _("Address"),
14716 addr_size
* 2, _("Initial"),
14717 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14718 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14719 for (i
= 0; i
< count
; i
++)
14721 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14723 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14726 if (idx
>= num_dynamic_syms
)
14727 printf (_("<corrupt symbol index: %lu>"), idx
);
14730 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14732 print_vma (psym
->st_value
, LONG_HEX
);
14733 printf (" %-7s %3s ",
14734 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14735 get_symbol_index_type (psym
->st_shndx
));
14736 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14737 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14739 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14754 process_nds32_specific (FILE * file
)
14756 Elf_Internal_Shdr
*sect
= NULL
;
14758 sect
= find_section (".nds32_e_flags");
14761 unsigned int *flag
;
14763 printf ("\nNDS32 elf flags section:\n");
14764 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14765 sect
->sh_size
, _("NDS32 elf flags section"));
14767 switch ((*flag
) & 0x3)
14770 printf ("(VEC_SIZE):\tNo entry.\n");
14773 printf ("(VEC_SIZE):\t4 bytes\n");
14776 printf ("(VEC_SIZE):\t16 bytes\n");
14779 printf ("(VEC_SIZE):\treserved\n");
14788 process_gnu_liblist (FILE * file
)
14790 Elf_Internal_Shdr
* section
;
14791 Elf_Internal_Shdr
* string_sec
;
14792 Elf32_External_Lib
* elib
;
14794 size_t strtab_size
;
14801 for (i
= 0, section
= section_headers
;
14802 i
< elf_header
.e_shnum
;
14805 switch (section
->sh_type
)
14807 case SHT_GNU_LIBLIST
:
14808 if (section
->sh_link
>= elf_header
.e_shnum
)
14811 elib
= (Elf32_External_Lib
*)
14812 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14813 _("liblist section data"));
14817 string_sec
= section_headers
+ section
->sh_link
;
14819 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14820 string_sec
->sh_size
,
14821 _("liblist string table"));
14823 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14829 strtab_size
= string_sec
->sh_size
;
14831 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14832 printable_section_name (section
),
14833 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14835 puts (_(" Library Time Stamp Checksum Version Flags"));
14837 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14845 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14846 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14847 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14848 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14849 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14851 tmp
= gmtime (&atime
);
14852 snprintf (timebuf
, sizeof (timebuf
),
14853 "%04u-%02u-%02uT%02u:%02u:%02u",
14854 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14855 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14857 printf ("%3lu: ", (unsigned long) cnt
);
14859 printf ("%-20s", liblist
.l_name
< strtab_size
14860 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14862 printf ("%-20.20s", liblist
.l_name
< strtab_size
14863 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14864 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14865 liblist
.l_version
, liblist
.l_flags
);
14876 static const char *
14877 get_note_type (unsigned e_type
)
14879 static char buff
[64];
14881 if (elf_header
.e_type
== ET_CORE
)
14885 return _("NT_AUXV (auxiliary vector)");
14887 return _("NT_PRSTATUS (prstatus structure)");
14889 return _("NT_FPREGSET (floating point registers)");
14891 return _("NT_PRPSINFO (prpsinfo structure)");
14892 case NT_TASKSTRUCT
:
14893 return _("NT_TASKSTRUCT (task structure)");
14895 return _("NT_PRXFPREG (user_xfpregs structure)");
14897 return _("NT_PPC_VMX (ppc Altivec registers)");
14899 return _("NT_PPC_VSX (ppc VSX registers)");
14901 return _("NT_386_TLS (x86 TLS information)");
14902 case NT_386_IOPERM
:
14903 return _("NT_386_IOPERM (x86 I/O permissions)");
14904 case NT_X86_XSTATE
:
14905 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14906 case NT_S390_HIGH_GPRS
:
14907 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14908 case NT_S390_TIMER
:
14909 return _("NT_S390_TIMER (s390 timer register)");
14910 case NT_S390_TODCMP
:
14911 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14912 case NT_S390_TODPREG
:
14913 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14915 return _("NT_S390_CTRS (s390 control registers)");
14916 case NT_S390_PREFIX
:
14917 return _("NT_S390_PREFIX (s390 prefix register)");
14918 case NT_S390_LAST_BREAK
:
14919 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14920 case NT_S390_SYSTEM_CALL
:
14921 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14923 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14924 case NT_S390_VXRS_LOW
:
14925 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
14926 case NT_S390_VXRS_HIGH
:
14927 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
14929 return _("NT_ARM_VFP (arm VFP registers)");
14931 return _("NT_ARM_TLS (AArch TLS registers)");
14932 case NT_ARM_HW_BREAK
:
14933 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14934 case NT_ARM_HW_WATCH
:
14935 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14937 return _("NT_PSTATUS (pstatus structure)");
14939 return _("NT_FPREGS (floating point registers)");
14941 return _("NT_PSINFO (psinfo structure)");
14943 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14945 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14946 case NT_WIN32PSTATUS
:
14947 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14949 return _("NT_SIGINFO (siginfo_t data)");
14951 return _("NT_FILE (mapped files)");
14959 return _("NT_VERSION (version)");
14961 return _("NT_ARCH (architecture)");
14966 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14971 print_core_note (Elf_Internal_Note
*pnote
)
14973 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14974 bfd_vma count
, page_size
;
14975 unsigned char *descdata
, *filenames
, *descend
;
14977 if (pnote
->type
!= NT_FILE
)
14983 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14984 /* Still "successful". */
14989 if (pnote
->descsz
< 2 * addr_size
)
14991 printf (_(" Malformed note - too short for header\n"));
14995 descdata
= (unsigned char *) pnote
->descdata
;
14996 descend
= descdata
+ pnote
->descsz
;
14998 if (descdata
[pnote
->descsz
- 1] != '\0')
15000 printf (_(" Malformed note - does not end with \\0\n"));
15004 count
= byte_get (descdata
, addr_size
);
15005 descdata
+= addr_size
;
15007 page_size
= byte_get (descdata
, addr_size
);
15008 descdata
+= addr_size
;
15010 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15012 printf (_(" Malformed note - too short for supplied file count\n"));
15016 printf (_(" Page size: "));
15017 print_vma (page_size
, DEC
);
15020 printf (_(" %*s%*s%*s\n"),
15021 (int) (2 + 2 * addr_size
), _("Start"),
15022 (int) (4 + 2 * addr_size
), _("End"),
15023 (int) (4 + 2 * addr_size
), _("Page Offset"));
15024 filenames
= descdata
+ count
* 3 * addr_size
;
15025 while (--count
> 0)
15027 bfd_vma start
, end
, file_ofs
;
15029 if (filenames
== descend
)
15031 printf (_(" Malformed note - filenames end too early\n"));
15035 start
= byte_get (descdata
, addr_size
);
15036 descdata
+= addr_size
;
15037 end
= byte_get (descdata
, addr_size
);
15038 descdata
+= addr_size
;
15039 file_ofs
= byte_get (descdata
, addr_size
);
15040 descdata
+= addr_size
;
15043 print_vma (start
, FULL_HEX
);
15045 print_vma (end
, FULL_HEX
);
15047 print_vma (file_ofs
, FULL_HEX
);
15048 printf ("\n %s\n", filenames
);
15050 filenames
+= 1 + strlen ((char *) filenames
);
15056 static const char *
15057 get_gnu_elf_note_type (unsigned e_type
)
15059 static char buff
[64];
15063 case NT_GNU_ABI_TAG
:
15064 return _("NT_GNU_ABI_TAG (ABI version tag)");
15066 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15067 case NT_GNU_BUILD_ID
:
15068 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15069 case NT_GNU_GOLD_VERSION
:
15070 return _("NT_GNU_GOLD_VERSION (gold version)");
15075 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15080 print_gnu_note (Elf_Internal_Note
*pnote
)
15082 switch (pnote
->type
)
15084 case NT_GNU_BUILD_ID
:
15088 printf (_(" Build ID: "));
15089 for (i
= 0; i
< pnote
->descsz
; ++i
)
15090 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15095 case NT_GNU_ABI_TAG
:
15097 unsigned long os
, major
, minor
, subminor
;
15098 const char *osname
;
15100 /* PR 17531: file: 030-599401-0.004. */
15101 if (pnote
->descsz
< 16)
15103 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15107 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15108 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15109 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15110 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15114 case GNU_ABI_TAG_LINUX
:
15117 case GNU_ABI_TAG_HURD
:
15120 case GNU_ABI_TAG_SOLARIS
:
15121 osname
= "Solaris";
15123 case GNU_ABI_TAG_FREEBSD
:
15124 osname
= "FreeBSD";
15126 case GNU_ABI_TAG_NETBSD
:
15129 case GNU_ABI_TAG_SYLLABLE
:
15130 osname
= "Syllable";
15132 case GNU_ABI_TAG_NACL
:
15136 osname
= "Unknown";
15140 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15141 major
, minor
, subminor
);
15145 case NT_GNU_GOLD_VERSION
:
15149 printf (_(" Version: "));
15150 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15151 printf ("%c", pnote
->descdata
[i
]);
15160 static const char *
15161 get_v850_elf_note_type (enum v850_notes n_type
)
15163 static char buff
[64];
15167 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15168 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15169 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15170 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15171 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15172 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15174 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15180 print_v850_note (Elf_Internal_Note
* pnote
)
15184 if (pnote
->descsz
!= 4)
15186 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15190 printf (_("not set\n"));
15194 switch (pnote
->type
)
15196 case V850_NOTE_ALIGNMENT
:
15199 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15200 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15204 case V850_NOTE_DATA_SIZE
:
15207 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15208 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15212 case V850_NOTE_FPU_INFO
:
15215 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15216 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15220 case V850_NOTE_MMU_INFO
:
15221 case V850_NOTE_CACHE_INFO
:
15222 case V850_NOTE_SIMD_INFO
:
15223 if (val
== EF_RH850_SIMD
)
15225 printf (_("yes\n"));
15231 /* An 'unknown note type' message will already have been displayed. */
15235 printf (_("unknown value: %x\n"), val
);
15239 static const char *
15240 get_netbsd_elfcore_note_type (unsigned e_type
)
15242 static char buff
[64];
15244 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15246 /* NetBSD core "procinfo" structure. */
15247 return _("NetBSD procinfo structure");
15250 /* As of Jan 2002 there are no other machine-independent notes
15251 defined for NetBSD core files. If the note type is less
15252 than the start of the machine-dependent note types, we don't
15255 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15257 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15261 switch (elf_header
.e_machine
)
15263 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15264 and PT_GETFPREGS == mach+2. */
15269 case EM_SPARC32PLUS
:
15273 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15274 return _("PT_GETREGS (reg structure)");
15275 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15276 return _("PT_GETFPREGS (fpreg structure)");
15282 /* On all other arch's, PT_GETREGS == mach+1 and
15283 PT_GETFPREGS == mach+3. */
15287 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15288 return _("PT_GETREGS (reg structure)");
15289 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15290 return _("PT_GETFPREGS (fpreg structure)");
15296 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15297 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15301 static const char *
15302 get_stapsdt_note_type (unsigned e_type
)
15304 static char buff
[64];
15309 return _("NT_STAPSDT (SystemTap probe descriptors)");
15315 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15320 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15322 int addr_size
= is_32bit_elf
? 4 : 8;
15323 char *data
= pnote
->descdata
;
15324 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15325 bfd_vma pc
, base_addr
, semaphore
;
15326 char *provider
, *probe
, *arg_fmt
;
15328 pc
= byte_get ((unsigned char *) data
, addr_size
);
15330 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15332 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15336 data
+= strlen (data
) + 1;
15338 data
+= strlen (data
) + 1;
15340 data
+= strlen (data
) + 1;
15342 printf (_(" Provider: %s\n"), provider
);
15343 printf (_(" Name: %s\n"), probe
);
15344 printf (_(" Location: "));
15345 print_vma (pc
, FULL_HEX
);
15346 printf (_(", Base: "));
15347 print_vma (base_addr
, FULL_HEX
);
15348 printf (_(", Semaphore: "));
15349 print_vma (semaphore
, FULL_HEX
);
15351 printf (_(" Arguments: %s\n"), arg_fmt
);
15353 return data
== data_end
;
15356 static const char *
15357 get_ia64_vms_note_type (unsigned e_type
)
15359 static char buff
[64];
15364 return _("NT_VMS_MHD (module header)");
15366 return _("NT_VMS_LNM (language name)");
15368 return _("NT_VMS_SRC (source files)");
15370 return "NT_VMS_TITLE";
15372 return _("NT_VMS_EIDC (consistency check)");
15373 case NT_VMS_FPMODE
:
15374 return _("NT_VMS_FPMODE (FP mode)");
15375 case NT_VMS_LINKTIME
:
15376 return "NT_VMS_LINKTIME";
15377 case NT_VMS_IMGNAM
:
15378 return _("NT_VMS_IMGNAM (image name)");
15380 return _("NT_VMS_IMGID (image id)");
15381 case NT_VMS_LINKID
:
15382 return _("NT_VMS_LINKID (link id)");
15383 case NT_VMS_IMGBID
:
15384 return _("NT_VMS_IMGBID (build id)");
15385 case NT_VMS_GSTNAM
:
15386 return _("NT_VMS_GSTNAM (sym table name)");
15387 case NT_VMS_ORIG_DYN
:
15388 return "NT_VMS_ORIG_DYN";
15389 case NT_VMS_PATCHTIME
:
15390 return "NT_VMS_PATCHTIME";
15392 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15398 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15400 switch (pnote
->type
)
15403 if (pnote
->descsz
> 36)
15405 size_t l
= strlen (pnote
->descdata
+ 34);
15406 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15407 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15408 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15409 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15412 printf (_(" Invalid size\n"));
15415 printf (_(" Language: %s\n"), pnote
->descdata
);
15418 case NT_VMS_FPMODE
:
15419 printf (_(" Floating Point mode: "));
15420 printf ("0x%016" BFD_VMA_FMT
"x\n",
15421 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15423 case NT_VMS_LINKTIME
:
15424 printf (_(" Link time: "));
15426 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15429 case NT_VMS_PATCHTIME
:
15430 printf (_(" Patch time: "));
15432 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15435 case NT_VMS_ORIG_DYN
:
15436 printf (_(" Major id: %u, minor id: %u\n"),
15437 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15438 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15439 printf (_(" Last modified : "));
15441 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15442 printf (_("\n Link flags : "));
15443 printf ("0x%016" BFD_VMA_FMT
"x\n",
15444 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15445 printf (_(" Header flags: 0x%08x\n"),
15446 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15447 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15450 case NT_VMS_IMGNAM
:
15451 printf (_(" Image name: %s\n"), pnote
->descdata
);
15453 case NT_VMS_GSTNAM
:
15454 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15457 printf (_(" Image id: %s\n"), pnote
->descdata
);
15459 case NT_VMS_LINKID
:
15460 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15468 /* Note that by the ELF standard, the name field is already null byte
15469 terminated, and namesz includes the terminating null byte.
15470 I.E. the value of namesz for the name "FSF" is 4.
15472 If the value of namesz is zero, there is no name present. */
15474 process_note (Elf_Internal_Note
* pnote
)
15476 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15479 if (pnote
->namesz
== 0)
15480 /* If there is no note name, then use the default set of
15481 note type strings. */
15482 nt
= get_note_type (pnote
->type
);
15484 else if (const_strneq (pnote
->namedata
, "GNU"))
15485 /* GNU-specific object file notes. */
15486 nt
= get_gnu_elf_note_type (pnote
->type
);
15488 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15489 /* NetBSD-specific core file notes. */
15490 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15492 else if (strneq (pnote
->namedata
, "SPU/", 4))
15494 /* SPU-specific core file notes. */
15495 nt
= pnote
->namedata
+ 4;
15499 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15500 /* VMS/ia64-specific file notes. */
15501 nt
= get_ia64_vms_note_type (pnote
->type
);
15503 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15504 nt
= get_stapsdt_note_type (pnote
->type
);
15507 /* Don't recognize this note name; just use the default set of
15508 note type strings. */
15509 nt
= get_note_type (pnote
->type
);
15511 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15513 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15514 return print_ia64_vms_note (pnote
);
15515 else if (const_strneq (pnote
->namedata
, "GNU"))
15516 return print_gnu_note (pnote
);
15517 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15518 return print_stapsdt_note (pnote
);
15519 else if (const_strneq (pnote
->namedata
, "CORE"))
15520 return print_core_note (pnote
);
15527 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15529 Elf_External_Note
* pnotes
;
15530 Elf_External_Note
* external
;
15537 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15539 if (pnotes
== NULL
)
15544 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15545 (unsigned long) offset
, (unsigned long) length
);
15546 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15548 end
= (char *) pnotes
+ length
;
15549 while ((char *) external
< end
)
15551 Elf_Internal_Note inote
;
15554 char * temp
= NULL
;
15555 size_t data_remaining
= end
- (char *) external
;
15557 if (!is_ia64_vms ())
15559 /* PR binutils/15191
15560 Make sure that there is enough data to read. */
15561 min_notesz
= offsetof (Elf_External_Note
, name
);
15562 if (data_remaining
< min_notesz
)
15564 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15565 (int) data_remaining
);
15568 inote
.type
= BYTE_GET (external
->type
);
15569 inote
.namesz
= BYTE_GET (external
->namesz
);
15570 inote
.namedata
= external
->name
;
15571 inote
.descsz
= BYTE_GET (external
->descsz
);
15572 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15573 /* PR 17531: file: 3443835e. */
15574 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15576 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15577 inote
.descdata
= inote
.namedata
;
15581 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15582 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15586 Elf64_External_VMS_Note
*vms_external
;
15588 /* PR binutils/15191
15589 Make sure that there is enough data to read. */
15590 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15591 if (data_remaining
< min_notesz
)
15593 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15594 (int) data_remaining
);
15598 vms_external
= (Elf64_External_VMS_Note
*) external
;
15599 inote
.type
= BYTE_GET (vms_external
->type
);
15600 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15601 inote
.namedata
= vms_external
->name
;
15602 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15603 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15604 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15605 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15608 if (inote
.descdata
< (char *) external
+ min_notesz
15609 || next
< (char *) external
+ min_notesz
15610 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15611 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15612 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15613 || data_remaining
< (size_t)(next
- (char *) external
))
15615 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15616 (unsigned long) ((char *) external
- (char *) pnotes
));
15617 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15618 inote
.type
, inote
.namesz
, inote
.descsz
);
15622 external
= (Elf_External_Note
*) next
;
15624 /* Verify that name is null terminated. It appears that at least
15625 one version of Linux (RedHat 6.0) generates corefiles that don't
15626 comply with the ELF spec by failing to include the null byte in
15628 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15630 temp
= (char *) malloc (inote
.namesz
+ 1);
15633 error (_("Out of memory allocating space for inote name\n"));
15638 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15639 temp
[inote
.namesz
] = 0;
15641 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15642 inote
.namedata
= temp
;
15645 res
&= process_note (& inote
);
15660 process_corefile_note_segments (FILE * file
)
15662 Elf_Internal_Phdr
* segment
;
15666 if (! get_program_headers (file
))
15669 for (i
= 0, segment
= program_headers
;
15670 i
< elf_header
.e_phnum
;
15673 if (segment
->p_type
== PT_NOTE
)
15674 res
&= process_corefile_note_segment (file
,
15675 (bfd_vma
) segment
->p_offset
,
15676 (bfd_vma
) segment
->p_filesz
);
15683 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15685 Elf_External_Note
* pnotes
;
15686 Elf_External_Note
* external
;
15693 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15695 if (pnotes
== NULL
)
15699 end
= (char*) pnotes
+ length
;
15701 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15702 (unsigned long) offset
, (unsigned long) length
);
15704 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15706 Elf_External_Note
* next
;
15707 Elf_Internal_Note inote
;
15709 inote
.type
= BYTE_GET (external
->type
);
15710 inote
.namesz
= BYTE_GET (external
->namesz
);
15711 inote
.namedata
= external
->name
;
15712 inote
.descsz
= BYTE_GET (external
->descsz
);
15713 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15714 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15716 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15718 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15719 inote
.descdata
= inote
.namedata
;
15723 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15725 if ( ((char *) next
> end
)
15726 || ((char *) next
< (char *) pnotes
))
15728 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15729 (unsigned long) ((char *) external
- (char *) pnotes
));
15730 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15731 inote
.type
, inote
.namesz
, inote
.descsz
);
15737 /* Prevent out-of-bounds indexing. */
15738 if ( inote
.namedata
+ inote
.namesz
> end
15739 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15741 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15742 (unsigned long) ((char *) external
- (char *) pnotes
));
15743 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15744 inote
.type
, inote
.namesz
, inote
.descsz
);
15748 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15750 if (! print_v850_note (& inote
))
15753 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15754 inote
.namesz
, inote
.descsz
);
15764 process_note_sections (FILE * file
)
15766 Elf_Internal_Shdr
* section
;
15771 for (i
= 0, section
= section_headers
;
15772 i
< elf_header
.e_shnum
&& section
!= NULL
;
15775 if (section
->sh_type
== SHT_NOTE
)
15777 res
&= process_corefile_note_segment (file
,
15778 (bfd_vma
) section
->sh_offset
,
15779 (bfd_vma
) section
->sh_size
);
15783 if (( elf_header
.e_machine
== EM_V800
15784 || elf_header
.e_machine
== EM_V850
15785 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15786 && section
->sh_type
== SHT_RENESAS_INFO
)
15788 res
&= process_v850_notes (file
,
15789 (bfd_vma
) section
->sh_offset
,
15790 (bfd_vma
) section
->sh_size
);
15796 /* Try processing NOTE segments instead. */
15797 return process_corefile_note_segments (file
);
15803 process_notes (FILE * file
)
15805 /* If we have not been asked to display the notes then do nothing. */
15809 if (elf_header
.e_type
!= ET_CORE
)
15810 return process_note_sections (file
);
15812 /* No program headers means no NOTE segment. */
15813 if (elf_header
.e_phnum
> 0)
15814 return process_corefile_note_segments (file
);
15816 printf (_("No note segments present in the core file.\n"));
15821 process_arch_specific (FILE * file
)
15826 switch (elf_header
.e_machine
)
15829 return process_arm_specific (file
);
15831 case EM_MIPS_RS3_LE
:
15832 return process_mips_specific (file
);
15835 return process_nds32_specific (file
);
15838 return process_power_specific (file
);
15842 return process_s390_specific (file
);
15845 case EM_SPARC32PLUS
:
15847 return process_sparc_specific (file
);
15850 return process_tic6x_specific (file
);
15853 return process_msp430x_specific (file
);
15861 get_file_header (FILE * file
)
15863 /* Read in the identity array. */
15864 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15867 /* Determine how to read the rest of the header. */
15868 switch (elf_header
.e_ident
[EI_DATA
])
15870 default: /* fall through */
15871 case ELFDATANONE
: /* fall through */
15873 byte_get
= byte_get_little_endian
;
15874 byte_put
= byte_put_little_endian
;
15877 byte_get
= byte_get_big_endian
;
15878 byte_put
= byte_put_big_endian
;
15882 /* For now we only support 32 bit and 64 bit ELF files. */
15883 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15885 /* Read in the rest of the header. */
15888 Elf32_External_Ehdr ehdr32
;
15890 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15893 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15894 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15895 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15896 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15897 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15898 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15899 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15900 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15901 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15902 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15903 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15904 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15905 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15909 Elf64_External_Ehdr ehdr64
;
15911 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15912 we will not be able to cope with the 64bit data found in
15913 64 ELF files. Detect this now and abort before we start
15914 overwriting things. */
15915 if (sizeof (bfd_vma
) < 8)
15917 error (_("This instance of readelf has been built without support for a\n\
15918 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15922 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15925 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15926 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15927 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15928 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15929 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15930 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15931 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15932 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15933 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15934 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15935 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15936 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15937 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15940 if (elf_header
.e_shoff
)
15942 /* There may be some extensions in the first section header. Don't
15943 bomb if we can't read it. */
15945 get_32bit_section_headers (file
, TRUE
);
15947 get_64bit_section_headers (file
, TRUE
);
15953 /* Process one ELF object file according to the command line options.
15954 This file may actually be stored in an archive. The file is
15955 positioned at the start of the ELF object. */
15958 process_object (char * file_name
, FILE * file
)
15962 if (! get_file_header (file
))
15964 error (_("%s: Failed to read file header\n"), file_name
);
15968 /* Initialise per file variables. */
15969 for (i
= ARRAY_SIZE (version_info
); i
--;)
15970 version_info
[i
] = 0;
15972 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15973 dynamic_info
[i
] = 0;
15974 dynamic_info_DT_GNU_HASH
= 0;
15976 /* Process the file. */
15978 printf (_("\nFile: %s\n"), file_name
);
15980 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15981 Note we do this even if cmdline_dump_sects is empty because we
15982 must make sure that the dump_sets array is zeroed out before each
15983 object file is processed. */
15984 if (num_dump_sects
> num_cmdline_dump_sects
)
15985 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15987 if (num_cmdline_dump_sects
> 0)
15989 if (num_dump_sects
== 0)
15990 /* A sneaky way of allocating the dump_sects array. */
15991 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15993 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15994 memcpy (dump_sects
, cmdline_dump_sects
,
15995 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15998 if (! process_file_header ())
16001 if (! process_section_headers (file
))
16003 /* Without loaded section headers we cannot process lots of
16005 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16007 if (! do_using_dynamic
)
16008 do_syms
= do_dyn_syms
= do_reloc
= 0;
16011 if (! process_section_groups (file
))
16013 /* Without loaded section groups we cannot process unwind. */
16017 if (process_program_headers (file
))
16018 process_dynamic_section (file
);
16020 process_relocs (file
);
16022 process_unwind (file
);
16024 process_symbol_table (file
);
16026 process_syminfo (file
);
16028 process_version_sections (file
);
16030 process_section_contents (file
);
16032 process_notes (file
);
16034 process_gnu_liblist (file
);
16036 process_arch_specific (file
);
16038 if (program_headers
)
16040 free (program_headers
);
16041 program_headers
= NULL
;
16044 if (section_headers
)
16046 free (section_headers
);
16047 section_headers
= NULL
;
16052 free (string_table
);
16053 string_table
= NULL
;
16054 string_table_length
= 0;
16057 if (dynamic_strings
)
16059 free (dynamic_strings
);
16060 dynamic_strings
= NULL
;
16061 dynamic_strings_length
= 0;
16064 if (dynamic_symbols
)
16066 free (dynamic_symbols
);
16067 dynamic_symbols
= NULL
;
16068 num_dynamic_syms
= 0;
16071 if (dynamic_syminfo
)
16073 free (dynamic_syminfo
);
16074 dynamic_syminfo
= NULL
;
16077 if (dynamic_section
)
16079 free (dynamic_section
);
16080 dynamic_section
= NULL
;
16083 if (section_headers_groups
)
16085 free (section_headers_groups
);
16086 section_headers_groups
= NULL
;
16089 if (section_groups
)
16091 struct group_list
* g
;
16092 struct group_list
* next
;
16094 for (i
= 0; i
< group_count
; i
++)
16096 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16103 free (section_groups
);
16104 section_groups
= NULL
;
16107 free_debug_memory ();
16112 /* Process an ELF archive.
16113 On entry the file is positioned just after the ARMAG string. */
16116 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16118 struct archive_info arch
;
16119 struct archive_info nested_arch
;
16125 /* The ARCH structure is used to hold information about this archive. */
16126 arch
.file_name
= NULL
;
16128 arch
.index_array
= NULL
;
16129 arch
.sym_table
= NULL
;
16130 arch
.longnames
= NULL
;
16132 /* The NESTED_ARCH structure is used as a single-item cache of information
16133 about a nested archive (when members of a thin archive reside within
16134 another regular archive file). */
16135 nested_arch
.file_name
= NULL
;
16136 nested_arch
.file
= NULL
;
16137 nested_arch
.index_array
= NULL
;
16138 nested_arch
.sym_table
= NULL
;
16139 nested_arch
.longnames
= NULL
;
16141 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16147 if (do_archive_index
)
16149 if (arch
.sym_table
== NULL
)
16150 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16153 unsigned long i
, l
;
16154 unsigned long current_pos
;
16156 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16157 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16158 current_pos
= ftell (file
);
16160 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16162 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16164 char * member_name
;
16166 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16168 if (member_name
!= NULL
)
16170 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16172 if (qualified_name
!= NULL
)
16174 printf (_("Contents of binary %s at offset "), qualified_name
);
16175 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16177 free (qualified_name
);
16182 if (l
>= arch
.sym_size
)
16184 error (_("%s: end of the symbol table reached before the end of the index\n"),
16188 /* PR 17531: file: 0b6630b2. */
16189 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16190 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16193 if (arch
.uses_64bit_indicies
)
16198 if (l
< arch
.sym_size
)
16199 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16200 file_name
, arch
.sym_size
- l
);
16202 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16204 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16210 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16211 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16212 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16213 && !do_section_groups
&& !do_dyn_syms
)
16215 ret
= 0; /* Archive index only. */
16226 char * qualified_name
;
16228 /* Read the next archive header. */
16229 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16231 error (_("%s: failed to seek to next archive header\n"), file_name
);
16234 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16235 if (got
!= sizeof arch
.arhdr
)
16239 error (_("%s: failed to read archive header\n"), file_name
);
16243 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16245 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16250 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16252 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16253 if (archive_file_size
& 01)
16254 ++archive_file_size
;
16256 name
= get_archive_member_name (&arch
, &nested_arch
);
16259 error (_("%s: bad archive file name\n"), file_name
);
16263 namelen
= strlen (name
);
16265 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16266 if (qualified_name
== NULL
)
16268 error (_("%s: bad archive file name\n"), file_name
);
16273 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16275 /* This is a proxy for an external member of a thin archive. */
16276 FILE * member_file
;
16277 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16278 if (member_file_name
== NULL
)
16284 member_file
= fopen (member_file_name
, "rb");
16285 if (member_file
== NULL
)
16287 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16288 free (member_file_name
);
16293 archive_file_offset
= arch
.nested_member_origin
;
16295 ret
|= process_object (qualified_name
, member_file
);
16297 fclose (member_file
);
16298 free (member_file_name
);
16300 else if (is_thin_archive
)
16302 /* PR 15140: Allow for corrupt thin archives. */
16303 if (nested_arch
.file
== NULL
)
16305 error (_("%s: contains corrupt thin archive: %s\n"),
16311 /* This is a proxy for a member of a nested archive. */
16312 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16314 /* The nested archive file will have been opened and setup by
16315 get_archive_member_name. */
16316 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16318 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16323 ret
|= process_object (qualified_name
, nested_arch
.file
);
16327 archive_file_offset
= arch
.next_arhdr_offset
;
16328 arch
.next_arhdr_offset
+= archive_file_size
;
16330 ret
|= process_object (qualified_name
, file
);
16333 if (dump_sects
!= NULL
)
16337 num_dump_sects
= 0;
16340 free (qualified_name
);
16344 if (nested_arch
.file
!= NULL
)
16345 fclose (nested_arch
.file
);
16346 release_archive (&nested_arch
);
16347 release_archive (&arch
);
16353 process_file (char * file_name
)
16356 struct stat statbuf
;
16357 char armag
[SARMAG
];
16360 if (stat (file_name
, &statbuf
) < 0)
16362 if (errno
== ENOENT
)
16363 error (_("'%s': No such file\n"), file_name
);
16365 error (_("Could not locate '%s'. System error message: %s\n"),
16366 file_name
, strerror (errno
));
16370 if (! S_ISREG (statbuf
.st_mode
))
16372 error (_("'%s' is not an ordinary file\n"), file_name
);
16376 file
= fopen (file_name
, "rb");
16379 error (_("Input file '%s' is not readable.\n"), file_name
);
16383 if (fread (armag
, SARMAG
, 1, file
) != 1)
16385 error (_("%s: Failed to read file's magic number\n"), file_name
);
16390 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16392 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16393 ret
= process_archive (file_name
, file
, FALSE
);
16394 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16395 ret
= process_archive (file_name
, file
, TRUE
);
16398 if (do_archive_index
)
16399 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16403 archive_file_size
= archive_file_offset
= 0;
16404 ret
= process_object (file_name
, file
);
16409 current_file_size
= 0;
16413 #ifdef SUPPORT_DISASSEMBLY
16414 /* Needed by the i386 disassembler. For extra credit, someone could
16415 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16419 print_address (unsigned int addr
, FILE * outfile
)
16421 fprintf (outfile
,"0x%8.8x", addr
);
16424 /* Needed by the i386 disassembler. */
16426 db_task_printsym (unsigned int addr
)
16428 print_address (addr
, stderr
);
16433 main (int argc
, char ** argv
)
16437 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16438 setlocale (LC_MESSAGES
, "");
16440 #if defined (HAVE_SETLOCALE)
16441 setlocale (LC_CTYPE
, "");
16443 bindtextdomain (PACKAGE
, LOCALEDIR
);
16444 textdomain (PACKAGE
);
16446 expandargv (&argc
, &argv
);
16448 parse_args (argc
, argv
);
16450 if (num_dump_sects
> 0)
16452 /* Make a copy of the dump_sects array. */
16453 cmdline_dump_sects
= (dump_type
*)
16454 malloc (num_dump_sects
* sizeof (* dump_sects
));
16455 if (cmdline_dump_sects
== NULL
)
16456 error (_("Out of memory allocating dump request table.\n"));
16459 memcpy (cmdline_dump_sects
, dump_sects
,
16460 num_dump_sects
* sizeof (* dump_sects
));
16461 num_cmdline_dump_sects
= num_dump_sects
;
16465 if (optind
< (argc
- 1))
16467 else if (optind
>= argc
)
16469 warn (_("Nothing to do.\n"));
16474 while (optind
< argc
)
16475 err
|= process_file (argv
[optind
++]);
16477 if (dump_sects
!= NULL
)
16479 if (cmdline_dump_sects
!= NULL
)
16480 free (cmdline_dump_sects
);