1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.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
;
215 struct group_list
* next
;
216 unsigned int section_index
;
221 struct group_list
* root
;
222 unsigned int group_index
;
225 static size_t group_count
;
226 static struct group
* section_groups
;
227 static struct group
** section_headers_groups
;
230 /* Flag bits indicating particular types of dump. */
231 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
232 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
233 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
234 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
237 typedef unsigned char dump_type
;
239 /* A linked list of the section names for which dumps were requested. */
240 struct dump_list_entry
244 struct dump_list_entry
* next
;
246 static struct dump_list_entry
* dump_sects_byname
;
248 /* A dynamic array of flags indicating for which sections a dump
249 has been requested via command line switches. */
250 static dump_type
* cmdline_dump_sects
= NULL
;
251 static unsigned int num_cmdline_dump_sects
= 0;
253 /* A dynamic array of flags indicating for which sections a dump of
254 some kind has been requested. It is reset on a per-object file
255 basis and then initialised from the cmdline_dump_sects array,
256 the results of interpreting the -w switch, and the
257 dump_sects_byname list. */
258 static dump_type
* dump_sects
= NULL
;
259 static unsigned int num_dump_sects
= 0;
262 /* How to print a vma value. */
263 typedef enum print_mode
275 /* Versioned symbol info. */
276 enum versioned_symbol_info
283 static const char *get_symbol_version_string
284 (FILE *file
, int is_dynsym
, const char *strtab
,
285 unsigned long int strtab_size
, unsigned int si
,
286 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
287 unsigned short *vna_other
);
291 #define SECTION_NAME(X) \
292 ((X) == NULL ? _("<none>") \
293 : string_table == NULL ? _("<no-name>") \
294 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
295 : string_table + (X)->sh_name))
297 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
299 #define GET_ELF_SYMBOLS(file, section, sym_count) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
301 : get_64bit_elf_symbols (file, section, sym_count))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 #define REMOVE_ARCH_BITS(ADDR) \
311 if (elf_header.e_machine == EM_ARM) \
316 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
317 the offset of the current archive member, if we are examining an archive.
318 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
319 using malloc and fill that. In either case return the pointer to the start of
320 the retrieved data or NULL if something went wrong. If something does go wrong
321 and REASON is not NULL then emit an error message using REASON as part of the
325 get_data (void * var
, FILE * file
, unsigned long offset
, size_t size
, size_t nmemb
,
329 size_t amt
= size
* nmemb
;
331 if (size
== 0 || nmemb
== 0)
334 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
335 attempting to allocate memory when the read is bound to fail. */
336 if (amt
> current_file_size
337 || offset
+ archive_file_offset
+ amt
> current_file_size
)
340 error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
341 (unsigned long) amt
, reason
);
345 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
348 error (_("Unable to seek to 0x%lx for %s\n"),
349 (unsigned long) archive_file_offset
+ offset
, reason
);
356 /* Check for overflow. */
357 if (nmemb
< (~(size_t) 0 - 1) / size
)
358 /* + 1 so that we can '\0' terminate invalid string table sections. */
359 mvar
= malloc (size
* nmemb
+ 1);
364 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
365 (unsigned long)(size
* nmemb
), reason
);
369 ((char *) mvar
)[amt
] = '\0';
372 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
375 error (_("Unable to read in 0x%lx bytes of %s\n"),
376 (unsigned long) amt
, reason
);
385 /* Print a VMA value. */
388 print_vma (bfd_vma vma
, print_mode mode
)
401 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
408 return printf ("%5" BFD_VMA_FMT
"d", vma
);
416 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
419 return printf ("%" BFD_VMA_FMT
"d", vma
);
422 return printf ("%" BFD_VMA_FMT
"u", vma
);
427 /* Display a symbol on stdout. Handles the display of control characters and
428 multibye characters (assuming the host environment supports them).
430 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
432 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
433 padding as necessary.
435 Returns the number of emitted characters. */
438 print_symbol (int width
, const char *symbol
)
440 bfd_boolean extra_padding
= FALSE
;
442 #ifdef HAVE_MBSTATE_T
449 /* Keep the width positive. This also helps. */
451 extra_padding
= TRUE
;
456 /* Set the remaining width to a very large value.
457 This simplifies the code below. */
458 width_remaining
= INT_MAX
;
460 width_remaining
= width
;
462 #ifdef HAVE_MBSTATE_T
463 /* Initialise the multibyte conversion state. */
464 memset (& state
, 0, sizeof (state
));
467 while (width_remaining
)
470 const char c
= *symbol
++;
475 /* Do not print control characters directly as they can affect terminal
476 settings. Such characters usually appear in the names generated
477 by the assembler for local labels. */
480 if (width_remaining
< 2)
483 printf ("^%c", c
+ 0x40);
484 width_remaining
-= 2;
487 else if (ISPRINT (c
))
495 #ifdef HAVE_MBSTATE_T
498 /* Let printf do the hard work of displaying multibyte characters. */
499 printf ("%.1s", symbol
- 1);
503 #ifdef HAVE_MBSTATE_T
504 /* Try to find out how many bytes made up the character that was
505 just printed. Advance the symbol pointer past the bytes that
507 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
511 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
516 if (extra_padding
&& num_printed
< width
)
518 /* Fill in the remaining spaces. */
519 printf ("%-*s", width
- num_printed
, " ");
526 /* Returns a pointer to a static buffer containing a printable version of
527 the given section's name. Like print_symbol, except that it does not try
528 to print multibyte characters, it just interprets them as hex values. */
531 printable_section_name (Elf_Internal_Shdr
* sec
)
533 #define MAX_PRINT_SEC_NAME_LEN 128
534 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
535 const char * name
= SECTION_NAME (sec
);
536 char * buf
= sec_name_buf
;
538 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
540 while ((c
= * name
++) != 0)
551 else if (ISPRINT (c
))
558 static char hex
[17] = "0123456789ABCDEF";
563 * buf
++ = hex
[(c
& 0xf0) >> 4];
564 * buf
++ = hex
[c
& 0x0f];
578 printable_section_name_from_index (unsigned long ndx
)
580 if (ndx
>= elf_header
.e_shnum
)
581 return _("<corrupt>");
583 return printable_section_name (section_headers
+ ndx
);
586 /* Return a pointer to section NAME, or NULL if no such section exists. */
588 static Elf_Internal_Shdr
*
589 find_section (const char * name
)
593 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
594 if (streq (SECTION_NAME (section_headers
+ i
), name
))
595 return section_headers
+ i
;
600 /* Return a pointer to a section containing ADDR, or NULL if no such
603 static Elf_Internal_Shdr
*
604 find_section_by_address (bfd_vma addr
)
608 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
610 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
611 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
618 static Elf_Internal_Shdr
*
619 find_section_by_type (unsigned int type
)
623 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
625 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
626 if (sec
->sh_type
== type
)
633 /* Return a pointer to section NAME, or NULL if no such section exists,
634 restricted to the list of sections given in SET. */
636 static Elf_Internal_Shdr
*
637 find_section_in_set (const char * name
, unsigned int * set
)
643 while ((i
= *set
++) > 0)
644 if (streq (SECTION_NAME (section_headers
+ i
), name
))
645 return section_headers
+ i
;
648 return find_section (name
);
651 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
654 static inline unsigned long
655 read_uleb128 (unsigned char *data
,
656 unsigned int *length_return
,
657 const unsigned char * const end
)
659 return read_leb128 (data
, length_return
, FALSE
, end
);
662 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
663 This OS has so many departures from the ELF standard that we test it at
669 return elf_header
.e_machine
== EM_IA_64
670 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
673 /* Guess the relocation size commonly used by the specific machines. */
676 guess_is_rela (unsigned int e_machine
)
680 /* Targets that use REL relocations. */
695 /* Targets that use RELA relocations. */
699 case EM_ADAPTEVA_EPIPHANY
:
701 case EM_ALTERA_NIOS2
:
720 case EM_LATTICEMICO32
:
729 case EM_CYGNUS_MN10200
:
731 case EM_CYGNUS_MN10300
:
764 case EM_MICROBLAZE_OLD
:
785 warn (_("Don't know about relocations on this machine architecture\n"));
791 slurp_rela_relocs (FILE * file
,
792 unsigned long rel_offset
,
793 unsigned long rel_size
,
794 Elf_Internal_Rela
** relasp
,
795 unsigned long * nrelasp
)
797 Elf_Internal_Rela
* relas
;
803 Elf32_External_Rela
* erelas
;
805 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
806 rel_size
, _("32-bit relocation data"));
810 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
812 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
813 sizeof (Elf_Internal_Rela
));
818 error (_("out of memory parsing relocs\n"));
822 for (i
= 0; i
< nrelas
; i
++)
824 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
825 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
826 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
833 Elf64_External_Rela
* erelas
;
835 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
836 rel_size
, _("64-bit relocation data"));
840 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
842 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
843 sizeof (Elf_Internal_Rela
));
848 error (_("out of memory parsing relocs\n"));
852 for (i
= 0; i
< nrelas
; i
++)
854 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
855 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
856 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
858 /* The #ifdef BFD64 below is to prevent a compile time
859 warning. We know that if we do not have a 64 bit data
860 type that we will never execute this code anyway. */
862 if (elf_header
.e_machine
== EM_MIPS
863 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
865 /* In little-endian objects, r_info isn't really a
866 64-bit little-endian value: it has a 32-bit
867 little-endian symbol index followed by four
868 individual byte fields. Reorder INFO
870 bfd_vma inf
= relas
[i
].r_info
;
871 inf
= (((inf
& 0xffffffff) << 32)
872 | ((inf
>> 56) & 0xff)
873 | ((inf
>> 40) & 0xff00)
874 | ((inf
>> 24) & 0xff0000)
875 | ((inf
>> 8) & 0xff000000));
876 relas
[i
].r_info
= inf
;
889 slurp_rel_relocs (FILE * file
,
890 unsigned long rel_offset
,
891 unsigned long rel_size
,
892 Elf_Internal_Rela
** relsp
,
893 unsigned long * nrelsp
)
895 Elf_Internal_Rela
* rels
;
901 Elf32_External_Rel
* erels
;
903 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
904 rel_size
, _("32-bit relocation data"));
908 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
910 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
915 error (_("out of memory parsing relocs\n"));
919 for (i
= 0; i
< nrels
; i
++)
921 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
922 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
923 rels
[i
].r_addend
= 0;
930 Elf64_External_Rel
* erels
;
932 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
933 rel_size
, _("64-bit relocation data"));
937 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
939 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
944 error (_("out of memory parsing relocs\n"));
948 for (i
= 0; i
< nrels
; i
++)
950 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
951 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
952 rels
[i
].r_addend
= 0;
954 /* The #ifdef BFD64 below is to prevent a compile time
955 warning. We know that if we do not have a 64 bit data
956 type that we will never execute this code anyway. */
958 if (elf_header
.e_machine
== EM_MIPS
959 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
961 /* In little-endian objects, r_info isn't really a
962 64-bit little-endian value: it has a 32-bit
963 little-endian symbol index followed by four
964 individual byte fields. Reorder INFO
966 bfd_vma inf
= rels
[i
].r_info
;
967 inf
= (((inf
& 0xffffffff) << 32)
968 | ((inf
>> 56) & 0xff)
969 | ((inf
>> 40) & 0xff00)
970 | ((inf
>> 24) & 0xff0000)
971 | ((inf
>> 8) & 0xff000000));
972 rels
[i
].r_info
= inf
;
984 /* Returns the reloc type extracted from the reloc info field. */
987 get_reloc_type (bfd_vma reloc_info
)
990 return ELF32_R_TYPE (reloc_info
);
992 switch (elf_header
.e_machine
)
995 /* Note: We assume that reloc_info has already been adjusted for us. */
996 return ELF64_MIPS_R_TYPE (reloc_info
);
999 return ELF64_R_TYPE_ID (reloc_info
);
1002 return ELF64_R_TYPE (reloc_info
);
1006 /* Return the symbol index extracted from the reloc info field. */
1009 get_reloc_symindex (bfd_vma reloc_info
)
1011 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1014 static inline bfd_boolean
1015 uses_msp430x_relocs (void)
1018 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1019 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1020 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1021 /* TI compiler uses ELFOSABI_NONE. */
1022 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1025 /* Display the contents of the relocation data found at the specified
1029 dump_relocations (FILE * file
,
1030 unsigned long rel_offset
,
1031 unsigned long rel_size
,
1032 Elf_Internal_Sym
* symtab
,
1033 unsigned long nsyms
,
1035 unsigned long strtablen
,
1040 Elf_Internal_Rela
* rels
;
1042 if (is_rela
== UNKNOWN
)
1043 is_rela
= guess_is_rela (elf_header
.e_machine
);
1047 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1052 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1061 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1063 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1068 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1070 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1078 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1080 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1085 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1087 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1091 for (i
= 0; i
< rel_size
; i
++)
1096 bfd_vma symtab_index
;
1099 offset
= rels
[i
].r_offset
;
1100 inf
= rels
[i
].r_info
;
1102 type
= get_reloc_type (inf
);
1103 symtab_index
= get_reloc_symindex (inf
);
1107 printf ("%8.8lx %8.8lx ",
1108 (unsigned long) offset
& 0xffffffff,
1109 (unsigned long) inf
& 0xffffffff);
1113 #if BFD_HOST_64BIT_LONG
1115 ? "%16.16lx %16.16lx "
1116 : "%12.12lx %12.12lx ",
1118 #elif BFD_HOST_64BIT_LONG_LONG
1121 ? "%16.16llx %16.16llx "
1122 : "%12.12llx %12.12llx ",
1126 ? "%16.16I64x %16.16I64x "
1127 : "%12.12I64x %12.12I64x ",
1132 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1133 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1134 _bfd_int64_high (offset
),
1135 _bfd_int64_low (offset
),
1136 _bfd_int64_high (inf
),
1137 _bfd_int64_low (inf
));
1141 switch (elf_header
.e_machine
)
1148 rtype
= elf_aarch64_reloc_type (type
);
1152 case EM_CYGNUS_M32R
:
1153 rtype
= elf_m32r_reloc_type (type
);
1158 rtype
= elf_i386_reloc_type (type
);
1163 rtype
= elf_m68hc11_reloc_type (type
);
1167 rtype
= elf_m68k_reloc_type (type
);
1171 rtype
= elf_i960_reloc_type (type
);
1176 rtype
= elf_avr_reloc_type (type
);
1179 case EM_OLD_SPARCV9
:
1180 case EM_SPARC32PLUS
:
1183 rtype
= elf_sparc_reloc_type (type
);
1187 rtype
= elf_spu_reloc_type (type
);
1191 rtype
= v800_reloc_type (type
);
1194 case EM_CYGNUS_V850
:
1195 rtype
= v850_reloc_type (type
);
1199 case EM_CYGNUS_D10V
:
1200 rtype
= elf_d10v_reloc_type (type
);
1204 case EM_CYGNUS_D30V
:
1205 rtype
= elf_d30v_reloc_type (type
);
1209 rtype
= elf_dlx_reloc_type (type
);
1213 rtype
= elf_sh_reloc_type (type
);
1217 case EM_CYGNUS_MN10300
:
1218 rtype
= elf_mn10300_reloc_type (type
);
1222 case EM_CYGNUS_MN10200
:
1223 rtype
= elf_mn10200_reloc_type (type
);
1227 case EM_CYGNUS_FR30
:
1228 rtype
= elf_fr30_reloc_type (type
);
1232 rtype
= elf_frv_reloc_type (type
);
1236 rtype
= elf_mcore_reloc_type (type
);
1240 rtype
= elf_mmix_reloc_type (type
);
1244 rtype
= elf_moxie_reloc_type (type
);
1248 if (uses_msp430x_relocs ())
1250 rtype
= elf_msp430x_reloc_type (type
);
1254 rtype
= elf_msp430_reloc_type (type
);
1258 rtype
= elf_nds32_reloc_type (type
);
1262 rtype
= elf_ppc_reloc_type (type
);
1266 rtype
= elf_ppc64_reloc_type (type
);
1270 case EM_MIPS_RS3_LE
:
1271 rtype
= elf_mips_reloc_type (type
);
1275 rtype
= elf_alpha_reloc_type (type
);
1279 rtype
= elf_arm_reloc_type (type
);
1283 rtype
= elf_arc_reloc_type (type
);
1287 rtype
= elf_hppa_reloc_type (type
);
1293 rtype
= elf_h8_reloc_type (type
);
1297 rtype
= elf_or1k_reloc_type (type
);
1302 rtype
= elf_pj_reloc_type (type
);
1305 rtype
= elf_ia64_reloc_type (type
);
1309 rtype
= elf_cris_reloc_type (type
);
1313 rtype
= elf_i860_reloc_type (type
);
1319 rtype
= elf_x86_64_reloc_type (type
);
1323 rtype
= i370_reloc_type (type
);
1328 rtype
= elf_s390_reloc_type (type
);
1332 rtype
= elf_score_reloc_type (type
);
1336 rtype
= elf_xstormy16_reloc_type (type
);
1340 rtype
= elf_crx_reloc_type (type
);
1344 rtype
= elf_vax_reloc_type (type
);
1347 case EM_ADAPTEVA_EPIPHANY
:
1348 rtype
= elf_epiphany_reloc_type (type
);
1353 rtype
= elf_ip2k_reloc_type (type
);
1357 rtype
= elf_iq2000_reloc_type (type
);
1362 rtype
= elf_xtensa_reloc_type (type
);
1365 case EM_LATTICEMICO32
:
1366 rtype
= elf_lm32_reloc_type (type
);
1371 rtype
= elf_m32c_reloc_type (type
);
1375 rtype
= elf_mt_reloc_type (type
);
1379 rtype
= elf_bfin_reloc_type (type
);
1383 rtype
= elf_mep_reloc_type (type
);
1387 rtype
= elf_cr16_reloc_type (type
);
1391 case EM_MICROBLAZE_OLD
:
1392 rtype
= elf_microblaze_reloc_type (type
);
1396 rtype
= elf_rl78_reloc_type (type
);
1400 rtype
= elf_rx_reloc_type (type
);
1404 rtype
= elf_metag_reloc_type (type
);
1409 rtype
= elf_xc16x_reloc_type (type
);
1413 rtype
= elf_tic6x_reloc_type (type
);
1417 rtype
= elf_tilegx_reloc_type (type
);
1421 rtype
= elf_tilepro_reloc_type (type
);
1425 rtype
= elf_xgate_reloc_type (type
);
1428 case EM_ALTERA_NIOS2
:
1429 rtype
= elf_nios2_reloc_type (type
);
1434 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1436 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1438 if (elf_header
.e_machine
== EM_ALPHA
1440 && streq (rtype
, "R_ALPHA_LITUSE")
1443 switch (rels
[i
].r_addend
)
1445 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1446 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1447 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1448 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1449 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1450 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1451 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1452 default: rtype
= NULL
;
1455 printf (" (%s)", rtype
);
1459 printf (_("<unknown addend: %lx>"),
1460 (unsigned long) rels
[i
].r_addend
);
1463 else if (symtab_index
)
1465 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1466 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1469 Elf_Internal_Sym
* psym
;
1470 const char * version_string
;
1471 enum versioned_symbol_info sym_info
;
1472 unsigned short vna_other
;
1474 psym
= symtab
+ symtab_index
;
1477 = get_symbol_version_string (file
, is_dynsym
,
1486 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1490 unsigned int width
= is_32bit_elf
? 8 : 14;
1492 /* Relocations against GNU_IFUNC symbols do not use the value
1493 of the symbol as the address to relocate against. Instead
1494 they invoke the function named by the symbol and use its
1495 result as the address for relocation.
1497 To indicate this to the user, do not display the value of
1498 the symbol in the "Symbols's Value" field. Instead show
1499 its name followed by () as a hint that the symbol is
1503 || psym
->st_name
== 0
1504 || psym
->st_name
>= strtablen
)
1507 name
= strtab
+ psym
->st_name
;
1509 len
= print_symbol (width
, name
);
1511 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1513 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1517 print_vma (psym
->st_value
, LONG_HEX
);
1519 printf (is_32bit_elf
? " " : " ");
1522 if (psym
->st_name
== 0)
1524 const char * sec_name
= "<null>";
1527 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1529 if (psym
->st_shndx
< elf_header
.e_shnum
)
1530 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1531 else if (psym
->st_shndx
== SHN_ABS
)
1533 else if (psym
->st_shndx
== SHN_COMMON
)
1534 sec_name
= "COMMON";
1535 else if ((elf_header
.e_machine
== EM_MIPS
1536 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1537 || (elf_header
.e_machine
== EM_TI_C6000
1538 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1539 sec_name
= "SCOMMON";
1540 else if (elf_header
.e_machine
== EM_MIPS
1541 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1542 sec_name
= "SUNDEF";
1543 else if ((elf_header
.e_machine
== EM_X86_64
1544 || elf_header
.e_machine
== EM_L1OM
1545 || elf_header
.e_machine
== EM_K1OM
)
1546 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1547 sec_name
= "LARGE_COMMON";
1548 else if (elf_header
.e_machine
== EM_IA_64
1549 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1550 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1551 sec_name
= "ANSI_COM";
1552 else if (is_ia64_vms ()
1553 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1554 sec_name
= "VMS_SYMVEC";
1557 sprintf (name_buf
, "<section 0x%x>",
1558 (unsigned int) psym
->st_shndx
);
1559 sec_name
= name_buf
;
1562 print_symbol (22, sec_name
);
1564 else if (strtab
== NULL
)
1565 printf (_("<string table index: %3ld>"), psym
->st_name
);
1566 else if (psym
->st_name
>= strtablen
)
1567 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1570 print_symbol (22, strtab
+ psym
->st_name
);
1572 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1578 bfd_signed_vma off
= rels
[i
].r_addend
;
1581 printf (" - %" BFD_VMA_FMT
"x", - off
);
1583 printf (" + %" BFD_VMA_FMT
"x", off
);
1589 bfd_signed_vma off
= rels
[i
].r_addend
;
1591 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1593 printf ("-%" BFD_VMA_FMT
"x", - off
);
1595 printf ("%" BFD_VMA_FMT
"x", off
);
1598 if (elf_header
.e_machine
== EM_SPARCV9
1600 && streq (rtype
, "R_SPARC_OLO10"))
1601 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1606 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1608 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1609 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1610 const char * rtype2
= elf_mips_reloc_type (type2
);
1611 const char * rtype3
= elf_mips_reloc_type (type3
);
1613 printf (" Type2: ");
1616 printf (_("unrecognized: %-7lx"),
1617 (unsigned long) type2
& 0xffffffff);
1619 printf ("%-17.17s", rtype2
);
1621 printf ("\n Type3: ");
1624 printf (_("unrecognized: %-7lx"),
1625 (unsigned long) type3
& 0xffffffff);
1627 printf ("%-17.17s", rtype3
);
1638 get_mips_dynamic_type (unsigned long type
)
1642 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1643 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1644 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1645 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1646 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1647 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1648 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1649 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1650 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1651 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1652 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1653 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1654 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1655 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1656 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1657 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1658 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1659 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1660 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1661 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1662 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1663 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1664 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1665 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1666 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1667 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1668 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1669 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1670 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1671 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1672 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1673 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1674 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1675 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1676 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1677 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1678 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1679 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1680 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1681 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1682 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1683 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1684 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1685 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1686 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1693 get_sparc64_dynamic_type (unsigned long type
)
1697 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1704 get_ppc_dynamic_type (unsigned long type
)
1708 case DT_PPC_GOT
: return "PPC_GOT";
1709 case DT_PPC_OPT
: return "PPC_OPT";
1716 get_ppc64_dynamic_type (unsigned long type
)
1720 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1721 case DT_PPC64_OPD
: return "PPC64_OPD";
1722 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1723 case DT_PPC64_OPT
: return "PPC64_OPT";
1730 get_parisc_dynamic_type (unsigned long type
)
1734 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1735 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1736 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1737 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1738 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1739 case DT_HP_PREINIT
: return "HP_PREINIT";
1740 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1741 case DT_HP_NEEDED
: return "HP_NEEDED";
1742 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1743 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1744 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1745 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1746 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1747 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1748 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1749 case DT_HP_FILTERED
: return "HP_FILTERED";
1750 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1751 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1752 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1753 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1754 case DT_PLT
: return "PLT";
1755 case DT_PLT_SIZE
: return "PLT_SIZE";
1756 case DT_DLT
: return "DLT";
1757 case DT_DLT_SIZE
: return "DLT_SIZE";
1764 get_ia64_dynamic_type (unsigned long type
)
1768 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1769 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1770 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1771 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1772 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1773 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1774 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1775 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1776 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1777 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1778 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1779 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1780 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1781 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1782 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1783 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1784 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1785 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1786 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1787 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1788 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1789 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1790 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1791 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1792 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1793 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1794 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1795 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1796 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1797 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1798 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1805 get_alpha_dynamic_type (unsigned long type
)
1809 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1816 get_score_dynamic_type (unsigned long type
)
1820 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1821 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1822 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1823 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1824 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1825 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1832 get_tic6x_dynamic_type (unsigned long type
)
1836 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1837 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1838 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1839 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1840 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1841 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1848 get_nios2_dynamic_type (unsigned long type
)
1852 case DT_NIOS2_GP
: return "NIOS2_GP";
1859 get_dynamic_type (unsigned long type
)
1861 static char buff
[64];
1865 case DT_NULL
: return "NULL";
1866 case DT_NEEDED
: return "NEEDED";
1867 case DT_PLTRELSZ
: return "PLTRELSZ";
1868 case DT_PLTGOT
: return "PLTGOT";
1869 case DT_HASH
: return "HASH";
1870 case DT_STRTAB
: return "STRTAB";
1871 case DT_SYMTAB
: return "SYMTAB";
1872 case DT_RELA
: return "RELA";
1873 case DT_RELASZ
: return "RELASZ";
1874 case DT_RELAENT
: return "RELAENT";
1875 case DT_STRSZ
: return "STRSZ";
1876 case DT_SYMENT
: return "SYMENT";
1877 case DT_INIT
: return "INIT";
1878 case DT_FINI
: return "FINI";
1879 case DT_SONAME
: return "SONAME";
1880 case DT_RPATH
: return "RPATH";
1881 case DT_SYMBOLIC
: return "SYMBOLIC";
1882 case DT_REL
: return "REL";
1883 case DT_RELSZ
: return "RELSZ";
1884 case DT_RELENT
: return "RELENT";
1885 case DT_PLTREL
: return "PLTREL";
1886 case DT_DEBUG
: return "DEBUG";
1887 case DT_TEXTREL
: return "TEXTREL";
1888 case DT_JMPREL
: return "JMPREL";
1889 case DT_BIND_NOW
: return "BIND_NOW";
1890 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1891 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1892 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1893 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1894 case DT_RUNPATH
: return "RUNPATH";
1895 case DT_FLAGS
: return "FLAGS";
1897 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1898 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1900 case DT_CHECKSUM
: return "CHECKSUM";
1901 case DT_PLTPADSZ
: return "PLTPADSZ";
1902 case DT_MOVEENT
: return "MOVEENT";
1903 case DT_MOVESZ
: return "MOVESZ";
1904 case DT_FEATURE
: return "FEATURE";
1905 case DT_POSFLAG_1
: return "POSFLAG_1";
1906 case DT_SYMINSZ
: return "SYMINSZ";
1907 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1909 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1910 case DT_CONFIG
: return "CONFIG";
1911 case DT_DEPAUDIT
: return "DEPAUDIT";
1912 case DT_AUDIT
: return "AUDIT";
1913 case DT_PLTPAD
: return "PLTPAD";
1914 case DT_MOVETAB
: return "MOVETAB";
1915 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1917 case DT_VERSYM
: return "VERSYM";
1919 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1920 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1921 case DT_RELACOUNT
: return "RELACOUNT";
1922 case DT_RELCOUNT
: return "RELCOUNT";
1923 case DT_FLAGS_1
: return "FLAGS_1";
1924 case DT_VERDEF
: return "VERDEF";
1925 case DT_VERDEFNUM
: return "VERDEFNUM";
1926 case DT_VERNEED
: return "VERNEED";
1927 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1929 case DT_AUXILIARY
: return "AUXILIARY";
1930 case DT_USED
: return "USED";
1931 case DT_FILTER
: return "FILTER";
1933 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1934 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1935 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1936 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1937 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1938 case DT_GNU_HASH
: return "GNU_HASH";
1941 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1943 const char * result
;
1945 switch (elf_header
.e_machine
)
1948 case EM_MIPS_RS3_LE
:
1949 result
= get_mips_dynamic_type (type
);
1952 result
= get_sparc64_dynamic_type (type
);
1955 result
= get_ppc_dynamic_type (type
);
1958 result
= get_ppc64_dynamic_type (type
);
1961 result
= get_ia64_dynamic_type (type
);
1964 result
= get_alpha_dynamic_type (type
);
1967 result
= get_score_dynamic_type (type
);
1970 result
= get_tic6x_dynamic_type (type
);
1972 case EM_ALTERA_NIOS2
:
1973 result
= get_nios2_dynamic_type (type
);
1983 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1985 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1986 || (elf_header
.e_machine
== EM_PARISC
1987 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1989 const char * result
;
1991 switch (elf_header
.e_machine
)
1994 result
= get_parisc_dynamic_type (type
);
1997 result
= get_ia64_dynamic_type (type
);
2007 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2011 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2018 get_file_type (unsigned e_type
)
2020 static char buff
[32];
2024 case ET_NONE
: return _("NONE (None)");
2025 case ET_REL
: return _("REL (Relocatable file)");
2026 case ET_EXEC
: return _("EXEC (Executable file)");
2027 case ET_DYN
: return _("DYN (Shared object file)");
2028 case ET_CORE
: return _("CORE (Core file)");
2031 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2032 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2033 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2034 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2036 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2042 get_machine_name (unsigned e_machine
)
2044 static char buff
[64]; /* XXX */
2048 case EM_NONE
: return _("None");
2049 case EM_AARCH64
: return "AArch64";
2050 case EM_M32
: return "WE32100";
2051 case EM_SPARC
: return "Sparc";
2052 case EM_SPU
: return "SPU";
2053 case EM_386
: return "Intel 80386";
2054 case EM_68K
: return "MC68000";
2055 case EM_88K
: return "MC88000";
2056 case EM_486
: return "Intel 80486";
2057 case EM_860
: return "Intel 80860";
2058 case EM_MIPS
: return "MIPS R3000";
2059 case EM_S370
: return "IBM System/370";
2060 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2061 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2062 case EM_PARISC
: return "HPPA";
2063 case EM_PPC_OLD
: return "Power PC (old)";
2064 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2065 case EM_960
: return "Intel 90860";
2066 case EM_PPC
: return "PowerPC";
2067 case EM_PPC64
: return "PowerPC64";
2068 case EM_FR20
: return "Fujitsu FR20";
2069 case EM_RH32
: return "TRW RH32";
2070 case EM_MCORE
: return "MCORE";
2071 case EM_ARM
: return "ARM";
2072 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2073 case EM_SH
: return "Renesas / SuperH SH";
2074 case EM_SPARCV9
: return "Sparc v9";
2075 case EM_TRICORE
: return "Siemens Tricore";
2076 case EM_ARC
: return "ARC";
2077 case EM_H8_300
: return "Renesas H8/300";
2078 case EM_H8_300H
: return "Renesas H8/300H";
2079 case EM_H8S
: return "Renesas H8S";
2080 case EM_H8_500
: return "Renesas H8/500";
2081 case EM_IA_64
: return "Intel IA-64";
2082 case EM_MIPS_X
: return "Stanford MIPS-X";
2083 case EM_COLDFIRE
: return "Motorola Coldfire";
2084 case EM_ALPHA
: return "Alpha";
2085 case EM_CYGNUS_D10V
:
2086 case EM_D10V
: return "d10v";
2087 case EM_CYGNUS_D30V
:
2088 case EM_D30V
: return "d30v";
2089 case EM_CYGNUS_M32R
:
2090 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2091 case EM_CYGNUS_V850
:
2092 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2093 case EM_V850
: return "Renesas V850";
2094 case EM_CYGNUS_MN10300
:
2095 case EM_MN10300
: return "mn10300";
2096 case EM_CYGNUS_MN10200
:
2097 case EM_MN10200
: return "mn10200";
2098 case EM_MOXIE
: return "Moxie";
2099 case EM_CYGNUS_FR30
:
2100 case EM_FR30
: return "Fujitsu FR30";
2101 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2103 case EM_PJ
: return "picoJava";
2104 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2105 case EM_PCP
: return "Siemens PCP";
2106 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2107 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2108 case EM_STARCORE
: return "Motorola Star*Core processor";
2109 case EM_ME16
: return "Toyota ME16 processor";
2110 case EM_ST100
: return "STMicroelectronics ST100 processor";
2111 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2112 case EM_PDSP
: return "Sony DSP processor";
2113 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2114 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2115 case EM_FX66
: return "Siemens FX66 microcontroller";
2116 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2117 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2118 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2119 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2120 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2121 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2122 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2123 case EM_SVX
: return "Silicon Graphics SVx";
2124 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2125 case EM_VAX
: return "Digital VAX";
2127 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2128 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2129 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2130 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2131 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2132 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2133 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2134 case EM_PRISM
: return "Vitesse Prism";
2135 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2136 case EM_L1OM
: return "Intel L1OM";
2137 case EM_K1OM
: return "Intel K1OM";
2139 case EM_S390
: return "IBM S/390";
2140 case EM_SCORE
: return "SUNPLUS S+Core";
2141 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2142 case EM_OR1K
: return "OpenRISC 1000";
2143 case EM_ARC_A5
: return "ARC International ARCompact processor";
2144 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2145 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2146 case EM_DLX
: return "OpenDLX";
2148 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2149 case EM_IQ2000
: return "Vitesse IQ2000";
2151 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2152 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2153 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2154 case EM_NS32K
: return "National Semiconductor 32000 series";
2155 case EM_TPC
: return "Tenor Network TPC processor";
2156 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2157 case EM_MAX
: return "MAX Processor";
2158 case EM_CR
: return "National Semiconductor CompactRISC";
2159 case EM_F2MC16
: return "Fujitsu F2MC16";
2160 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2161 case EM_LATTICEMICO32
: return "Lattice Mico32";
2163 case EM_M32C
: return "Renesas M32c";
2164 case EM_MT
: return "Morpho Techologies MT processor";
2165 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2166 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2167 case EM_SEP
: return "Sharp embedded microprocessor";
2168 case EM_ARCA
: return "Arca RISC microprocessor";
2169 case EM_UNICORE
: return "Unicore";
2170 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2171 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2172 case EM_NIOS32
: return "Altera Nios";
2173 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2175 case EM_XC16X
: return "Infineon Technologies xc16x";
2176 case EM_M16C
: return "Renesas M16C series microprocessors";
2177 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2178 case EM_CE
: return "Freescale Communication Engine RISC core";
2179 case EM_TSK3000
: return "Altium TSK3000 core";
2180 case EM_RS08
: return "Freescale RS08 embedded processor";
2181 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2182 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2183 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2184 case EM_SE_C17
: return "Seiko Epson C17 family";
2185 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2186 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2187 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2188 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2189 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2190 case EM_R32C
: return "Renesas R32C series microprocessors";
2191 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2192 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2193 case EM_8051
: return "Intel 8051 and variants";
2194 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2195 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2196 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2197 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2198 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2199 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2200 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2201 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2204 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2205 case EM_RL78
: return "Renesas RL78";
2206 case EM_RX
: return "Renesas RX";
2207 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2208 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2209 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2210 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2211 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2212 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2213 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2214 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2215 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2216 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2217 case EM_CUDA
: return "NVIDIA CUDA architecture";
2218 case EM_XGATE
: return "Motorola XGATE embedded processor";
2220 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2226 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2231 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2232 e_flags
&= ~ EF_ARM_EABIMASK
;
2234 /* Handle "generic" ARM flags. */
2235 if (e_flags
& EF_ARM_RELEXEC
)
2237 strcat (buf
, ", relocatable executable");
2238 e_flags
&= ~ EF_ARM_RELEXEC
;
2241 if (e_flags
& EF_ARM_HASENTRY
)
2243 strcat (buf
, ", has entry point");
2244 e_flags
&= ~ EF_ARM_HASENTRY
;
2247 /* Now handle EABI specific flags. */
2251 strcat (buf
, ", <unrecognized EABI>");
2256 case EF_ARM_EABI_VER1
:
2257 strcat (buf
, ", Version1 EABI");
2262 /* Process flags one bit at a time. */
2263 flag
= e_flags
& - e_flags
;
2268 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2269 strcat (buf
, ", sorted symbol tables");
2279 case EF_ARM_EABI_VER2
:
2280 strcat (buf
, ", Version2 EABI");
2285 /* Process flags one bit at a time. */
2286 flag
= e_flags
& - e_flags
;
2291 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2292 strcat (buf
, ", sorted symbol tables");
2295 case EF_ARM_DYNSYMSUSESEGIDX
:
2296 strcat (buf
, ", dynamic symbols use segment index");
2299 case EF_ARM_MAPSYMSFIRST
:
2300 strcat (buf
, ", mapping symbols precede others");
2310 case EF_ARM_EABI_VER3
:
2311 strcat (buf
, ", Version3 EABI");
2314 case EF_ARM_EABI_VER4
:
2315 strcat (buf
, ", Version4 EABI");
2320 /* Process flags one bit at a time. */
2321 flag
= e_flags
& - e_flags
;
2327 strcat (buf
, ", BE8");
2331 strcat (buf
, ", LE8");
2342 case EF_ARM_EABI_VER5
:
2343 strcat (buf
, ", Version5 EABI");
2348 /* Process flags one bit at a time. */
2349 flag
= e_flags
& - e_flags
;
2355 strcat (buf
, ", BE8");
2359 strcat (buf
, ", LE8");
2362 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2363 strcat (buf
, ", soft-float ABI");
2366 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2367 strcat (buf
, ", hard-float ABI");
2377 case EF_ARM_EABI_UNKNOWN
:
2378 strcat (buf
, ", GNU EABI");
2383 /* Process flags one bit at a time. */
2384 flag
= e_flags
& - e_flags
;
2389 case EF_ARM_INTERWORK
:
2390 strcat (buf
, ", interworking enabled");
2393 case EF_ARM_APCS_26
:
2394 strcat (buf
, ", uses APCS/26");
2397 case EF_ARM_APCS_FLOAT
:
2398 strcat (buf
, ", uses APCS/float");
2402 strcat (buf
, ", position independent");
2406 strcat (buf
, ", 8 bit structure alignment");
2409 case EF_ARM_NEW_ABI
:
2410 strcat (buf
, ", uses new ABI");
2413 case EF_ARM_OLD_ABI
:
2414 strcat (buf
, ", uses old ABI");
2417 case EF_ARM_SOFT_FLOAT
:
2418 strcat (buf
, ", software FP");
2421 case EF_ARM_VFP_FLOAT
:
2422 strcat (buf
, ", VFP");
2425 case EF_ARM_MAVERICK_FLOAT
:
2426 strcat (buf
, ", Maverick FP");
2437 strcat (buf
,_(", <unknown>"));
2441 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2443 --size
; /* Leave space for null terminator. */
2445 switch (e_flags
& EF_AVR_MACH
)
2447 case E_AVR_MACH_AVR1
:
2448 strncat (buf
, ", avr:1", size
);
2450 case E_AVR_MACH_AVR2
:
2451 strncat (buf
, ", avr:2", size
);
2453 case E_AVR_MACH_AVR25
:
2454 strncat (buf
, ", avr:25", size
);
2456 case E_AVR_MACH_AVR3
:
2457 strncat (buf
, ", avr:3", size
);
2459 case E_AVR_MACH_AVR31
:
2460 strncat (buf
, ", avr:31", size
);
2462 case E_AVR_MACH_AVR35
:
2463 strncat (buf
, ", avr:35", size
);
2465 case E_AVR_MACH_AVR4
:
2466 strncat (buf
, ", avr:4", size
);
2468 case E_AVR_MACH_AVR5
:
2469 strncat (buf
, ", avr:5", size
);
2471 case E_AVR_MACH_AVR51
:
2472 strncat (buf
, ", avr:51", size
);
2474 case E_AVR_MACH_AVR6
:
2475 strncat (buf
, ", avr:6", size
);
2477 case E_AVR_MACH_AVRTINY
:
2478 strncat (buf
, ", avr:100", size
);
2480 case E_AVR_MACH_XMEGA1
:
2481 strncat (buf
, ", avr:101", size
);
2483 case E_AVR_MACH_XMEGA2
:
2484 strncat (buf
, ", avr:102", size
);
2486 case E_AVR_MACH_XMEGA3
:
2487 strncat (buf
, ", avr:103", size
);
2489 case E_AVR_MACH_XMEGA4
:
2490 strncat (buf
, ", avr:104", size
);
2492 case E_AVR_MACH_XMEGA5
:
2493 strncat (buf
, ", avr:105", size
);
2495 case E_AVR_MACH_XMEGA6
:
2496 strncat (buf
, ", avr:106", size
);
2498 case E_AVR_MACH_XMEGA7
:
2499 strncat (buf
, ", avr:107", size
);
2502 strncat (buf
, ", avr:<unknown>", size
);
2506 size
-= strlen (buf
);
2507 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2508 strncat (buf
, ", link-relax", size
);
2512 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2521 static const char *ABI_STRINGS
[] =
2523 "ABI v0", /* use r5 as return register; only used in N1213HC */
2524 "ABI v1", /* use r0 as return register */
2525 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2526 "ABI v2fp", /* for FPU */
2530 static const char *VER_STRINGS
[] =
2532 "Andes ELF V1.3 or older",
2536 static const char *ARCH_STRINGS
[] =
2545 abi
= EF_NDS_ABI
& e_flags
;
2546 arch
= EF_NDS_ARCH
& e_flags
;
2547 config
= EF_NDS_INST
& e_flags
;
2548 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2550 memset (buf
, 0, size
);
2557 case E_NDS_ABI_V2FP
:
2558 case E_NDS_ABI_AABI
:
2559 case E_NDS_ABI_V2FP_PLUS
:
2560 /* In case there are holes in the array. */
2561 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2565 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2571 case E_NDS32_ELF_VER_1_2
:
2572 case E_NDS32_ELF_VER_1_3
:
2573 case E_NDS32_ELF_VER_1_4
:
2574 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2578 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2582 if (E_NDS_ABI_V0
== abi
)
2584 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2585 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2586 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2587 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2593 case E_NDS_ARCH_STAR_V1_0
:
2594 case E_NDS_ARCH_STAR_V2_0
:
2595 case E_NDS_ARCH_STAR_V3_0
:
2596 case E_NDS_ARCH_STAR_V3_M
:
2597 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2601 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2602 /* ARCH version determines how the e_flags are interpreted.
2603 If it is unknown, we cannot proceed. */
2607 /* Newer ABI; Now handle architecture specific flags. */
2608 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2610 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2611 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2613 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2614 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2616 if (config
& E_NDS32_HAS_DIV_INST
)
2617 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2619 if (config
& E_NDS32_HAS_16BIT_INST
)
2620 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2624 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2626 if (version
<= E_NDS32_ELF_VER_1_3
)
2627 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2629 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2632 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2633 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2635 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2636 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2638 if (config
& E_NDS32_HAS_16BIT_INST
)
2640 if (version
<= E_NDS32_ELF_VER_1_3
)
2641 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2643 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2647 if (config
& E_NDS32_HAS_EXT_INST
)
2648 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2650 if (config
& E_NDS32_HAS_EXT2_INST
)
2651 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2653 if (config
& E_NDS32_HAS_FPU_INST
)
2656 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2659 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2662 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2665 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2668 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2673 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2675 case E_NDS32_FPU_REG_8SP_4DP
:
2676 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2678 case E_NDS32_FPU_REG_16SP_8DP
:
2679 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2681 case E_NDS32_FPU_REG_32SP_16DP
:
2682 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2684 case E_NDS32_FPU_REG_32SP_32DP
:
2685 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2690 if (config
& E_NDS32_HAS_AUDIO_INST
)
2691 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2693 if (config
& E_NDS32_HAS_STRING_INST
)
2694 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2696 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2697 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2699 if (config
& E_NDS32_HAS_VIDEO_INST
)
2701 if (version
<= E_NDS32_ELF_VER_1_3
)
2702 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2704 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2707 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2708 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2710 if (config
& E_NDS32_HAS_L2C_INST
)
2711 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2715 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2717 static char buf
[1024];
2729 decode_ARM_machine_flags (e_flags
, buf
);
2733 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2737 if (e_flags
& EF_BFIN_PIC
)
2738 strcat (buf
, ", PIC");
2740 if (e_flags
& EF_BFIN_FDPIC
)
2741 strcat (buf
, ", FDPIC");
2743 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2744 strcat (buf
, ", code in L1");
2746 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2747 strcat (buf
, ", data in L1");
2752 switch (e_flags
& EF_FRV_CPU_MASK
)
2754 case EF_FRV_CPU_GENERIC
:
2758 strcat (buf
, ", fr???");
2761 case EF_FRV_CPU_FR300
:
2762 strcat (buf
, ", fr300");
2765 case EF_FRV_CPU_FR400
:
2766 strcat (buf
, ", fr400");
2768 case EF_FRV_CPU_FR405
:
2769 strcat (buf
, ", fr405");
2772 case EF_FRV_CPU_FR450
:
2773 strcat (buf
, ", fr450");
2776 case EF_FRV_CPU_FR500
:
2777 strcat (buf
, ", fr500");
2779 case EF_FRV_CPU_FR550
:
2780 strcat (buf
, ", fr550");
2783 case EF_FRV_CPU_SIMPLE
:
2784 strcat (buf
, ", simple");
2786 case EF_FRV_CPU_TOMCAT
:
2787 strcat (buf
, ", tomcat");
2793 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2794 strcat (buf
, ", m68000");
2795 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2796 strcat (buf
, ", cpu32");
2797 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2798 strcat (buf
, ", fido_a");
2801 char const * isa
= _("unknown");
2802 char const * mac
= _("unknown mac");
2803 char const * additional
= NULL
;
2805 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2807 case EF_M68K_CF_ISA_A_NODIV
:
2809 additional
= ", nodiv";
2811 case EF_M68K_CF_ISA_A
:
2814 case EF_M68K_CF_ISA_A_PLUS
:
2817 case EF_M68K_CF_ISA_B_NOUSP
:
2819 additional
= ", nousp";
2821 case EF_M68K_CF_ISA_B
:
2824 case EF_M68K_CF_ISA_C
:
2827 case EF_M68K_CF_ISA_C_NODIV
:
2829 additional
= ", nodiv";
2832 strcat (buf
, ", cf, isa ");
2835 strcat (buf
, additional
);
2836 if (e_flags
& EF_M68K_CF_FLOAT
)
2837 strcat (buf
, ", float");
2838 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2843 case EF_M68K_CF_MAC
:
2846 case EF_M68K_CF_EMAC
:
2849 case EF_M68K_CF_EMAC_B
:
2862 if (e_flags
& EF_PPC_EMB
)
2863 strcat (buf
, ", emb");
2865 if (e_flags
& EF_PPC_RELOCATABLE
)
2866 strcat (buf
, _(", relocatable"));
2868 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2869 strcat (buf
, _(", relocatable-lib"));
2873 if (e_flags
& EF_PPC64_ABI
)
2875 char abi
[] = ", abiv0";
2877 abi
[6] += e_flags
& EF_PPC64_ABI
;
2883 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2884 strcat (buf
, ", RH850 ABI");
2886 if (e_flags
& EF_V800_850E3
)
2887 strcat (buf
, ", V3 architecture");
2889 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2890 strcat (buf
, ", FPU not used");
2892 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2893 strcat (buf
, ", regmode: COMMON");
2895 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2896 strcat (buf
, ", r4 not used");
2898 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2899 strcat (buf
, ", r30 not used");
2901 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2902 strcat (buf
, ", r5 not used");
2904 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2905 strcat (buf
, ", r2 not used");
2907 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2909 switch (e_flags
& - e_flags
)
2911 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2912 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2913 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2914 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2915 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2916 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2917 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2918 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2919 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2920 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2921 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2922 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2923 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2924 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2925 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2926 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2933 case EM_CYGNUS_V850
:
2934 switch (e_flags
& EF_V850_ARCH
)
2936 case E_V850E3V5_ARCH
:
2937 strcat (buf
, ", v850e3v5");
2939 case E_V850E2V3_ARCH
:
2940 strcat (buf
, ", v850e2v3");
2943 strcat (buf
, ", v850e2");
2946 strcat (buf
, ", v850e1");
2949 strcat (buf
, ", v850e");
2952 strcat (buf
, ", v850");
2955 strcat (buf
, _(", unknown v850 architecture variant"));
2961 case EM_CYGNUS_M32R
:
2962 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2963 strcat (buf
, ", m32r");
2967 case EM_MIPS_RS3_LE
:
2968 if (e_flags
& EF_MIPS_NOREORDER
)
2969 strcat (buf
, ", noreorder");
2971 if (e_flags
& EF_MIPS_PIC
)
2972 strcat (buf
, ", pic");
2974 if (e_flags
& EF_MIPS_CPIC
)
2975 strcat (buf
, ", cpic");
2977 if (e_flags
& EF_MIPS_UCODE
)
2978 strcat (buf
, ", ugen_reserved");
2980 if (e_flags
& EF_MIPS_ABI2
)
2981 strcat (buf
, ", abi2");
2983 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2984 strcat (buf
, ", odk first");
2986 if (e_flags
& EF_MIPS_32BITMODE
)
2987 strcat (buf
, ", 32bitmode");
2989 if (e_flags
& EF_MIPS_NAN2008
)
2990 strcat (buf
, ", nan2008");
2992 if (e_flags
& EF_MIPS_FP64
)
2993 strcat (buf
, ", fp64");
2995 switch ((e_flags
& EF_MIPS_MACH
))
2997 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2998 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2999 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3000 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3001 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3002 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3003 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3004 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3005 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3006 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3007 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3008 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3009 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3010 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3011 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3012 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3013 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3015 /* We simply ignore the field in this case to avoid confusion:
3016 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3019 default: strcat (buf
, _(", unknown CPU")); break;
3022 switch ((e_flags
& EF_MIPS_ABI
))
3024 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3025 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3026 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3027 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3029 /* We simply ignore the field in this case to avoid confusion:
3030 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3031 This means it is likely to be an o32 file, but not for
3034 default: strcat (buf
, _(", unknown ABI")); break;
3037 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3038 strcat (buf
, ", mdmx");
3040 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3041 strcat (buf
, ", mips16");
3043 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3044 strcat (buf
, ", micromips");
3046 switch ((e_flags
& EF_MIPS_ARCH
))
3048 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3049 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3050 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3051 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3052 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3053 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3054 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3055 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3056 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3057 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3058 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3059 default: strcat (buf
, _(", unknown ISA")); break;
3064 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3068 switch ((e_flags
& EF_SH_MACH_MASK
))
3070 case EF_SH1
: strcat (buf
, ", sh1"); break;
3071 case EF_SH2
: strcat (buf
, ", sh2"); break;
3072 case EF_SH3
: strcat (buf
, ", sh3"); break;
3073 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3074 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3075 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3076 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3077 case EF_SH4
: strcat (buf
, ", sh4"); break;
3078 case EF_SH5
: strcat (buf
, ", sh5"); break;
3079 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3080 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3081 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3082 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3083 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3084 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3085 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3086 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3087 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3088 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3089 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3090 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3091 default: strcat (buf
, _(", unknown ISA")); break;
3094 if (e_flags
& EF_SH_PIC
)
3095 strcat (buf
, ", pic");
3097 if (e_flags
& EF_SH_FDPIC
)
3098 strcat (buf
, ", fdpic");
3102 if (e_flags
& EF_OR1K_NODELAY
)
3103 strcat (buf
, ", no delay");
3107 if (e_flags
& EF_SPARC_32PLUS
)
3108 strcat (buf
, ", v8+");
3110 if (e_flags
& EF_SPARC_SUN_US1
)
3111 strcat (buf
, ", ultrasparcI");
3113 if (e_flags
& EF_SPARC_SUN_US3
)
3114 strcat (buf
, ", ultrasparcIII");
3116 if (e_flags
& EF_SPARC_HAL_R1
)
3117 strcat (buf
, ", halr1");
3119 if (e_flags
& EF_SPARC_LEDATA
)
3120 strcat (buf
, ", ledata");
3122 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3123 strcat (buf
, ", tso");
3125 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3126 strcat (buf
, ", pso");
3128 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3129 strcat (buf
, ", rmo");
3133 switch (e_flags
& EF_PARISC_ARCH
)
3135 case EFA_PARISC_1_0
:
3136 strcpy (buf
, ", PA-RISC 1.0");
3138 case EFA_PARISC_1_1
:
3139 strcpy (buf
, ", PA-RISC 1.1");
3141 case EFA_PARISC_2_0
:
3142 strcpy (buf
, ", PA-RISC 2.0");
3147 if (e_flags
& EF_PARISC_TRAPNIL
)
3148 strcat (buf
, ", trapnil");
3149 if (e_flags
& EF_PARISC_EXT
)
3150 strcat (buf
, ", ext");
3151 if (e_flags
& EF_PARISC_LSB
)
3152 strcat (buf
, ", lsb");
3153 if (e_flags
& EF_PARISC_WIDE
)
3154 strcat (buf
, ", wide");
3155 if (e_flags
& EF_PARISC_NO_KABP
)
3156 strcat (buf
, ", no kabp");
3157 if (e_flags
& EF_PARISC_LAZYSWAP
)
3158 strcat (buf
, ", lazyswap");
3163 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3164 strcat (buf
, ", new calling convention");
3166 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3167 strcat (buf
, ", gnu calling convention");
3171 if ((e_flags
& EF_IA_64_ABI64
))
3172 strcat (buf
, ", 64-bit");
3174 strcat (buf
, ", 32-bit");
3175 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3176 strcat (buf
, ", reduced fp model");
3177 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3178 strcat (buf
, ", no function descriptors, constant gp");
3179 else if ((e_flags
& EF_IA_64_CONS_GP
))
3180 strcat (buf
, ", constant gp");
3181 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3182 strcat (buf
, ", absolute");
3183 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3185 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3186 strcat (buf
, ", vms_linkages");
3187 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3189 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3191 case EF_IA_64_VMS_COMCOD_WARNING
:
3192 strcat (buf
, ", warning");
3194 case EF_IA_64_VMS_COMCOD_ERROR
:
3195 strcat (buf
, ", error");
3197 case EF_IA_64_VMS_COMCOD_ABORT
:
3198 strcat (buf
, ", abort");
3201 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3202 e_flags
& EF_IA_64_VMS_COMCOD
);
3203 strcat (buf
, ", <unknown>");
3209 if ((e_flags
& EF_VAX_NONPIC
))
3210 strcat (buf
, ", non-PIC");
3211 if ((e_flags
& EF_VAX_DFLOAT
))
3212 strcat (buf
, ", D-Float");
3213 if ((e_flags
& EF_VAX_GFLOAT
))
3214 strcat (buf
, ", G-Float");
3218 if (e_flags
& E_FLAG_RL78_G10
)
3219 strcat (buf
, ", G10");
3220 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3221 strcat (buf
, ", 64-bit doubles");
3225 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3226 strcat (buf
, ", 64-bit doubles");
3227 if (e_flags
& E_FLAG_RX_DSP
)
3228 strcat (buf
, ", dsp");
3229 if (e_flags
& E_FLAG_RX_PID
)
3230 strcat (buf
, ", pid");
3231 if (e_flags
& E_FLAG_RX_ABI
)
3232 strcat (buf
, ", RX ABI");
3236 if (e_flags
& EF_S390_HIGH_GPRS
)
3237 strcat (buf
, ", highgprs");
3241 if ((e_flags
& EF_C6000_REL
))
3242 strcat (buf
, ", relocatable module");
3246 strcat (buf
, _(": architecture variant: "));
3247 switch (e_flags
& EF_MSP430_MACH
)
3249 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3250 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3251 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3252 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3253 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3254 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3255 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3256 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3257 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3258 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3259 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3260 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3261 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3262 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3263 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3265 strcat (buf
, _(": unknown")); break;
3268 if (e_flags
& ~ EF_MSP430_MACH
)
3269 strcat (buf
, _(": unknown extra flag bits also present"));
3277 get_osabi_name (unsigned int osabi
)
3279 static char buff
[32];
3283 case ELFOSABI_NONE
: return "UNIX - System V";
3284 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3285 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3286 case ELFOSABI_GNU
: return "UNIX - GNU";
3287 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3288 case ELFOSABI_AIX
: return "UNIX - AIX";
3289 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3290 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3291 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3292 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3293 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3294 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3295 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3296 case ELFOSABI_AROS
: return "AROS";
3297 case ELFOSABI_FENIXOS
: return "FenixOS";
3300 switch (elf_header
.e_machine
)
3305 case ELFOSABI_ARM
: return "ARM";
3315 case ELFOSABI_STANDALONE
: return _("Standalone App");
3324 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3325 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3334 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3340 get_aarch64_segment_type (unsigned long type
)
3344 case PT_AARCH64_ARCHEXT
:
3345 return "AARCH64_ARCHEXT";
3354 get_arm_segment_type (unsigned long type
)
3368 get_mips_segment_type (unsigned long type
)
3372 case PT_MIPS_REGINFO
:
3374 case PT_MIPS_RTPROC
:
3376 case PT_MIPS_OPTIONS
:
3378 case PT_MIPS_ABIFLAGS
:
3388 get_parisc_segment_type (unsigned long type
)
3392 case PT_HP_TLS
: return "HP_TLS";
3393 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3394 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3395 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3396 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3397 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3398 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3399 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3400 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3401 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3402 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3403 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3404 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3405 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3406 case PT_HP_STACK
: return "HP_STACK";
3407 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3408 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3409 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3410 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3419 get_ia64_segment_type (unsigned long type
)
3423 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3424 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3425 case PT_HP_TLS
: return "HP_TLS";
3426 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3427 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3428 case PT_IA_64_HP_STACK
: return "HP_STACK";
3437 get_tic6x_segment_type (unsigned long type
)
3441 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3450 get_segment_type (unsigned long p_type
)
3452 static char buff
[32];
3456 case PT_NULL
: return "NULL";
3457 case PT_LOAD
: return "LOAD";
3458 case PT_DYNAMIC
: return "DYNAMIC";
3459 case PT_INTERP
: return "INTERP";
3460 case PT_NOTE
: return "NOTE";
3461 case PT_SHLIB
: return "SHLIB";
3462 case PT_PHDR
: return "PHDR";
3463 case PT_TLS
: return "TLS";
3465 case PT_GNU_EH_FRAME
:
3466 return "GNU_EH_FRAME";
3467 case PT_GNU_STACK
: return "GNU_STACK";
3468 case PT_GNU_RELRO
: return "GNU_RELRO";
3471 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3473 const char * result
;
3475 switch (elf_header
.e_machine
)
3478 result
= get_aarch64_segment_type (p_type
);
3481 result
= get_arm_segment_type (p_type
);
3484 case EM_MIPS_RS3_LE
:
3485 result
= get_mips_segment_type (p_type
);
3488 result
= get_parisc_segment_type (p_type
);
3491 result
= get_ia64_segment_type (p_type
);
3494 result
= get_tic6x_segment_type (p_type
);
3504 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3506 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3508 const char * result
;
3510 switch (elf_header
.e_machine
)
3513 result
= get_parisc_segment_type (p_type
);
3516 result
= get_ia64_segment_type (p_type
);
3526 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3529 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3536 get_mips_section_type_name (unsigned int sh_type
)
3540 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3541 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3542 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3543 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3544 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3545 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3546 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3547 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3548 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3549 case SHT_MIPS_RELD
: return "MIPS_RELD";
3550 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3551 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3552 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3553 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3554 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3555 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3556 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3557 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3558 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3559 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3560 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3561 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3562 case SHT_MIPS_LINE
: return "MIPS_LINE";
3563 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3564 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3565 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3566 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3567 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3568 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3569 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3570 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3571 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3572 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3573 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3574 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3575 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3576 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3577 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3578 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3579 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3587 get_parisc_section_type_name (unsigned int sh_type
)
3591 case SHT_PARISC_EXT
: return "PARISC_EXT";
3592 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3593 case SHT_PARISC_DOC
: return "PARISC_DOC";
3594 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3595 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3596 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3597 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3605 get_ia64_section_type_name (unsigned int sh_type
)
3607 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3608 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3609 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3613 case SHT_IA_64_EXT
: return "IA_64_EXT";
3614 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3615 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3616 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3617 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3618 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3619 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3620 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3621 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3622 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3630 get_x86_64_section_type_name (unsigned int sh_type
)
3634 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3642 get_aarch64_section_type_name (unsigned int sh_type
)
3646 case SHT_AARCH64_ATTRIBUTES
:
3647 return "AARCH64_ATTRIBUTES";
3655 get_arm_section_type_name (unsigned int sh_type
)
3659 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3660 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3661 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3662 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3663 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3671 get_tic6x_section_type_name (unsigned int sh_type
)
3675 case SHT_C6000_UNWIND
:
3676 return "C6000_UNWIND";
3677 case SHT_C6000_PREEMPTMAP
:
3678 return "C6000_PREEMPTMAP";
3679 case SHT_C6000_ATTRIBUTES
:
3680 return "C6000_ATTRIBUTES";
3685 case SHT_TI_HANDLER
:
3686 return "TI_HANDLER";
3687 case SHT_TI_INITINFO
:
3688 return "TI_INITINFO";
3689 case SHT_TI_PHATTRS
:
3690 return "TI_PHATTRS";
3698 get_msp430x_section_type_name (unsigned int sh_type
)
3702 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3703 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3704 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3705 default: return NULL
;
3710 get_section_type_name (unsigned int sh_type
)
3712 static char buff
[32];
3716 case SHT_NULL
: return "NULL";
3717 case SHT_PROGBITS
: return "PROGBITS";
3718 case SHT_SYMTAB
: return "SYMTAB";
3719 case SHT_STRTAB
: return "STRTAB";
3720 case SHT_RELA
: return "RELA";
3721 case SHT_HASH
: return "HASH";
3722 case SHT_DYNAMIC
: return "DYNAMIC";
3723 case SHT_NOTE
: return "NOTE";
3724 case SHT_NOBITS
: return "NOBITS";
3725 case SHT_REL
: return "REL";
3726 case SHT_SHLIB
: return "SHLIB";
3727 case SHT_DYNSYM
: return "DYNSYM";
3728 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3729 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3730 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3731 case SHT_GNU_HASH
: return "GNU_HASH";
3732 case SHT_GROUP
: return "GROUP";
3733 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3734 case SHT_GNU_verdef
: return "VERDEF";
3735 case SHT_GNU_verneed
: return "VERNEED";
3736 case SHT_GNU_versym
: return "VERSYM";
3737 case 0x6ffffff0: return "VERSYM";
3738 case 0x6ffffffc: return "VERDEF";
3739 case 0x7ffffffd: return "AUXILIARY";
3740 case 0x7fffffff: return "FILTER";
3741 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3744 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3746 const char * result
;
3748 switch (elf_header
.e_machine
)
3751 case EM_MIPS_RS3_LE
:
3752 result
= get_mips_section_type_name (sh_type
);
3755 result
= get_parisc_section_type_name (sh_type
);
3758 result
= get_ia64_section_type_name (sh_type
);
3763 result
= get_x86_64_section_type_name (sh_type
);
3766 result
= get_aarch64_section_type_name (sh_type
);
3769 result
= get_arm_section_type_name (sh_type
);
3772 result
= get_tic6x_section_type_name (sh_type
);
3775 result
= get_msp430x_section_type_name (sh_type
);
3785 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3787 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3789 const char * result
;
3791 switch (elf_header
.e_machine
)
3794 result
= get_ia64_section_type_name (sh_type
);
3804 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3806 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3807 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3809 /* This message is probably going to be displayed in a 15
3810 character wide field, so put the hex value first. */
3811 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3817 #define OPTION_DEBUG_DUMP 512
3818 #define OPTION_DYN_SYMS 513
3819 #define OPTION_DWARF_DEPTH 514
3820 #define OPTION_DWARF_START 515
3821 #define OPTION_DWARF_CHECK 516
3823 static struct option options
[] =
3825 {"all", no_argument
, 0, 'a'},
3826 {"file-header", no_argument
, 0, 'h'},
3827 {"program-headers", no_argument
, 0, 'l'},
3828 {"headers", no_argument
, 0, 'e'},
3829 {"histogram", no_argument
, 0, 'I'},
3830 {"segments", no_argument
, 0, 'l'},
3831 {"sections", no_argument
, 0, 'S'},
3832 {"section-headers", no_argument
, 0, 'S'},
3833 {"section-groups", no_argument
, 0, 'g'},
3834 {"section-details", no_argument
, 0, 't'},
3835 {"full-section-name",no_argument
, 0, 'N'},
3836 {"symbols", no_argument
, 0, 's'},
3837 {"syms", no_argument
, 0, 's'},
3838 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3839 {"relocs", no_argument
, 0, 'r'},
3840 {"notes", no_argument
, 0, 'n'},
3841 {"dynamic", no_argument
, 0, 'd'},
3842 {"arch-specific", no_argument
, 0, 'A'},
3843 {"version-info", no_argument
, 0, 'V'},
3844 {"use-dynamic", no_argument
, 0, 'D'},
3845 {"unwind", no_argument
, 0, 'u'},
3846 {"archive-index", no_argument
, 0, 'c'},
3847 {"hex-dump", required_argument
, 0, 'x'},
3848 {"relocated-dump", required_argument
, 0, 'R'},
3849 {"string-dump", required_argument
, 0, 'p'},
3850 #ifdef SUPPORT_DISASSEMBLY
3851 {"instruction-dump", required_argument
, 0, 'i'},
3853 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3855 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3856 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3857 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3859 {"version", no_argument
, 0, 'v'},
3860 {"wide", no_argument
, 0, 'W'},
3861 {"help", no_argument
, 0, 'H'},
3862 {0, no_argument
, 0, 0}
3866 usage (FILE * stream
)
3868 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3869 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3870 fprintf (stream
, _(" Options are:\n\
3871 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3872 -h --file-header Display the ELF file header\n\
3873 -l --program-headers Display the program headers\n\
3874 --segments An alias for --program-headers\n\
3875 -S --section-headers Display the sections' header\n\
3876 --sections An alias for --section-headers\n\
3877 -g --section-groups Display the section groups\n\
3878 -t --section-details Display the section details\n\
3879 -e --headers Equivalent to: -h -l -S\n\
3880 -s --syms Display the symbol table\n\
3881 --symbols An alias for --syms\n\
3882 --dyn-syms Display the dynamic symbol table\n\
3883 -n --notes Display the core notes (if present)\n\
3884 -r --relocs Display the relocations (if present)\n\
3885 -u --unwind Display the unwind info (if present)\n\
3886 -d --dynamic Display the dynamic section (if present)\n\
3887 -V --version-info Display the version sections (if present)\n\
3888 -A --arch-specific Display architecture specific information (if any)\n\
3889 -c --archive-index Display the symbol/file index in an archive\n\
3890 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3891 -x --hex-dump=<number|name>\n\
3892 Dump the contents of section <number|name> as bytes\n\
3893 -p --string-dump=<number|name>\n\
3894 Dump the contents of section <number|name> as strings\n\
3895 -R --relocated-dump=<number|name>\n\
3896 Dump the contents of section <number|name> as relocated bytes\n\
3897 -w[lLiaprmfFsoRt] or\n\
3898 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3899 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3900 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3902 Display the contents of DWARF2 debug sections\n"));
3903 fprintf (stream
, _("\
3904 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3905 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3907 #ifdef SUPPORT_DISASSEMBLY
3908 fprintf (stream
, _("\
3909 -i --instruction-dump=<number|name>\n\
3910 Disassemble the contents of section <number|name>\n"));
3912 fprintf (stream
, _("\
3913 -I --histogram Display histogram of bucket list lengths\n\
3914 -W --wide Allow output width to exceed 80 characters\n\
3915 @<file> Read options from <file>\n\
3916 -H --help Display this information\n\
3917 -v --version Display the version number of readelf\n"));
3919 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3920 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3922 exit (stream
== stdout
? 0 : 1);
3925 /* Record the fact that the user wants the contents of section number
3926 SECTION to be displayed using the method(s) encoded as flags bits
3927 in TYPE. Note, TYPE can be zero if we are creating the array for
3931 request_dump_bynumber (unsigned int section
, dump_type type
)
3933 if (section
>= num_dump_sects
)
3935 dump_type
* new_dump_sects
;
3937 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3938 sizeof (* dump_sects
));
3940 if (new_dump_sects
== NULL
)
3941 error (_("Out of memory allocating dump request table.\n"));
3944 /* Copy current flag settings. */
3945 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3949 dump_sects
= new_dump_sects
;
3950 num_dump_sects
= section
+ 1;
3955 dump_sects
[section
] |= type
;
3960 /* Request a dump by section name. */
3963 request_dump_byname (const char * section
, dump_type type
)
3965 struct dump_list_entry
* new_request
;
3967 new_request
= (struct dump_list_entry
*)
3968 malloc (sizeof (struct dump_list_entry
));
3970 error (_("Out of memory allocating dump request table.\n"));
3972 new_request
->name
= strdup (section
);
3973 if (!new_request
->name
)
3974 error (_("Out of memory allocating dump request table.\n"));
3976 new_request
->type
= type
;
3978 new_request
->next
= dump_sects_byname
;
3979 dump_sects_byname
= new_request
;
3983 request_dump (dump_type type
)
3989 section
= strtoul (optarg
, & cp
, 0);
3991 if (! *cp
&& section
>= 0)
3992 request_dump_bynumber (section
, type
);
3994 request_dump_byname (optarg
, type
);
3999 parse_args (int argc
, char ** argv
)
4006 while ((c
= getopt_long
4007 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
4025 do_section_groups
++;
4033 do_section_groups
++;
4038 do_section_details
++;
4082 request_dump (HEX_DUMP
);
4085 request_dump (STRING_DUMP
);
4088 request_dump (RELOC_DUMP
);
4095 dwarf_select_sections_all ();
4100 dwarf_select_sections_by_letters (optarg
);
4103 case OPTION_DEBUG_DUMP
:
4110 dwarf_select_sections_by_names (optarg
);
4113 case OPTION_DWARF_DEPTH
:
4117 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4120 case OPTION_DWARF_START
:
4124 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4127 case OPTION_DWARF_CHECK
:
4130 case OPTION_DYN_SYMS
:
4133 #ifdef SUPPORT_DISASSEMBLY
4135 request_dump (DISASS_DUMP
);
4139 print_version (program_name
);
4148 /* xgettext:c-format */
4149 error (_("Invalid option '-%c'\n"), c
);
4156 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4157 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4158 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4159 && !do_section_groups
&& !do_archive_index
4164 warn (_("Nothing to do.\n"));
4170 get_elf_class (unsigned int elf_class
)
4172 static char buff
[32];
4176 case ELFCLASSNONE
: return _("none");
4177 case ELFCLASS32
: return "ELF32";
4178 case ELFCLASS64
: return "ELF64";
4180 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4186 get_data_encoding (unsigned int encoding
)
4188 static char buff
[32];
4192 case ELFDATANONE
: return _("none");
4193 case ELFDATA2LSB
: return _("2's complement, little endian");
4194 case ELFDATA2MSB
: return _("2's complement, big endian");
4196 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4201 /* Decode the data held in 'elf_header'. */
4204 process_file_header (void)
4206 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4207 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4208 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4209 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4212 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4216 init_dwarf_regnames (elf_header
.e_machine
);
4222 printf (_("ELF Header:\n"));
4223 printf (_(" Magic: "));
4224 for (i
= 0; i
< EI_NIDENT
; i
++)
4225 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4227 printf (_(" Class: %s\n"),
4228 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4229 printf (_(" Data: %s\n"),
4230 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4231 printf (_(" Version: %d %s\n"),
4232 elf_header
.e_ident
[EI_VERSION
],
4233 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4235 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4236 ? _("<unknown: %lx>")
4238 printf (_(" OS/ABI: %s\n"),
4239 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4240 printf (_(" ABI Version: %d\n"),
4241 elf_header
.e_ident
[EI_ABIVERSION
]);
4242 printf (_(" Type: %s\n"),
4243 get_file_type (elf_header
.e_type
));
4244 printf (_(" Machine: %s\n"),
4245 get_machine_name (elf_header
.e_machine
));
4246 printf (_(" Version: 0x%lx\n"),
4247 (unsigned long) elf_header
.e_version
);
4249 printf (_(" Entry point address: "));
4250 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4251 printf (_("\n Start of program headers: "));
4252 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4253 printf (_(" (bytes into file)\n Start of section headers: "));
4254 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4255 printf (_(" (bytes into file)\n"));
4257 printf (_(" Flags: 0x%lx%s\n"),
4258 (unsigned long) elf_header
.e_flags
,
4259 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4260 printf (_(" Size of this header: %ld (bytes)\n"),
4261 (long) elf_header
.e_ehsize
);
4262 printf (_(" Size of program headers: %ld (bytes)\n"),
4263 (long) elf_header
.e_phentsize
);
4264 printf (_(" Number of program headers: %ld"),
4265 (long) elf_header
.e_phnum
);
4266 if (section_headers
!= NULL
4267 && elf_header
.e_phnum
== PN_XNUM
4268 && section_headers
[0].sh_info
!= 0)
4269 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4270 putc ('\n', stdout
);
4271 printf (_(" Size of section headers: %ld (bytes)\n"),
4272 (long) elf_header
.e_shentsize
);
4273 printf (_(" Number of section headers: %ld"),
4274 (long) elf_header
.e_shnum
);
4275 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4276 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4277 putc ('\n', stdout
);
4278 printf (_(" Section header string table index: %ld"),
4279 (long) elf_header
.e_shstrndx
);
4280 if (section_headers
!= NULL
4281 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4282 printf (" (%u)", section_headers
[0].sh_link
);
4283 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4284 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4285 printf (_(" <corrupt: out of range>"));
4286 putc ('\n', stdout
);
4289 if (section_headers
!= NULL
)
4291 if (elf_header
.e_phnum
== PN_XNUM
4292 && section_headers
[0].sh_info
!= 0)
4293 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4294 if (elf_header
.e_shnum
== SHN_UNDEF
)
4295 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4296 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4297 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4298 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4299 elf_header
.e_shstrndx
= SHN_UNDEF
;
4300 free (section_headers
);
4301 section_headers
= NULL
;
4308 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4310 Elf32_External_Phdr
* phdrs
;
4311 Elf32_External_Phdr
* external
;
4312 Elf_Internal_Phdr
* internal
;
4314 unsigned int size
= elf_header
.e_phentsize
;
4315 unsigned int num
= elf_header
.e_phnum
;
4317 /* PR binutils/17531: Cope with unexpected section header sizes. */
4318 if (size
== 0 || num
== 0)
4320 if (size
< sizeof * phdrs
)
4322 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4325 if (size
> sizeof * phdrs
)
4326 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4328 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4329 size
, num
, _("program headers"));
4333 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4334 i
< elf_header
.e_phnum
;
4335 i
++, internal
++, external
++)
4337 internal
->p_type
= BYTE_GET (external
->p_type
);
4338 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4339 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4340 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4341 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4342 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4343 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4344 internal
->p_align
= BYTE_GET (external
->p_align
);
4352 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4354 Elf64_External_Phdr
* phdrs
;
4355 Elf64_External_Phdr
* external
;
4356 Elf_Internal_Phdr
* internal
;
4358 unsigned int size
= elf_header
.e_phentsize
;
4359 unsigned int num
= elf_header
.e_phnum
;
4361 /* PR binutils/17531: Cope with unexpected section header sizes. */
4362 if (size
== 0 || num
== 0)
4364 if (size
< sizeof * phdrs
)
4366 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4369 if (size
> sizeof * phdrs
)
4370 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4372 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4373 size
, num
, _("program headers"));
4377 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4378 i
< elf_header
.e_phnum
;
4379 i
++, internal
++, external
++)
4381 internal
->p_type
= BYTE_GET (external
->p_type
);
4382 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4383 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4384 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4385 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4386 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4387 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4388 internal
->p_align
= BYTE_GET (external
->p_align
);
4395 /* Returns 1 if the program headers were read into `program_headers'. */
4398 get_program_headers (FILE * file
)
4400 Elf_Internal_Phdr
* phdrs
;
4402 /* Check cache of prior read. */
4403 if (program_headers
!= NULL
)
4406 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4407 sizeof (Elf_Internal_Phdr
));
4411 error (_("Out of memory reading %u program headers\n"),
4412 elf_header
.e_phnum
);
4417 ? get_32bit_program_headers (file
, phdrs
)
4418 : get_64bit_program_headers (file
, phdrs
))
4420 program_headers
= phdrs
;
4428 /* Returns 1 if the program headers were loaded. */
4431 process_program_headers (FILE * file
)
4433 Elf_Internal_Phdr
* segment
;
4436 if (elf_header
.e_phnum
== 0)
4438 /* PR binutils/12467. */
4439 if (elf_header
.e_phoff
!= 0)
4440 warn (_("possibly corrupt ELF header - it has a non-zero program"
4441 " header offset, but no program headers"));
4442 else if (do_segments
)
4443 printf (_("\nThere are no program headers in this file.\n"));
4447 if (do_segments
&& !do_header
)
4449 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4450 printf (_("Entry point "));
4451 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4452 printf (_("\nThere are %d program headers, starting at offset "),
4453 elf_header
.e_phnum
);
4454 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4458 if (! get_program_headers (file
))
4463 if (elf_header
.e_phnum
> 1)
4464 printf (_("\nProgram Headers:\n"));
4466 printf (_("\nProgram Headers:\n"));
4470 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4473 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4477 (_(" Type Offset VirtAddr PhysAddr\n"));
4479 (_(" FileSiz MemSiz Flags Align\n"));
4486 for (i
= 0, segment
= program_headers
;
4487 i
< elf_header
.e_phnum
;
4492 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4496 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4497 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4498 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4499 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4500 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4502 (segment
->p_flags
& PF_R
? 'R' : ' '),
4503 (segment
->p_flags
& PF_W
? 'W' : ' '),
4504 (segment
->p_flags
& PF_X
? 'E' : ' '));
4505 printf ("%#lx", (unsigned long) segment
->p_align
);
4509 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4510 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4513 print_vma (segment
->p_offset
, FULL_HEX
);
4517 print_vma (segment
->p_vaddr
, FULL_HEX
);
4519 print_vma (segment
->p_paddr
, FULL_HEX
);
4522 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4523 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4526 print_vma (segment
->p_filesz
, FULL_HEX
);
4530 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4531 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4534 print_vma (segment
->p_memsz
, FULL_HEX
);
4538 (segment
->p_flags
& PF_R
? 'R' : ' '),
4539 (segment
->p_flags
& PF_W
? 'W' : ' '),
4540 (segment
->p_flags
& PF_X
? 'E' : ' '));
4542 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4543 printf ("%#lx", (unsigned long) segment
->p_align
);
4546 print_vma (segment
->p_align
, PREFIX_HEX
);
4551 print_vma (segment
->p_offset
, FULL_HEX
);
4553 print_vma (segment
->p_vaddr
, FULL_HEX
);
4555 print_vma (segment
->p_paddr
, FULL_HEX
);
4557 print_vma (segment
->p_filesz
, FULL_HEX
);
4559 print_vma (segment
->p_memsz
, FULL_HEX
);
4561 (segment
->p_flags
& PF_R
? 'R' : ' '),
4562 (segment
->p_flags
& PF_W
? 'W' : ' '),
4563 (segment
->p_flags
& PF_X
? 'E' : ' '));
4564 print_vma (segment
->p_align
, HEX
);
4569 putc ('\n', stdout
);
4571 switch (segment
->p_type
)
4575 error (_("more than one dynamic segment\n"));
4577 /* By default, assume that the .dynamic section is the first
4578 section in the DYNAMIC segment. */
4579 dynamic_addr
= segment
->p_offset
;
4580 dynamic_size
= segment
->p_filesz
;
4581 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4582 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4584 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4585 dynamic_addr
= dynamic_size
= 0;
4588 /* Try to locate the .dynamic section. If there is
4589 a section header table, we can easily locate it. */
4590 if (section_headers
!= NULL
)
4592 Elf_Internal_Shdr
* sec
;
4594 sec
= find_section (".dynamic");
4595 if (sec
== NULL
|| sec
->sh_size
== 0)
4597 /* A corresponding .dynamic section is expected, but on
4598 IA-64/OpenVMS it is OK for it to be missing. */
4599 if (!is_ia64_vms ())
4600 error (_("no .dynamic section in the dynamic segment\n"));
4604 if (sec
->sh_type
== SHT_NOBITS
)
4610 dynamic_addr
= sec
->sh_offset
;
4611 dynamic_size
= sec
->sh_size
;
4613 if (dynamic_addr
< segment
->p_offset
4614 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4615 warn (_("the .dynamic section is not contained"
4616 " within the dynamic segment\n"));
4617 else if (dynamic_addr
> segment
->p_offset
)
4618 warn (_("the .dynamic section is not the first section"
4619 " in the dynamic segment.\n"));
4624 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4626 error (_("Unable to find program interpreter name\n"));
4630 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4632 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4633 error (_("Internal error: failed to create format string to display program interpreter\n"));
4635 program_interpreter
[0] = 0;
4636 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4637 error (_("Unable to read program interpreter name\n"));
4640 printf (_(" [Requesting program interpreter: %s]\n"),
4641 program_interpreter
);
4647 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4649 printf (_("\n Section to Segment mapping:\n"));
4650 printf (_(" Segment Sections...\n"));
4652 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4655 Elf_Internal_Shdr
* section
;
4657 segment
= program_headers
+ i
;
4658 section
= section_headers
+ 1;
4660 printf (" %2.2d ", i
);
4662 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4664 if (!ELF_TBSS_SPECIAL (section
, segment
)
4665 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4666 printf ("%s ", printable_section_name (section
));
4677 /* Find the file offset corresponding to VMA by using the program headers. */
4680 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4682 Elf_Internal_Phdr
* seg
;
4684 if (! get_program_headers (file
))
4686 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4690 for (seg
= program_headers
;
4691 seg
< program_headers
+ elf_header
.e_phnum
;
4694 if (seg
->p_type
!= PT_LOAD
)
4697 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4698 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4699 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4702 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4703 (unsigned long) vma
);
4708 /* Allocate memory and load the sections headers into the global pointer
4709 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4710 generate any error messages if the load fails. */
4713 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4715 Elf32_External_Shdr
* shdrs
;
4716 Elf_Internal_Shdr
* internal
;
4718 unsigned int size
= elf_header
.e_shentsize
;
4719 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4721 /* PR binutils/17531: Cope with unexpected section header sizes. */
4722 if (size
== 0 || num
== 0)
4724 if (size
< sizeof * shdrs
)
4727 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4730 if (!probe
&& size
> sizeof * shdrs
)
4731 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4733 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4735 probe
? NULL
: _("section headers"));
4739 if (section_headers
!= NULL
)
4740 free (section_headers
);
4741 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4742 sizeof (Elf_Internal_Shdr
));
4743 if (section_headers
== NULL
)
4746 error (_("Out of memory reading %u section headers\n"), num
);
4750 for (i
= 0, internal
= section_headers
;
4754 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4755 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4756 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4757 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4758 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4759 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4760 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4761 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4762 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4763 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4771 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4773 Elf64_External_Shdr
* shdrs
;
4774 Elf_Internal_Shdr
* internal
;
4776 unsigned int size
= elf_header
.e_shentsize
;
4777 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4779 /* PR binutils/17531: Cope with unexpected section header sizes. */
4780 if (size
== 0 || num
== 0)
4782 if (size
< sizeof * shdrs
)
4785 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4788 if (! probe
&& size
> sizeof * shdrs
)
4789 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4791 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4793 probe
? NULL
: _("section headers"));
4797 if (section_headers
!= NULL
)
4798 free (section_headers
);
4799 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4800 sizeof (Elf_Internal_Shdr
));
4801 if (section_headers
== NULL
)
4804 error (_("Out of memory reading %u section headers\n"), num
);
4808 for (i
= 0, internal
= section_headers
;
4812 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4813 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4814 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4815 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4816 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4817 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4818 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4819 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4820 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4821 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4828 static Elf_Internal_Sym
*
4829 get_32bit_elf_symbols (FILE * file
,
4830 Elf_Internal_Shdr
* section
,
4831 unsigned long * num_syms_return
)
4833 unsigned long number
= 0;
4834 Elf32_External_Sym
* esyms
= NULL
;
4835 Elf_External_Sym_Shndx
* shndx
= NULL
;
4836 Elf_Internal_Sym
* isyms
= NULL
;
4837 Elf_Internal_Sym
* psym
;
4840 if (section
->sh_size
== 0)
4842 if (num_syms_return
!= NULL
)
4843 * num_syms_return
= 0;
4847 /* Run some sanity checks first. */
4848 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4850 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4851 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
4855 if (section
->sh_size
> current_file_size
)
4857 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4858 printable_section_name (section
), (unsigned long) section
->sh_size
);
4862 number
= section
->sh_size
/ section
->sh_entsize
;
4864 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4866 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4867 (unsigned long) section
->sh_size
,
4868 printable_section_name (section
),
4869 (unsigned long) section
->sh_entsize
);
4873 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4874 section
->sh_size
, _("symbols"));
4879 if (symtab_shndx_hdr
!= NULL
4880 && (symtab_shndx_hdr
->sh_link
4881 == (unsigned long) (section
- section_headers
)))
4883 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4884 symtab_shndx_hdr
->sh_offset
,
4885 1, symtab_shndx_hdr
->sh_size
,
4886 _("symbol table section indicies"));
4889 /* PR17531: file: heap-buffer-overflow */
4890 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
4892 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4893 printable_section_name (symtab_shndx_hdr
),
4894 (unsigned long) symtab_shndx_hdr
->sh_size
,
4895 (unsigned long) section
->sh_size
);
4900 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4904 error (_("Out of memory reading %lu symbols\n"),
4905 (unsigned long) number
);
4909 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4911 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4912 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4913 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4914 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4915 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4917 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4918 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4919 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4920 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4921 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4930 if (num_syms_return
!= NULL
)
4931 * num_syms_return
= isyms
== NULL
? 0 : number
;
4936 static Elf_Internal_Sym
*
4937 get_64bit_elf_symbols (FILE * file
,
4938 Elf_Internal_Shdr
* section
,
4939 unsigned long * num_syms_return
)
4941 unsigned long number
= 0;
4942 Elf64_External_Sym
* esyms
= NULL
;
4943 Elf_External_Sym_Shndx
* shndx
= NULL
;
4944 Elf_Internal_Sym
* isyms
= NULL
;
4945 Elf_Internal_Sym
* psym
;
4948 if (section
->sh_size
== 0)
4950 if (num_syms_return
!= NULL
)
4951 * num_syms_return
= 0;
4955 /* Run some sanity checks first. */
4956 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
4958 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4959 printable_section_name (section
),
4960 (unsigned long) section
->sh_entsize
);
4964 if (section
->sh_size
> current_file_size
)
4966 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4967 printable_section_name (section
),
4968 (unsigned long) section
->sh_size
);
4972 number
= section
->sh_size
/ section
->sh_entsize
;
4974 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4976 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4977 (unsigned long) section
->sh_size
,
4978 printable_section_name (section
),
4979 (unsigned long) section
->sh_entsize
);
4983 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4984 section
->sh_size
, _("symbols"));
4988 if (symtab_shndx_hdr
!= NULL
4989 && (symtab_shndx_hdr
->sh_link
4990 == (unsigned long) (section
- section_headers
)))
4992 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4993 symtab_shndx_hdr
->sh_offset
,
4994 1, symtab_shndx_hdr
->sh_size
,
4995 _("symbol table section indicies"));
4998 else if (symtab_shndx_hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5000 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5001 printable_section_name (symtab_shndx_hdr
),
5002 (unsigned long) symtab_shndx_hdr
->sh_size
,
5003 (unsigned long) section
->sh_size
);
5008 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5012 error (_("Out of memory reading %lu symbols\n"),
5013 (unsigned long) number
);
5017 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5019 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5020 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5021 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5022 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5024 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5026 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5027 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5028 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5030 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5031 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5040 if (num_syms_return
!= NULL
)
5041 * num_syms_return
= isyms
== NULL
? 0 : number
;
5047 get_elf_section_flags (bfd_vma sh_flags
)
5049 static char buff
[1024];
5051 int field_size
= is_32bit_elf
? 8 : 16;
5053 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5054 bfd_vma os_flags
= 0;
5055 bfd_vma proc_flags
= 0;
5056 bfd_vma unknown_flags
= 0;
5064 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5065 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5066 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5067 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5068 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5069 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5070 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5071 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5072 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5073 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5074 /* IA-64 specific. */
5075 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5076 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5077 /* IA-64 OpenVMS specific. */
5078 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5079 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5080 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5081 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5082 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5083 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5085 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5086 /* SPARC specific. */
5087 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5090 if (do_section_details
)
5092 sprintf (buff
, "[%*.*lx]: ",
5093 field_size
, field_size
, (unsigned long) sh_flags
);
5094 p
+= field_size
+ 4;
5101 flag
= sh_flags
& - sh_flags
;
5104 if (do_section_details
)
5108 case SHF_WRITE
: sindex
= 0; break;
5109 case SHF_ALLOC
: sindex
= 1; break;
5110 case SHF_EXECINSTR
: sindex
= 2; break;
5111 case SHF_MERGE
: sindex
= 3; break;
5112 case SHF_STRINGS
: sindex
= 4; break;
5113 case SHF_INFO_LINK
: sindex
= 5; break;
5114 case SHF_LINK_ORDER
: sindex
= 6; break;
5115 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5116 case SHF_GROUP
: sindex
= 8; break;
5117 case SHF_TLS
: sindex
= 9; break;
5118 case SHF_EXCLUDE
: sindex
= 18; break;
5122 switch (elf_header
.e_machine
)
5125 if (flag
== SHF_IA_64_SHORT
)
5127 else if (flag
== SHF_IA_64_NORECOV
)
5130 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5133 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5134 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5135 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5136 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5137 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5138 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5149 case EM_OLD_SPARCV9
:
5150 case EM_SPARC32PLUS
:
5153 if (flag
== SHF_ORDERED
)
5163 if (p
!= buff
+ field_size
+ 4)
5165 if (size
< (10 + 2))
5167 warn (_("Internal error: not enough buffer room for section flag info"));
5168 return _("<unknown>");
5175 size
-= flags
[sindex
].len
;
5176 p
= stpcpy (p
, flags
[sindex
].str
);
5178 else if (flag
& SHF_MASKOS
)
5180 else if (flag
& SHF_MASKPROC
)
5183 unknown_flags
|= flag
;
5189 case SHF_WRITE
: *p
= 'W'; break;
5190 case SHF_ALLOC
: *p
= 'A'; break;
5191 case SHF_EXECINSTR
: *p
= 'X'; break;
5192 case SHF_MERGE
: *p
= 'M'; break;
5193 case SHF_STRINGS
: *p
= 'S'; break;
5194 case SHF_INFO_LINK
: *p
= 'I'; break;
5195 case SHF_LINK_ORDER
: *p
= 'L'; break;
5196 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5197 case SHF_GROUP
: *p
= 'G'; break;
5198 case SHF_TLS
: *p
= 'T'; break;
5199 case SHF_EXCLUDE
: *p
= 'E'; break;
5202 if ((elf_header
.e_machine
== EM_X86_64
5203 || elf_header
.e_machine
== EM_L1OM
5204 || elf_header
.e_machine
== EM_K1OM
)
5205 && flag
== SHF_X86_64_LARGE
)
5207 else if (flag
& SHF_MASKOS
)
5210 sh_flags
&= ~ SHF_MASKOS
;
5212 else if (flag
& SHF_MASKPROC
)
5215 sh_flags
&= ~ SHF_MASKPROC
;
5225 if (do_section_details
)
5229 size
-= 5 + field_size
;
5230 if (p
!= buff
+ field_size
+ 4)
5234 warn (_("Internal error: not enough buffer room for section flag info"));
5235 return _("<unknown>");
5241 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5242 (unsigned long) os_flags
);
5243 p
+= 5 + field_size
;
5247 size
-= 7 + field_size
;
5248 if (p
!= buff
+ field_size
+ 4)
5252 warn (_("Internal error: not enough buffer room for section flag info"));
5253 return _("<unknown>");
5259 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5260 (unsigned long) proc_flags
);
5261 p
+= 7 + field_size
;
5265 size
-= 10 + field_size
;
5266 if (p
!= buff
+ field_size
+ 4)
5270 warn (_("Internal error: not enough buffer room for section flag info"));
5271 return _("<unknown>");
5277 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5278 (unsigned long) unknown_flags
);
5279 p
+= 10 + field_size
;
5288 process_section_headers (FILE * file
)
5290 Elf_Internal_Shdr
* section
;
5293 section_headers
= NULL
;
5295 if (elf_header
.e_shnum
== 0)
5297 /* PR binutils/12467. */
5298 if (elf_header
.e_shoff
!= 0)
5299 warn (_("possibly corrupt ELF file header - it has a non-zero"
5300 " section header offset, but no section headers\n"));
5301 else if (do_sections
)
5302 printf (_("\nThere are no sections in this file.\n"));
5307 if (do_sections
&& !do_header
)
5308 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5309 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5313 if (! get_32bit_section_headers (file
, FALSE
))
5316 else if (! get_64bit_section_headers (file
, FALSE
))
5319 /* Read in the string table, so that we have names to display. */
5320 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5321 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5323 section
= section_headers
+ elf_header
.e_shstrndx
;
5325 if (section
->sh_size
!= 0)
5327 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5328 1, section
->sh_size
,
5331 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5335 /* Scan the sections for the dynamic symbol table
5336 and dynamic string table and debug sections. */
5337 dynamic_symbols
= NULL
;
5338 dynamic_strings
= NULL
;
5339 dynamic_syminfo
= NULL
;
5340 symtab_shndx_hdr
= NULL
;
5342 eh_addr_size
= is_32bit_elf
? 4 : 8;
5343 switch (elf_header
.e_machine
)
5346 case EM_MIPS_RS3_LE
:
5347 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5348 FDE addresses. However, the ABI also has a semi-official ILP32
5349 variant for which the normal FDE address size rules apply.
5351 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5352 section, where XX is the size of longs in bits. Unfortunately,
5353 earlier compilers provided no way of distinguishing ILP32 objects
5354 from LP64 objects, so if there's any doubt, we should assume that
5355 the official LP64 form is being used. */
5356 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5357 && find_section (".gcc_compiled_long32") == NULL
)
5363 switch (elf_header
.e_flags
& EF_H8_MACH
)
5365 case E_H8_MACH_H8300
:
5366 case E_H8_MACH_H8300HN
:
5367 case E_H8_MACH_H8300SN
:
5368 case E_H8_MACH_H8300SXN
:
5371 case E_H8_MACH_H8300H
:
5372 case E_H8_MACH_H8300S
:
5373 case E_H8_MACH_H8300SX
:
5381 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5383 case EF_M32C_CPU_M16C
:
5390 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5393 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5394 if (section->sh_entsize != expected_entsize) \
5397 sprintf_vma (buf, section->sh_entsize); \
5398 /* Note: coded this way so that there is a single string for \
5400 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5401 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5402 (unsigned) expected_entsize); \
5403 section->sh_entsize = expected_entsize; \
5408 #define CHECK_ENTSIZE(section, i, type) \
5409 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5410 sizeof (Elf64_External_##type))
5412 for (i
= 0, section
= section_headers
;
5413 i
< elf_header
.e_shnum
;
5416 char * name
= SECTION_NAME (section
);
5418 if (section
->sh_type
== SHT_DYNSYM
)
5420 if (dynamic_symbols
!= NULL
)
5422 error (_("File contains multiple dynamic symbol tables\n"));
5426 CHECK_ENTSIZE (section
, i
, Sym
);
5427 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5429 else if (section
->sh_type
== SHT_STRTAB
5430 && streq (name
, ".dynstr"))
5432 if (dynamic_strings
!= NULL
)
5434 error (_("File contains multiple dynamic string tables\n"));
5438 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5439 1, section
->sh_size
,
5440 _("dynamic strings"));
5441 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5443 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5445 if (symtab_shndx_hdr
!= NULL
)
5447 error (_("File contains multiple symtab shndx tables\n"));
5450 symtab_shndx_hdr
= section
;
5452 else if (section
->sh_type
== SHT_SYMTAB
)
5453 CHECK_ENTSIZE (section
, i
, Sym
);
5454 else if (section
->sh_type
== SHT_GROUP
)
5455 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5456 else if (section
->sh_type
== SHT_REL
)
5457 CHECK_ENTSIZE (section
, i
, Rel
);
5458 else if (section
->sh_type
== SHT_RELA
)
5459 CHECK_ENTSIZE (section
, i
, Rela
);
5460 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5461 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5462 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5463 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5464 || do_debug_addr
|| do_debug_cu_index
)
5465 && (const_strneq (name
, ".debug_")
5466 || const_strneq (name
, ".zdebug_")))
5469 name
+= sizeof (".zdebug_") - 1;
5471 name
+= sizeof (".debug_") - 1;
5474 || (do_debug_info
&& const_strneq (name
, "info"))
5475 || (do_debug_info
&& const_strneq (name
, "types"))
5476 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5477 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5478 || (do_debug_lines
&& const_strneq (name
, "line."))
5479 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5480 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5481 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5482 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5483 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5484 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5485 || (do_debug_frames
&& const_strneq (name
, "frame"))
5486 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5487 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5488 || (do_debug_str
&& const_strneq (name
, "str"))
5489 || (do_debug_loc
&& const_strneq (name
, "loc"))
5490 || (do_debug_addr
&& const_strneq (name
, "addr"))
5491 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5492 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5494 request_dump_bynumber (i
, DEBUG_DUMP
);
5496 /* Linkonce section to be combined with .debug_info at link time. */
5497 else if ((do_debugging
|| do_debug_info
)
5498 && const_strneq (name
, ".gnu.linkonce.wi."))
5499 request_dump_bynumber (i
, DEBUG_DUMP
);
5500 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5501 request_dump_bynumber (i
, DEBUG_DUMP
);
5502 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5503 request_dump_bynumber (i
, DEBUG_DUMP
);
5504 /* Trace sections for Itanium VMS. */
5505 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5506 || do_trace_aranges
)
5507 && const_strneq (name
, ".trace_"))
5509 name
+= sizeof (".trace_") - 1;
5512 || (do_trace_info
&& streq (name
, "info"))
5513 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5514 || (do_trace_aranges
&& streq (name
, "aranges"))
5516 request_dump_bynumber (i
, DEBUG_DUMP
);
5523 if (elf_header
.e_shnum
> 1)
5524 printf (_("\nSection Headers:\n"));
5526 printf (_("\nSection Header:\n"));
5530 if (do_section_details
)
5532 printf (_(" [Nr] Name\n"));
5533 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5537 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5541 if (do_section_details
)
5543 printf (_(" [Nr] Name\n"));
5544 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5548 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5552 if (do_section_details
)
5554 printf (_(" [Nr] Name\n"));
5555 printf (_(" Type Address Offset Link\n"));
5556 printf (_(" Size EntSize Info Align\n"));
5560 printf (_(" [Nr] Name Type Address Offset\n"));
5561 printf (_(" Size EntSize Flags Link Info Align\n"));
5565 if (do_section_details
)
5566 printf (_(" Flags\n"));
5568 for (i
= 0, section
= section_headers
;
5569 i
< elf_header
.e_shnum
;
5572 printf (" [%2u] ", i
);
5573 if (do_section_details
)
5574 printf ("%s\n ", printable_section_name (section
));
5576 print_symbol (-17, SECTION_NAME (section
));
5578 printf (do_wide
? " %-15s " : " %-15.15s ",
5579 get_section_type_name (section
->sh_type
));
5583 const char * link_too_big
= NULL
;
5585 print_vma (section
->sh_addr
, LONG_HEX
);
5587 printf ( " %6.6lx %6.6lx %2.2lx",
5588 (unsigned long) section
->sh_offset
,
5589 (unsigned long) section
->sh_size
,
5590 (unsigned long) section
->sh_entsize
);
5592 if (do_section_details
)
5593 fputs (" ", stdout
);
5595 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5597 if (section
->sh_link
>= elf_header
.e_shnum
)
5600 /* The sh_link value is out of range. Normally this indicates
5601 an error but it can have special values in Solaris binaries. */
5602 switch (elf_header
.e_machine
)
5609 case EM_OLD_SPARCV9
:
5610 case EM_SPARC32PLUS
:
5613 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5614 link_too_big
= "BEFORE";
5615 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5616 link_too_big
= "AFTER";
5623 if (do_section_details
)
5625 if (link_too_big
!= NULL
&& * link_too_big
)
5626 printf ("<%s> ", link_too_big
);
5628 printf ("%2u ", section
->sh_link
);
5629 printf ("%3u %2lu\n", section
->sh_info
,
5630 (unsigned long) section
->sh_addralign
);
5633 printf ("%2u %3u %2lu\n",
5636 (unsigned long) section
->sh_addralign
);
5638 if (link_too_big
&& ! * link_too_big
)
5639 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5640 i
, section
->sh_link
);
5644 print_vma (section
->sh_addr
, LONG_HEX
);
5646 if ((long) section
->sh_offset
== section
->sh_offset
)
5647 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5651 print_vma (section
->sh_offset
, LONG_HEX
);
5654 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5655 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5659 print_vma (section
->sh_size
, LONG_HEX
);
5662 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5663 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5667 print_vma (section
->sh_entsize
, LONG_HEX
);
5670 if (do_section_details
)
5671 fputs (" ", stdout
);
5673 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5675 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5677 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5678 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5681 print_vma (section
->sh_addralign
, DEC
);
5685 else if (do_section_details
)
5687 printf (" %-15.15s ",
5688 get_section_type_name (section
->sh_type
));
5689 print_vma (section
->sh_addr
, LONG_HEX
);
5690 if ((long) section
->sh_offset
== section
->sh_offset
)
5691 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5695 print_vma (section
->sh_offset
, LONG_HEX
);
5697 printf (" %u\n ", section
->sh_link
);
5698 print_vma (section
->sh_size
, LONG_HEX
);
5700 print_vma (section
->sh_entsize
, LONG_HEX
);
5702 printf (" %-16u %lu\n",
5704 (unsigned long) section
->sh_addralign
);
5709 print_vma (section
->sh_addr
, LONG_HEX
);
5710 if ((long) section
->sh_offset
== section
->sh_offset
)
5711 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5715 print_vma (section
->sh_offset
, LONG_HEX
);
5718 print_vma (section
->sh_size
, LONG_HEX
);
5720 print_vma (section
->sh_entsize
, LONG_HEX
);
5722 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5724 printf (" %2u %3u %lu\n",
5727 (unsigned long) section
->sh_addralign
);
5730 if (do_section_details
)
5731 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5734 if (!do_section_details
)
5736 if (elf_header
.e_machine
== EM_X86_64
5737 || elf_header
.e_machine
== EM_L1OM
5738 || elf_header
.e_machine
== EM_K1OM
)
5739 printf (_("Key to Flags:\n\
5740 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5741 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5742 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5744 printf (_("Key to Flags:\n\
5745 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5746 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5747 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5754 get_group_flags (unsigned int flags
)
5756 static char buff
[32];
5766 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5773 process_section_groups (FILE * file
)
5775 Elf_Internal_Shdr
* section
;
5777 struct group
* group
;
5778 Elf_Internal_Shdr
* symtab_sec
;
5779 Elf_Internal_Shdr
* strtab_sec
;
5780 Elf_Internal_Sym
* symtab
;
5781 unsigned long num_syms
;
5785 /* Don't process section groups unless needed. */
5786 if (!do_unwind
&& !do_section_groups
)
5789 if (elf_header
.e_shnum
== 0)
5791 if (do_section_groups
)
5792 printf (_("\nThere are no sections to group in this file.\n"));
5797 if (section_headers
== NULL
)
5799 error (_("Section headers are not available!\n"));
5800 /* PR 13622: This can happen with a corrupt ELF header. */
5804 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5805 sizeof (struct group
*));
5807 if (section_headers_groups
== NULL
)
5809 error (_("Out of memory reading %u section group headers\n"),
5810 elf_header
.e_shnum
);
5814 /* Scan the sections for the group section. */
5816 for (i
= 0, section
= section_headers
;
5817 i
< elf_header
.e_shnum
;
5819 if (section
->sh_type
== SHT_GROUP
)
5822 if (group_count
== 0)
5824 if (do_section_groups
)
5825 printf (_("\nThere are no section groups in this file.\n"));
5830 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5832 if (section_groups
== NULL
)
5834 error (_("Out of memory reading %lu groups\n"),
5835 (unsigned long) group_count
);
5845 for (i
= 0, section
= section_headers
, group
= section_groups
;
5846 i
< elf_header
.e_shnum
;
5849 if (section
->sh_type
== SHT_GROUP
)
5851 const char * name
= printable_section_name (section
);
5852 const char * group_name
;
5853 unsigned char * start
;
5854 unsigned char * indices
;
5855 unsigned int entry
, j
, size
;
5856 Elf_Internal_Shdr
* sec
;
5857 Elf_Internal_Sym
* sym
;
5859 /* Get the symbol table. */
5860 if (section
->sh_link
>= elf_header
.e_shnum
5861 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5864 error (_("Bad sh_link in group section `%s'\n"), name
);
5868 if (symtab_sec
!= sec
)
5873 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5878 error (_("Corrupt header in group section `%s'\n"), name
);
5882 if (section
->sh_info
>= num_syms
)
5884 error (_("Bad sh_info in group section `%s'\n"), name
);
5888 sym
= symtab
+ section
->sh_info
;
5890 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5892 if (sym
->st_shndx
== 0
5893 || sym
->st_shndx
>= elf_header
.e_shnum
)
5895 error (_("Bad sh_info in group section `%s'\n"), name
);
5899 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5908 /* Get the string table. */
5909 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5918 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5924 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5925 1, strtab_sec
->sh_size
,
5927 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5929 group_name
= sym
->st_name
< strtab_size
5930 ? strtab
+ sym
->st_name
: _("<corrupt>");
5933 /* PR 17531: file: loop. */
5934 if (section
->sh_entsize
> section
->sh_size
)
5936 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5937 printable_section_name (section
),
5938 (unsigned long) section
->sh_entsize
,
5939 (unsigned long) section
->sh_size
);
5943 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5944 1, section
->sh_size
,
5950 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5951 entry
= byte_get (indices
, 4);
5954 if (do_section_groups
)
5956 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5957 get_group_flags (entry
), i
, name
, group_name
, size
);
5959 printf (_(" [Index] Name\n"));
5962 group
->group_index
= i
;
5964 for (j
= 0; j
< size
; j
++)
5966 struct group_list
* g
;
5968 entry
= byte_get (indices
, 4);
5971 if (entry
>= elf_header
.e_shnum
)
5973 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5974 entry
, i
, elf_header
.e_shnum
- 1);
5978 if (section_headers_groups
[entry
] != NULL
)
5982 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5984 section_headers_groups
[entry
]->group_index
);
5989 /* Intel C/C++ compiler may put section 0 in a
5990 section group. We just warn it the first time
5991 and ignore it afterwards. */
5992 static int warned
= 0;
5995 error (_("section 0 in group section [%5u]\n"),
5996 section_headers_groups
[entry
]->group_index
);
6002 section_headers_groups
[entry
] = group
;
6004 if (do_section_groups
)
6006 sec
= section_headers
+ entry
;
6007 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6010 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6011 g
->section_index
= entry
;
6012 g
->next
= group
->root
;
6030 /* Data used to display dynamic fixups. */
6032 struct ia64_vms_dynfixup
6034 bfd_vma needed_ident
; /* Library ident number. */
6035 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6036 bfd_vma fixup_needed
; /* Index of the library. */
6037 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6038 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6041 /* Data used to display dynamic relocations. */
6043 struct ia64_vms_dynimgrela
6045 bfd_vma img_rela_cnt
; /* Number of relocations. */
6046 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6049 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6053 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6054 const char *strtab
, unsigned int strtab_sz
)
6056 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6058 const char *lib_name
;
6060 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6061 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6062 _("dynamic section image fixups"));
6066 if (fixup
->needed
< strtab_sz
)
6067 lib_name
= strtab
+ fixup
->needed
;
6070 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6071 (unsigned long) fixup
->needed
);
6074 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6075 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6077 (_("Seg Offset Type SymVec DataType\n"));
6079 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6084 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6085 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6086 type
= BYTE_GET (imfs
[i
].type
);
6087 rtype
= elf_ia64_reloc_type (type
);
6089 printf (" 0x%08x ", type
);
6091 printf (" %-32s ", rtype
);
6092 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6093 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6099 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6102 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6104 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6107 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6108 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6109 _("dynamic section image relocations"));
6113 printf (_("\nImage relocs\n"));
6115 (_("Seg Offset Type Addend Seg Sym Off\n"));
6117 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6122 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6123 printf ("%08" BFD_VMA_FMT
"x ",
6124 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6125 type
= BYTE_GET (imrs
[i
].type
);
6126 rtype
= elf_ia64_reloc_type (type
);
6128 printf ("0x%08x ", type
);
6130 printf ("%-31s ", rtype
);
6131 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6132 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6133 printf ("%08" BFD_VMA_FMT
"x\n",
6134 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6140 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6143 process_ia64_vms_dynamic_relocs (FILE *file
)
6145 struct ia64_vms_dynfixup fixup
;
6146 struct ia64_vms_dynimgrela imgrela
;
6147 Elf_Internal_Dyn
*entry
;
6149 bfd_vma strtab_off
= 0;
6150 bfd_vma strtab_sz
= 0;
6151 char *strtab
= NULL
;
6153 memset (&fixup
, 0, sizeof (fixup
));
6154 memset (&imgrela
, 0, sizeof (imgrela
));
6156 /* Note: the order of the entries is specified by the OpenVMS specs. */
6157 for (entry
= dynamic_section
;
6158 entry
< dynamic_section
+ dynamic_nent
;
6161 switch (entry
->d_tag
)
6163 case DT_IA_64_VMS_STRTAB_OFFSET
:
6164 strtab_off
= entry
->d_un
.d_val
;
6167 strtab_sz
= entry
->d_un
.d_val
;
6169 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6170 1, strtab_sz
, _("dynamic string section"));
6173 case DT_IA_64_VMS_NEEDED_IDENT
:
6174 fixup
.needed_ident
= entry
->d_un
.d_val
;
6177 fixup
.needed
= entry
->d_un
.d_val
;
6179 case DT_IA_64_VMS_FIXUP_NEEDED
:
6180 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6182 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6183 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6185 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6186 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6188 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6191 case DT_IA_64_VMS_IMG_RELA_CNT
:
6192 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6194 case DT_IA_64_VMS_IMG_RELA_OFF
:
6195 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6197 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6217 } dynamic_relocations
[] =
6219 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6220 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6221 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6224 /* Process the reloc section. */
6227 process_relocs (FILE * file
)
6229 unsigned long rel_size
;
6230 unsigned long rel_offset
;
6236 if (do_using_dynamic
)
6240 int has_dynamic_reloc
;
6243 has_dynamic_reloc
= 0;
6245 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6247 is_rela
= dynamic_relocations
[i
].rela
;
6248 name
= dynamic_relocations
[i
].name
;
6249 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6250 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6252 has_dynamic_reloc
|= rel_size
;
6254 if (is_rela
== UNKNOWN
)
6256 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6257 switch (dynamic_info
[DT_PLTREL
])
6271 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6272 name
, rel_offset
, rel_size
);
6274 dump_relocations (file
,
6275 offset_from_vma (file
, rel_offset
, rel_size
),
6277 dynamic_symbols
, num_dynamic_syms
,
6278 dynamic_strings
, dynamic_strings_length
,
6284 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6286 if (! has_dynamic_reloc
)
6287 printf (_("\nThere are no dynamic relocations in this file.\n"));
6291 Elf_Internal_Shdr
* section
;
6295 for (i
= 0, section
= section_headers
;
6296 i
< elf_header
.e_shnum
;
6299 if ( section
->sh_type
!= SHT_RELA
6300 && section
->sh_type
!= SHT_REL
)
6303 rel_offset
= section
->sh_offset
;
6304 rel_size
= section
->sh_size
;
6308 Elf_Internal_Shdr
* strsec
;
6311 printf (_("\nRelocation section "));
6313 if (string_table
== NULL
)
6314 printf ("%d", section
->sh_name
);
6316 printf ("'%s'", printable_section_name (section
));
6318 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6319 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6321 is_rela
= section
->sh_type
== SHT_RELA
;
6323 if (section
->sh_link
!= 0
6324 && section
->sh_link
< elf_header
.e_shnum
)
6326 Elf_Internal_Shdr
* symsec
;
6327 Elf_Internal_Sym
* symtab
;
6328 unsigned long nsyms
;
6329 unsigned long strtablen
= 0;
6330 char * strtab
= NULL
;
6332 symsec
= section_headers
+ section
->sh_link
;
6333 if (symsec
->sh_type
!= SHT_SYMTAB
6334 && symsec
->sh_type
!= SHT_DYNSYM
)
6337 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6342 if (symsec
->sh_link
!= 0
6343 && symsec
->sh_link
< elf_header
.e_shnum
)
6345 strsec
= section_headers
+ symsec
->sh_link
;
6347 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6350 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6353 dump_relocations (file
, rel_offset
, rel_size
,
6354 symtab
, nsyms
, strtab
, strtablen
,
6356 symsec
->sh_type
== SHT_DYNSYM
);
6362 dump_relocations (file
, rel_offset
, rel_size
,
6363 NULL
, 0, NULL
, 0, is_rela
, 0);
6370 printf (_("\nThere are no relocations in this file.\n"));
6376 /* Process the unwind section. */
6378 #include "unwind-ia64.h"
6380 /* An absolute address consists of a section and an offset. If the
6381 section is NULL, the offset itself is the address, otherwise, the
6382 address equals to LOAD_ADDRESS(section) + offset. */
6386 unsigned short section
;
6390 #define ABSADDR(a) \
6392 ? section_headers [(a).section].sh_addr + (a).offset \
6395 struct ia64_unw_table_entry
6397 struct absaddr start
;
6399 struct absaddr info
;
6402 struct ia64_unw_aux_info
6405 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6406 unsigned long table_len
; /* Length of unwind table. */
6407 unsigned char * info
; /* Unwind info. */
6408 unsigned long info_size
; /* Size of unwind info. */
6409 bfd_vma info_addr
; /* starting address of unwind info. */
6410 bfd_vma seg_base
; /* Starting address of segment. */
6411 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6412 unsigned long nsyms
; /* Number of symbols. */
6413 char * strtab
; /* The string table. */
6414 unsigned long strtab_size
; /* Size of string table. */
6418 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6419 unsigned long nsyms
,
6420 const char * strtab
,
6421 unsigned long strtab_size
,
6422 struct absaddr addr
,
6423 const char ** symname
,
6426 bfd_vma dist
= 0x100000;
6427 Elf_Internal_Sym
* sym
;
6428 Elf_Internal_Sym
* best
= NULL
;
6431 REMOVE_ARCH_BITS (addr
.offset
);
6433 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6435 bfd_vma value
= sym
->st_value
;
6437 REMOVE_ARCH_BITS (value
);
6439 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6440 && sym
->st_name
!= 0
6441 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6442 && addr
.offset
>= value
6443 && addr
.offset
- value
< dist
)
6446 dist
= addr
.offset
- value
;
6454 *symname
= (best
->st_name
>= strtab_size
6455 ? _("<corrupt>") : strtab
+ best
->st_name
);
6461 *offset
= addr
.offset
;
6465 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6467 struct ia64_unw_table_entry
* tp
;
6470 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6474 const unsigned char * dp
;
6475 const unsigned char * head
;
6476 const char * procname
;
6478 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6479 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6481 fputs ("\n<", stdout
);
6485 fputs (procname
, stdout
);
6488 printf ("+%lx", (unsigned long) offset
);
6491 fputs (">: [", stdout
);
6492 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6493 fputc ('-', stdout
);
6494 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6495 printf ("], info at +0x%lx\n",
6496 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6498 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6499 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6501 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6502 (unsigned) UNW_VER (stamp
),
6503 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6504 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6505 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6506 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6508 if (UNW_VER (stamp
) != 1)
6510 printf (_("\tUnknown version.\n"));
6515 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6516 dp
= unw_decode (dp
, in_body
, & in_body
);
6521 slurp_ia64_unwind_table (FILE * file
,
6522 struct ia64_unw_aux_info
* aux
,
6523 Elf_Internal_Shdr
* sec
)
6525 unsigned long size
, nrelas
, i
;
6526 Elf_Internal_Phdr
* seg
;
6527 struct ia64_unw_table_entry
* tep
;
6528 Elf_Internal_Shdr
* relsec
;
6529 Elf_Internal_Rela
* rela
;
6530 Elf_Internal_Rela
* rp
;
6531 unsigned char * table
;
6533 Elf_Internal_Sym
* sym
;
6534 const char * relname
;
6536 /* First, find the starting address of the segment that includes
6539 if (elf_header
.e_phnum
)
6541 if (! get_program_headers (file
))
6544 for (seg
= program_headers
;
6545 seg
< program_headers
+ elf_header
.e_phnum
;
6548 if (seg
->p_type
!= PT_LOAD
)
6551 if (sec
->sh_addr
>= seg
->p_vaddr
6552 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6554 aux
->seg_base
= seg
->p_vaddr
;
6560 /* Second, build the unwind table from the contents of the unwind section: */
6561 size
= sec
->sh_size
;
6562 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6567 aux
->table
= (struct ia64_unw_table_entry
*)
6568 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6570 for (tp
= table
; tp
< table
+ size
; ++tep
)
6572 tep
->start
.section
= SHN_UNDEF
;
6573 tep
->end
.section
= SHN_UNDEF
;
6574 tep
->info
.section
= SHN_UNDEF
;
6575 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6576 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6577 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6578 tep
->start
.offset
+= aux
->seg_base
;
6579 tep
->end
.offset
+= aux
->seg_base
;
6580 tep
->info
.offset
+= aux
->seg_base
;
6584 /* Third, apply any relocations to the unwind table: */
6585 for (relsec
= section_headers
;
6586 relsec
< section_headers
+ elf_header
.e_shnum
;
6589 if (relsec
->sh_type
!= SHT_RELA
6590 || relsec
->sh_info
>= elf_header
.e_shnum
6591 || section_headers
+ relsec
->sh_info
!= sec
)
6594 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6598 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6600 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6601 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6603 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6605 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6609 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6611 switch (rp
->r_offset
/eh_addr_size
% 3)
6614 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6615 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6618 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6619 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6622 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6623 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6633 aux
->table_len
= size
/ (3 * eh_addr_size
);
6638 ia64_process_unwind (FILE * file
)
6640 Elf_Internal_Shdr
* sec
;
6641 Elf_Internal_Shdr
* unwsec
= NULL
;
6642 Elf_Internal_Shdr
* strsec
;
6643 unsigned long i
, unwcount
= 0, unwstart
= 0;
6644 struct ia64_unw_aux_info aux
;
6646 memset (& aux
, 0, sizeof (aux
));
6648 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6650 if (sec
->sh_type
== SHT_SYMTAB
6651 && sec
->sh_link
< elf_header
.e_shnum
)
6653 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6655 strsec
= section_headers
+ sec
->sh_link
;
6656 if (aux
.strtab
!= NULL
)
6658 error (_("Multiple auxillary string tables encountered\n"));
6661 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6664 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6666 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6671 printf (_("\nThere are no unwind sections in this file.\n"));
6673 while (unwcount
-- > 0)
6678 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6679 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6680 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6685 /* We have already counted the number of SHT_IA64_UNWIND
6686 sections so the loop above should never fail. */
6687 assert (unwsec
!= NULL
);
6690 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6692 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6694 /* We need to find which section group it is in. */
6695 struct group_list
* g
;
6697 if (section_headers_groups
== NULL
6698 || section_headers_groups
[i
] == NULL
)
6699 i
= elf_header
.e_shnum
;
6702 g
= section_headers_groups
[i
]->root
;
6704 for (; g
!= NULL
; g
= g
->next
)
6706 sec
= section_headers
+ g
->section_index
;
6708 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6713 i
= elf_header
.e_shnum
;
6716 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6718 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6719 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6720 suffix
= SECTION_NAME (unwsec
) + len
;
6721 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6723 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6724 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6729 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6730 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6731 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6732 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6734 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6735 suffix
= SECTION_NAME (unwsec
) + len
;
6736 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6738 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6739 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6743 if (i
== elf_header
.e_shnum
)
6745 printf (_("\nCould not find unwind info section for "));
6747 if (string_table
== NULL
)
6748 printf ("%d", unwsec
->sh_name
);
6750 printf ("'%s'", printable_section_name (unwsec
));
6754 aux
.info_addr
= sec
->sh_addr
;
6755 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6758 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6760 printf (_("\nUnwind section "));
6762 if (string_table
== NULL
)
6763 printf ("%d", unwsec
->sh_name
);
6765 printf ("'%s'", printable_section_name (unwsec
));
6767 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6768 (unsigned long) unwsec
->sh_offset
,
6769 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6771 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6773 if (aux
.table_len
> 0)
6774 dump_ia64_unwind (& aux
);
6777 free ((char *) aux
.table
);
6779 free ((char *) aux
.info
);
6788 free ((char *) aux
.strtab
);
6791 struct hppa_unw_table_entry
6793 struct absaddr start
;
6795 unsigned int Cannot_unwind
:1; /* 0 */
6796 unsigned int Millicode
:1; /* 1 */
6797 unsigned int Millicode_save_sr0
:1; /* 2 */
6798 unsigned int Region_description
:2; /* 3..4 */
6799 unsigned int reserved1
:1; /* 5 */
6800 unsigned int Entry_SR
:1; /* 6 */
6801 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6802 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6803 unsigned int Args_stored
:1; /* 16 */
6804 unsigned int Variable_Frame
:1; /* 17 */
6805 unsigned int Separate_Package_Body
:1; /* 18 */
6806 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6807 unsigned int Stack_Overflow_Check
:1; /* 20 */
6808 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6809 unsigned int Ada_Region
:1; /* 22 */
6810 unsigned int cxx_info
:1; /* 23 */
6811 unsigned int cxx_try_catch
:1; /* 24 */
6812 unsigned int sched_entry_seq
:1; /* 25 */
6813 unsigned int reserved2
:1; /* 26 */
6814 unsigned int Save_SP
:1; /* 27 */
6815 unsigned int Save_RP
:1; /* 28 */
6816 unsigned int Save_MRP_in_frame
:1; /* 29 */
6817 unsigned int extn_ptr_defined
:1; /* 30 */
6818 unsigned int Cleanup_defined
:1; /* 31 */
6820 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6821 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6822 unsigned int Large_frame
:1; /* 2 */
6823 unsigned int Pseudo_SP_Set
:1; /* 3 */
6824 unsigned int reserved4
:1; /* 4 */
6825 unsigned int Total_frame_size
:27; /* 5..31 */
6828 struct hppa_unw_aux_info
6830 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6831 unsigned long table_len
; /* Length of unwind table. */
6832 bfd_vma seg_base
; /* Starting address of segment. */
6833 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6834 unsigned long nsyms
; /* Number of symbols. */
6835 char * strtab
; /* The string table. */
6836 unsigned long strtab_size
; /* Size of string table. */
6840 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6842 struct hppa_unw_table_entry
* tp
;
6844 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6847 const char * procname
;
6849 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6850 aux
->strtab_size
, tp
->start
, &procname
,
6853 fputs ("\n<", stdout
);
6857 fputs (procname
, stdout
);
6860 printf ("+%lx", (unsigned long) offset
);
6863 fputs (">: [", stdout
);
6864 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6865 fputc ('-', stdout
);
6866 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6869 #define PF(_m) if (tp->_m) printf (#_m " ");
6870 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6873 PF(Millicode_save_sr0
);
6874 /* PV(Region_description); */
6880 PF(Separate_Package_Body
);
6881 PF(Frame_Extension_Millicode
);
6882 PF(Stack_Overflow_Check
);
6883 PF(Two_Instruction_SP_Increment
);
6887 PF(sched_entry_seq
);
6890 PF(Save_MRP_in_frame
);
6891 PF(extn_ptr_defined
);
6892 PF(Cleanup_defined
);
6893 PF(MPE_XL_interrupt_marker
);
6894 PF(HP_UX_interrupt_marker
);
6897 PV(Total_frame_size
);
6906 slurp_hppa_unwind_table (FILE * file
,
6907 struct hppa_unw_aux_info
* aux
,
6908 Elf_Internal_Shdr
* sec
)
6910 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6911 Elf_Internal_Phdr
* seg
;
6912 struct hppa_unw_table_entry
* tep
;
6913 Elf_Internal_Shdr
* relsec
;
6914 Elf_Internal_Rela
* rela
;
6915 Elf_Internal_Rela
* rp
;
6916 unsigned char * table
;
6918 Elf_Internal_Sym
* sym
;
6919 const char * relname
;
6921 /* First, find the starting address of the segment that includes
6924 if (elf_header
.e_phnum
)
6926 if (! get_program_headers (file
))
6929 for (seg
= program_headers
;
6930 seg
< program_headers
+ elf_header
.e_phnum
;
6933 if (seg
->p_type
!= PT_LOAD
)
6936 if (sec
->sh_addr
>= seg
->p_vaddr
6937 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6939 aux
->seg_base
= seg
->p_vaddr
;
6945 /* Second, build the unwind table from the contents of the unwind
6947 size
= sec
->sh_size
;
6948 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6954 nentries
= size
/ unw_ent_size
;
6955 size
= unw_ent_size
* nentries
;
6957 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6958 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6960 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6962 unsigned int tmp1
, tmp2
;
6964 tep
->start
.section
= SHN_UNDEF
;
6965 tep
->end
.section
= SHN_UNDEF
;
6967 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6968 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6969 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6970 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6972 tep
->start
.offset
+= aux
->seg_base
;
6973 tep
->end
.offset
+= aux
->seg_base
;
6975 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6976 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6977 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6978 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6979 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6980 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6981 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6982 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6983 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6984 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6985 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6986 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6987 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6988 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6989 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6990 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6991 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6992 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6993 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6994 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6995 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6996 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6997 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6998 tep
->Cleanup_defined
= tmp1
& 0x1;
7000 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7001 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7002 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7003 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7004 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7005 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7009 /* Third, apply any relocations to the unwind table. */
7010 for (relsec
= section_headers
;
7011 relsec
< section_headers
+ elf_header
.e_shnum
;
7014 if (relsec
->sh_type
!= SHT_RELA
7015 || relsec
->sh_info
>= elf_header
.e_shnum
7016 || section_headers
+ relsec
->sh_info
!= sec
)
7019 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7023 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7025 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7026 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7028 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7029 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7031 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7035 i
= rp
->r_offset
/ unw_ent_size
;
7037 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7040 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7041 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7044 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7045 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7055 aux
->table_len
= nentries
;
7061 hppa_process_unwind (FILE * file
)
7063 struct hppa_unw_aux_info aux
;
7064 Elf_Internal_Shdr
* unwsec
= NULL
;
7065 Elf_Internal_Shdr
* strsec
;
7066 Elf_Internal_Shdr
* sec
;
7069 if (string_table
== NULL
)
7072 memset (& aux
, 0, sizeof (aux
));
7074 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7076 if (sec
->sh_type
== SHT_SYMTAB
7077 && sec
->sh_link
< elf_header
.e_shnum
)
7079 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7081 strsec
= section_headers
+ sec
->sh_link
;
7082 if (aux
.strtab
!= NULL
)
7084 error (_("Multiple auxillary string tables encountered\n"));
7087 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7090 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7092 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7097 printf (_("\nThere are no unwind sections in this file.\n"));
7099 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7101 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7103 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7104 printable_section_name (sec
),
7105 (unsigned long) sec
->sh_offset
,
7106 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7108 slurp_hppa_unwind_table (file
, &aux
, sec
);
7109 if (aux
.table_len
> 0)
7110 dump_hppa_unwind (&aux
);
7113 free ((char *) aux
.table
);
7121 free ((char *) aux
.strtab
);
7126 unsigned char * data
; /* The unwind data. */
7127 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7128 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7129 unsigned long nrelas
; /* The number of relocations. */
7130 unsigned int rel_type
; /* REL or RELA ? */
7131 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7134 struct arm_unw_aux_info
7136 FILE * file
; /* The file containing the unwind sections. */
7137 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7138 unsigned long nsyms
; /* Number of symbols. */
7139 char * strtab
; /* The file's string table. */
7140 unsigned long strtab_size
; /* Size of string table. */
7144 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7145 bfd_vma fn
, struct absaddr addr
)
7147 const char *procname
;
7150 if (addr
.section
== SHN_UNDEF
)
7153 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
7154 aux
->strtab_size
, addr
, &procname
,
7157 print_vma (fn
, PREFIX_HEX
);
7161 fputs (" <", stdout
);
7162 fputs (procname
, stdout
);
7165 printf ("+0x%lx", (unsigned long) sym_offset
);
7166 fputc ('>', stdout
);
7173 arm_free_section (struct arm_section
*arm_sec
)
7175 if (arm_sec
->data
!= NULL
)
7176 free (arm_sec
->data
);
7178 if (arm_sec
->rela
!= NULL
)
7179 free (arm_sec
->rela
);
7182 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7183 cached section and install SEC instead.
7184 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7185 and return its valued in * WORDP, relocating if necessary.
7186 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7187 relocation's offset in ADDR.
7188 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7189 into the string table of the symbol associated with the reloc. If no
7190 reloc was applied store -1 there.
7191 5) Return TRUE upon success, FALSE otherwise. */
7194 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7195 struct arm_section
* arm_sec
,
7196 Elf_Internal_Shdr
* sec
,
7197 bfd_vma word_offset
,
7198 unsigned int * wordp
,
7199 struct absaddr
* addr
,
7202 Elf_Internal_Rela
*rp
;
7203 Elf_Internal_Sym
*sym
;
7204 const char * relname
;
7206 bfd_boolean wrapped
;
7208 if (sec
== NULL
|| arm_sec
== NULL
)
7211 addr
->section
= SHN_UNDEF
;
7214 if (sym_name
!= NULL
)
7215 *sym_name
= (bfd_vma
) -1;
7217 /* If necessary, update the section cache. */
7218 if (sec
!= arm_sec
->sec
)
7220 Elf_Internal_Shdr
*relsec
;
7222 arm_free_section (arm_sec
);
7225 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7226 sec
->sh_size
, _("unwind data"));
7227 arm_sec
->rela
= NULL
;
7228 arm_sec
->nrelas
= 0;
7230 for (relsec
= section_headers
;
7231 relsec
< section_headers
+ elf_header
.e_shnum
;
7234 if (relsec
->sh_info
>= elf_header
.e_shnum
7235 || section_headers
+ relsec
->sh_info
!= sec
7236 /* PR 15745: Check the section type as well. */
7237 || (relsec
->sh_type
!= SHT_REL
7238 && relsec
->sh_type
!= SHT_RELA
))
7241 arm_sec
->rel_type
= relsec
->sh_type
;
7242 if (relsec
->sh_type
== SHT_REL
)
7244 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7246 & arm_sec
->rela
, & arm_sec
->nrelas
))
7249 else /* relsec->sh_type == SHT_RELA */
7251 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7253 & arm_sec
->rela
, & arm_sec
->nrelas
))
7259 arm_sec
->next_rela
= arm_sec
->rela
;
7262 /* If there is no unwind data we can do nothing. */
7263 if (arm_sec
->data
== NULL
)
7266 /* If the offset is invalid then fail. */
7267 if (word_offset
> sec
->sh_size
- 4)
7270 /* Get the word at the required offset. */
7271 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7273 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7274 if (arm_sec
->rela
== NULL
)
7280 /* Look through the relocs to find the one that applies to the provided offset. */
7282 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7284 bfd_vma prelval
, offset
;
7286 if (rp
->r_offset
> word_offset
&& !wrapped
)
7291 if (rp
->r_offset
> word_offset
)
7294 if (rp
->r_offset
& 3)
7296 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7297 (unsigned long) rp
->r_offset
);
7301 if (rp
->r_offset
< word_offset
)
7304 /* PR 17531: file: 027-161405-0.004 */
7305 if (aux
->symtab
== NULL
)
7308 if (arm_sec
->rel_type
== SHT_REL
)
7310 offset
= word
& 0x7fffffff;
7311 if (offset
& 0x40000000)
7312 offset
|= ~ (bfd_vma
) 0x7fffffff;
7314 else if (arm_sec
->rel_type
== SHT_RELA
)
7315 offset
= rp
->r_addend
;
7318 error (_("Unknown section relocation type %d encountered\n"),
7323 /* PR 17531 file: 027-1241568-0.004. */
7324 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7326 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7327 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7331 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7332 offset
+= sym
->st_value
;
7333 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7335 /* Check that we are processing the expected reloc type. */
7336 if (elf_header
.e_machine
== EM_ARM
)
7338 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7339 if (relname
== NULL
)
7341 warn (_("Skipping unknown ARM relocation type: %d\n"),
7342 (int) ELF32_R_TYPE (rp
->r_info
));
7346 if (streq (relname
, "R_ARM_NONE"))
7349 if (! streq (relname
, "R_ARM_PREL31"))
7351 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7355 else if (elf_header
.e_machine
== EM_TI_C6000
)
7357 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7358 if (relname
== NULL
)
7360 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7361 (int) ELF32_R_TYPE (rp
->r_info
));
7365 if (streq (relname
, "R_C6000_NONE"))
7368 if (! streq (relname
, "R_C6000_PREL31"))
7370 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7378 /* This function currently only supports ARM and TI unwinders. */
7379 warn (_("Only TI and ARM unwinders are currently supported\n"));
7383 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7384 addr
->section
= sym
->st_shndx
;
7385 addr
->offset
= offset
;
7388 * sym_name
= sym
->st_name
;
7393 arm_sec
->next_rela
= rp
;
7398 static const char *tic6x_unwind_regnames
[16] =
7400 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7401 "A14", "A13", "A12", "A11", "A10",
7402 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7406 decode_tic6x_unwind_regmask (unsigned int mask
)
7410 for (i
= 12; mask
; mask
>>= 1, i
--)
7414 fputs (tic6x_unwind_regnames
[i
], stdout
);
7416 fputs (", ", stdout
);
7422 if (remaining == 0 && more_words) \
7425 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7426 data_offset, & word, & addr, NULL)) \
7432 #define GET_OP(OP) \
7437 (OP) = word >> 24; \
7442 printf (_("[Truncated opcode]\n")); \
7445 printf ("0x%02x ", OP)
7448 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7449 unsigned int word
, unsigned int remaining
,
7450 unsigned int more_words
,
7451 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7452 struct arm_section
*data_arm_sec
)
7454 struct absaddr addr
;
7456 /* Decode the unwinding instructions. */
7459 unsigned int op
, op2
;
7468 printf (" 0x%02x ", op
);
7470 if ((op
& 0xc0) == 0x00)
7472 int offset
= ((op
& 0x3f) << 2) + 4;
7474 printf (" vsp = vsp + %d", offset
);
7476 else if ((op
& 0xc0) == 0x40)
7478 int offset
= ((op
& 0x3f) << 2) + 4;
7480 printf (" vsp = vsp - %d", offset
);
7482 else if ((op
& 0xf0) == 0x80)
7485 if (op
== 0x80 && op2
== 0)
7486 printf (_("Refuse to unwind"));
7489 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7494 for (i
= 0; i
< 12; i
++)
7495 if (mask
& (1 << i
))
7501 printf ("r%d", 4 + i
);
7506 else if ((op
& 0xf0) == 0x90)
7508 if (op
== 0x9d || op
== 0x9f)
7509 printf (_(" [Reserved]"));
7511 printf (" vsp = r%d", op
& 0x0f);
7513 else if ((op
& 0xf0) == 0xa0)
7515 int end
= 4 + (op
& 0x07);
7520 for (i
= 4; i
<= end
; i
++)
7536 else if (op
== 0xb0)
7537 printf (_(" finish"));
7538 else if (op
== 0xb1)
7541 if (op2
== 0 || (op2
& 0xf0) != 0)
7542 printf (_("[Spare]"));
7545 unsigned int mask
= op2
& 0x0f;
7550 for (i
= 0; i
< 12; i
++)
7551 if (mask
& (1 << i
))
7562 else if (op
== 0xb2)
7564 unsigned char buf
[9];
7565 unsigned int i
, len
;
7566 unsigned long offset
;
7568 for (i
= 0; i
< sizeof (buf
); i
++)
7571 if ((buf
[i
] & 0x80) == 0)
7574 if (i
== sizeof (buf
))
7575 printf (_("corrupt change to vsp"));
7578 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7579 assert (len
== i
+ 1);
7580 offset
= offset
* 4 + 0x204;
7581 printf ("vsp = vsp + %ld", offset
);
7584 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7586 unsigned int first
, last
;
7593 printf ("pop {D%d", first
);
7595 printf ("-D%d", first
+ last
);
7598 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7600 unsigned int count
= op
& 0x07;
7604 printf ("-D%d", 8 + count
);
7607 else if (op
>= 0xc0 && op
<= 0xc5)
7609 unsigned int count
= op
& 0x07;
7611 printf (" pop {wR10");
7613 printf ("-wR%d", 10 + count
);
7616 else if (op
== 0xc6)
7618 unsigned int first
, last
;
7623 printf ("pop {wR%d", first
);
7625 printf ("-wR%d", first
+ last
);
7628 else if (op
== 0xc7)
7631 if (op2
== 0 || (op2
& 0xf0) != 0)
7632 printf (_("[Spare]"));
7635 unsigned int mask
= op2
& 0x0f;
7640 for (i
= 0; i
< 4; i
++)
7641 if (mask
& (1 << i
))
7647 printf ("wCGR%d", i
);
7653 printf (_(" [unsupported opcode]"));
7659 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7660 unsigned int word
, unsigned int remaining
,
7661 unsigned int more_words
,
7662 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7663 struct arm_section
*data_arm_sec
)
7665 struct absaddr addr
;
7667 /* Decode the unwinding instructions. */
7670 unsigned int op
, op2
;
7679 printf (" 0x%02x ", op
);
7681 if ((op
& 0xc0) == 0x00)
7683 int offset
= ((op
& 0x3f) << 3) + 8;
7684 printf (" sp = sp + %d", offset
);
7686 else if ((op
& 0xc0) == 0x80)
7689 if (op
== 0x80 && op2
== 0)
7690 printf (_("Refuse to unwind"));
7693 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7695 printf ("pop compact {");
7699 decode_tic6x_unwind_regmask (mask
);
7703 else if ((op
& 0xf0) == 0xc0)
7711 unsigned int offset
;
7715 /* Scan entire instruction first so that GET_OP output is not
7716 interleaved with disassembly. */
7718 for (i
= 0; nregs
< (op
& 0xf); i
++)
7724 regpos
[nregs
].offset
= i
* 2;
7725 regpos
[nregs
].reg
= reg
;
7732 regpos
[nregs
].offset
= i
* 2 + 1;
7733 regpos
[nregs
].reg
= reg
;
7738 printf (_("pop frame {"));
7740 for (i
= i
* 2; i
> 0; i
--)
7742 if (regpos
[reg
].offset
== i
- 1)
7744 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7751 fputs (name
, stdout
);
7758 else if (op
== 0xd0)
7759 printf (" MOV FP, SP");
7760 else if (op
== 0xd1)
7761 printf (" __c6xabi_pop_rts");
7762 else if (op
== 0xd2)
7764 unsigned char buf
[9];
7765 unsigned int i
, len
;
7766 unsigned long offset
;
7768 for (i
= 0; i
< sizeof (buf
); i
++)
7771 if ((buf
[i
] & 0x80) == 0)
7774 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7775 if (i
== sizeof (buf
))
7777 printf ("<corrupt sp adjust>\n");
7778 warn (_("Corrupt stack pointer adjustment detected\n"));
7782 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7783 assert (len
== i
+ 1);
7784 offset
= offset
* 8 + 0x408;
7785 printf (_("sp = sp + %ld"), offset
);
7787 else if ((op
& 0xf0) == 0xe0)
7789 if ((op
& 0x0f) == 7)
7792 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7796 printf (_(" [unsupported opcode]"));
7803 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7807 offset
= word
& 0x7fffffff;
7808 if (offset
& 0x40000000)
7809 offset
|= ~ (bfd_vma
) 0x7fffffff;
7811 if (elf_header
.e_machine
== EM_TI_C6000
)
7814 return offset
+ where
;
7818 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7820 unsigned int remaining
,
7821 bfd_vma data_offset
,
7822 Elf_Internal_Shdr
* data_sec
,
7823 struct arm_section
* data_arm_sec
)
7826 unsigned int more_words
= 0;
7827 struct absaddr addr
;
7828 bfd_vma sym_name
= (bfd_vma
) -1;
7832 /* Fetch the first word.
7833 Note - when decoding an object file the address extracted
7834 here will always be 0. So we also pass in the sym_name
7835 parameter so that we can find the symbol associated with
7836 the personality routine. */
7837 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7838 & word
, & addr
, & sym_name
))
7844 if ((word
& 0x80000000) == 0)
7846 /* Expand prel31 for personality routine. */
7848 const char *procname
;
7850 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7851 printf (_(" Personality routine: "));
7853 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7854 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7856 procname
= aux
->strtab
+ sym_name
;
7857 print_vma (fn
, PREFIX_HEX
);
7860 fputs (" <", stdout
);
7861 fputs (procname
, stdout
);
7862 fputc ('>', stdout
);
7866 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7867 fputc ('\n', stdout
);
7869 /* The GCC personality routines use the standard compact
7870 encoding, starting with one byte giving the number of
7872 if (procname
!= NULL
7873 && (const_strneq (procname
, "__gcc_personality_v0")
7874 || const_strneq (procname
, "__gxx_personality_v0")
7875 || const_strneq (procname
, "__gcj_personality_v0")
7876 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7883 printf (_(" [Truncated data]\n"));
7886 more_words
= word
>> 24;
7896 /* ARM EHABI Section 6.3:
7898 An exception-handling table entry for the compact model looks like:
7902 1 0 index Data for personalityRoutine[index] */
7904 if (elf_header
.e_machine
== EM_ARM
7905 && (word
& 0x70000000))
7906 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7908 per_index
= (word
>> 24) & 0x7f;
7909 printf (_(" Compact model index: %d\n"), per_index
);
7916 else if (per_index
< 3)
7918 more_words
= (word
>> 16) & 0xff;
7924 switch (elf_header
.e_machine
)
7929 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7930 data_offset
, data_sec
, data_arm_sec
);
7934 warn (_("Unknown ARM compact model index encountered\n"));
7935 printf (_(" [reserved]\n"));
7942 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7943 data_offset
, data_sec
, data_arm_sec
);
7945 else if (per_index
< 5)
7947 if (((word
>> 17) & 0x7f) == 0x7f)
7948 printf (_(" Restore stack from frame pointer\n"));
7950 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7951 printf (_(" Registers restored: "));
7953 printf (" (compact) ");
7954 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7956 printf (_(" Return register: %s\n"),
7957 tic6x_unwind_regnames
[word
& 0xf]);
7960 printf (_(" [reserved (%d)]\n"), per_index
);
7964 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7965 elf_header
.e_machine
);
7968 /* Decode the descriptors. Not implemented. */
7972 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7974 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7975 unsigned int i
, exidx_len
;
7977 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7978 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7979 exidx_len
= exidx_sec
->sh_size
/ 8;
7981 for (i
= 0; i
< exidx_len
; i
++)
7983 unsigned int exidx_fn
, exidx_entry
;
7984 struct absaddr fn_addr
, entry_addr
;
7987 fputc ('\n', stdout
);
7989 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7990 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7991 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7992 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7994 arm_free_section (& exidx_arm_sec
);
7995 arm_free_section (& extab_arm_sec
);
7999 /* ARM EHABI, Section 5:
8000 An index table entry consists of 2 words.
8001 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8002 if (exidx_fn
& 0x80000000)
8003 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8005 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8007 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8008 fputs (": ", stdout
);
8010 if (exidx_entry
== 1)
8012 print_vma (exidx_entry
, PREFIX_HEX
);
8013 fputs (" [cantunwind]\n", stdout
);
8015 else if (exidx_entry
& 0x80000000)
8017 print_vma (exidx_entry
, PREFIX_HEX
);
8018 fputc ('\n', stdout
);
8019 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8023 bfd_vma table
, table_offset
= 0;
8024 Elf_Internal_Shdr
*table_sec
;
8026 fputs ("@", stdout
);
8027 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8028 print_vma (table
, PREFIX_HEX
);
8031 /* Locate the matching .ARM.extab. */
8032 if (entry_addr
.section
!= SHN_UNDEF
8033 && entry_addr
.section
< elf_header
.e_shnum
)
8035 table_sec
= section_headers
+ entry_addr
.section
;
8036 table_offset
= entry_addr
.offset
;
8040 table_sec
= find_section_by_address (table
);
8041 if (table_sec
!= NULL
)
8042 table_offset
= table
- table_sec
->sh_addr
;
8044 if (table_sec
== NULL
)
8046 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8047 (unsigned long) table
);
8050 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8057 arm_free_section (&exidx_arm_sec
);
8058 arm_free_section (&extab_arm_sec
);
8061 /* Used for both ARM and C6X unwinding tables. */
8064 arm_process_unwind (FILE *file
)
8066 struct arm_unw_aux_info aux
;
8067 Elf_Internal_Shdr
*unwsec
= NULL
;
8068 Elf_Internal_Shdr
*strsec
;
8069 Elf_Internal_Shdr
*sec
;
8071 unsigned int sec_type
;
8073 switch (elf_header
.e_machine
)
8076 sec_type
= SHT_ARM_EXIDX
;
8080 sec_type
= SHT_C6000_UNWIND
;
8084 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8085 elf_header
.e_machine
);
8089 if (string_table
== NULL
)
8092 memset (& aux
, 0, sizeof (aux
));
8095 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8097 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8099 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8101 strsec
= section_headers
+ sec
->sh_link
;
8103 /* PR binutils/17531 file: 011-12666-0.004. */
8104 if (aux
.strtab
!= NULL
)
8106 error (_("Multiple string tables found in file.\n"));
8109 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8110 1, strsec
->sh_size
, _("string table"));
8111 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8113 else if (sec
->sh_type
== sec_type
)
8118 printf (_("\nThere are no unwind sections in this file.\n"));
8120 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8122 if (sec
->sh_type
== sec_type
)
8124 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8125 printable_section_name (sec
),
8126 (unsigned long) sec
->sh_offset
,
8127 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8129 dump_arm_unwind (&aux
, sec
);
8136 free ((char *) aux
.strtab
);
8140 process_unwind (FILE * file
)
8142 struct unwind_handler
8145 void (* handler
)(FILE *);
8148 { EM_ARM
, arm_process_unwind
},
8149 { EM_IA_64
, ia64_process_unwind
},
8150 { EM_PARISC
, hppa_process_unwind
},
8151 { EM_TI_C6000
, arm_process_unwind
},
8159 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8160 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8162 handlers
[i
].handler (file
);
8166 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8167 get_machine_name (elf_header
.e_machine
));
8171 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8173 switch (entry
->d_tag
)
8176 if (entry
->d_un
.d_val
== 0)
8180 static const char * opts
[] =
8182 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8183 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8184 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8185 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8191 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8192 if (entry
->d_un
.d_val
& (1 << cnt
))
8194 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8200 case DT_MIPS_IVERSION
:
8201 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8202 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8206 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8207 /* Note: coded this way so that there is a single string for translation. */
8208 printf (_("<corrupt: %s>"), buf
);
8212 case DT_MIPS_TIME_STAMP
:
8217 time_t atime
= entry
->d_un
.d_val
;
8218 tmp
= gmtime (&atime
);
8219 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8220 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8221 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8222 printf (_("Time Stamp: %s"), timebuf
);
8226 case DT_MIPS_RLD_VERSION
:
8227 case DT_MIPS_LOCAL_GOTNO
:
8228 case DT_MIPS_CONFLICTNO
:
8229 case DT_MIPS_LIBLISTNO
:
8230 case DT_MIPS_SYMTABNO
:
8231 case DT_MIPS_UNREFEXTNO
:
8232 case DT_MIPS_HIPAGENO
:
8233 case DT_MIPS_DELTA_CLASS_NO
:
8234 case DT_MIPS_DELTA_INSTANCE_NO
:
8235 case DT_MIPS_DELTA_RELOC_NO
:
8236 case DT_MIPS_DELTA_SYM_NO
:
8237 case DT_MIPS_DELTA_CLASSSYM_NO
:
8238 case DT_MIPS_COMPACT_SIZE
:
8239 print_vma (entry
->d_un
.d_ptr
, DEC
);
8243 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8249 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8251 switch (entry
->d_tag
)
8253 case DT_HP_DLD_FLAGS
:
8262 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8263 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8264 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8265 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8266 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8267 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8268 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8269 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8270 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8271 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8272 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8273 { DT_HP_GST
, "HP_GST" },
8274 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8275 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8276 { DT_HP_NODELETE
, "HP_NODELETE" },
8277 { DT_HP_GROUP
, "HP_GROUP" },
8278 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8282 bfd_vma val
= entry
->d_un
.d_val
;
8284 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8285 if (val
& flags
[cnt
].bit
)
8289 fputs (flags
[cnt
].str
, stdout
);
8291 val
^= flags
[cnt
].bit
;
8294 if (val
!= 0 || first
)
8298 print_vma (val
, HEX
);
8304 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8312 /* VMS vs Unix time offset and factor. */
8314 #define VMS_EPOCH_OFFSET 35067168000000000LL
8315 #define VMS_GRANULARITY_FACTOR 10000000
8317 /* Display a VMS time in a human readable format. */
8320 print_vms_time (bfd_int64_t vmstime
)
8325 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8326 tm
= gmtime (&unxtime
);
8327 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8328 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8329 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8334 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8336 switch (entry
->d_tag
)
8338 case DT_IA_64_PLT_RESERVE
:
8339 /* First 3 slots reserved. */
8340 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8342 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8345 case DT_IA_64_VMS_LINKTIME
:
8347 print_vms_time (entry
->d_un
.d_val
);
8351 case DT_IA_64_VMS_LNKFLAGS
:
8352 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8353 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8354 printf (" CALL_DEBUG");
8355 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8356 printf (" NOP0BUFS");
8357 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8358 printf (" P0IMAGE");
8359 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8360 printf (" MKTHREADS");
8361 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8362 printf (" UPCALLS");
8363 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8365 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8366 printf (" INITIALIZE");
8367 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8369 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8370 printf (" EXE_INIT");
8371 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8372 printf (" TBK_IN_IMG");
8373 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8374 printf (" DBG_IN_IMG");
8375 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8376 printf (" TBK_IN_DSF");
8377 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8378 printf (" DBG_IN_DSF");
8379 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8380 printf (" SIGNATURES");
8381 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8382 printf (" REL_SEG_OFF");
8386 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8393 get_32bit_dynamic_section (FILE * file
)
8395 Elf32_External_Dyn
* edyn
;
8396 Elf32_External_Dyn
* ext
;
8397 Elf_Internal_Dyn
* entry
;
8399 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8400 dynamic_size
, _("dynamic section"));
8404 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8405 might not have the luxury of section headers. Look for the DT_NULL
8406 terminator to determine the number of entries. */
8407 for (ext
= edyn
, dynamic_nent
= 0;
8408 (char *) ext
< (char *) edyn
+ dynamic_size
- sizeof (* entry
);
8412 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8416 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8418 if (dynamic_section
== NULL
)
8420 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8421 (unsigned long) dynamic_nent
);
8426 for (ext
= edyn
, entry
= dynamic_section
;
8427 entry
< dynamic_section
+ dynamic_nent
;
8430 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8431 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8440 get_64bit_dynamic_section (FILE * file
)
8442 Elf64_External_Dyn
* edyn
;
8443 Elf64_External_Dyn
* ext
;
8444 Elf_Internal_Dyn
* entry
;
8446 /* Read in the data. */
8447 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8448 dynamic_size
, _("dynamic section"));
8452 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8453 might not have the luxury of section headers. Look for the DT_NULL
8454 terminator to determine the number of entries. */
8455 for (ext
= edyn
, dynamic_nent
= 0;
8456 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8457 (char *) ext
< ((char *) edyn
) + dynamic_size
- sizeof (* ext
);
8461 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8465 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8467 if (dynamic_section
== NULL
)
8469 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8470 (unsigned long) dynamic_nent
);
8475 /* Convert from external to internal formats. */
8476 for (ext
= edyn
, entry
= dynamic_section
;
8477 entry
< dynamic_section
+ dynamic_nent
;
8480 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8481 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8490 print_dynamic_flags (bfd_vma flags
)
8498 flag
= flags
& - flags
;
8508 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8509 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8510 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8511 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8512 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8513 default: fputs (_("unknown"), stdout
); break;
8519 /* Parse and display the contents of the dynamic section. */
8522 process_dynamic_section (FILE * file
)
8524 Elf_Internal_Dyn
* entry
;
8526 if (dynamic_size
== 0)
8529 printf (_("\nThere is no dynamic section in this file.\n"));
8536 if (! get_32bit_dynamic_section (file
))
8539 else if (! get_64bit_dynamic_section (file
))
8542 /* Find the appropriate symbol table. */
8543 if (dynamic_symbols
== NULL
)
8545 for (entry
= dynamic_section
;
8546 entry
< dynamic_section
+ dynamic_nent
;
8549 Elf_Internal_Shdr section
;
8551 if (entry
->d_tag
!= DT_SYMTAB
)
8554 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8556 /* Since we do not know how big the symbol table is,
8557 we default to reading in the entire file (!) and
8558 processing that. This is overkill, I know, but it
8560 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8562 if (archive_file_offset
!= 0)
8563 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8566 if (fseek (file
, 0, SEEK_END
))
8567 error (_("Unable to seek to end of file!\n"));
8569 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8573 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8575 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8576 section
.sh_name
= string_table_length
;
8578 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8579 if (num_dynamic_syms
< 1)
8581 error (_("Unable to determine the number of symbols to load\n"));
8587 /* Similarly find a string table. */
8588 if (dynamic_strings
== NULL
)
8590 for (entry
= dynamic_section
;
8591 entry
< dynamic_section
+ dynamic_nent
;
8594 unsigned long offset
;
8597 if (entry
->d_tag
!= DT_STRTAB
)
8600 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8602 /* Since we do not know how big the string table is,
8603 we default to reading in the entire file (!) and
8604 processing that. This is overkill, I know, but it
8607 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8609 if (archive_file_offset
!= 0)
8610 str_tab_len
= archive_file_size
- offset
;
8613 if (fseek (file
, 0, SEEK_END
))
8614 error (_("Unable to seek to end of file\n"));
8615 str_tab_len
= ftell (file
) - offset
;
8618 if (str_tab_len
< 1)
8621 (_("Unable to determine the length of the dynamic string table\n"));
8625 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8627 _("dynamic string table"));
8628 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8633 /* And find the syminfo section if available. */
8634 if (dynamic_syminfo
== NULL
)
8636 unsigned long syminsz
= 0;
8638 for (entry
= dynamic_section
;
8639 entry
< dynamic_section
+ dynamic_nent
;
8642 if (entry
->d_tag
== DT_SYMINENT
)
8644 /* Note: these braces are necessary to avoid a syntax
8645 error from the SunOS4 C compiler. */
8646 /* PR binutils/17531: A corrupt file can trigger this test.
8647 So do not use an assert, instead generate an error message. */
8648 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8649 error (_("Bad value (%d) for SYMINENT entry\n"),
8650 (int) entry
->d_un
.d_val
);
8652 else if (entry
->d_tag
== DT_SYMINSZ
)
8653 syminsz
= entry
->d_un
.d_val
;
8654 else if (entry
->d_tag
== DT_SYMINFO
)
8655 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8659 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8661 Elf_External_Syminfo
* extsyminfo
;
8662 Elf_External_Syminfo
* extsym
;
8663 Elf_Internal_Syminfo
* syminfo
;
8665 /* There is a syminfo section. Read the data. */
8666 extsyminfo
= (Elf_External_Syminfo
*)
8667 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8668 _("symbol information"));
8672 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8673 if (dynamic_syminfo
== NULL
)
8675 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8676 (unsigned long) syminsz
);
8680 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8681 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8682 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8683 ++syminfo
, ++extsym
)
8685 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8686 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8693 if (do_dynamic
&& dynamic_addr
)
8694 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8695 dynamic_addr
, (unsigned long) dynamic_nent
);
8697 printf (_(" Tag Type Name/Value\n"));
8699 for (entry
= dynamic_section
;
8700 entry
< dynamic_section
+ dynamic_nent
;
8708 print_vma (entry
->d_tag
, FULL_HEX
);
8709 dtype
= get_dynamic_type (entry
->d_tag
);
8710 printf (" (%s)%*s", dtype
,
8711 ((is_32bit_elf
? 27 : 19)
8712 - (int) strlen (dtype
)),
8716 switch (entry
->d_tag
)
8720 print_dynamic_flags (entry
->d_un
.d_val
);
8730 switch (entry
->d_tag
)
8733 printf (_("Auxiliary library"));
8737 printf (_("Filter library"));
8741 printf (_("Configuration file"));
8745 printf (_("Dependency audit library"));
8749 printf (_("Audit library"));
8753 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8754 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8758 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8767 printf (_("Flags:"));
8769 if (entry
->d_un
.d_val
== 0)
8770 printf (_(" None\n"));
8773 unsigned long int val
= entry
->d_un
.d_val
;
8775 if (val
& DTF_1_PARINIT
)
8777 printf (" PARINIT");
8778 val
^= DTF_1_PARINIT
;
8780 if (val
& DTF_1_CONFEXP
)
8782 printf (" CONFEXP");
8783 val
^= DTF_1_CONFEXP
;
8786 printf (" %lx", val
);
8795 printf (_("Flags:"));
8797 if (entry
->d_un
.d_val
== 0)
8798 printf (_(" None\n"));
8801 unsigned long int val
= entry
->d_un
.d_val
;
8803 if (val
& DF_P1_LAZYLOAD
)
8805 printf (" LAZYLOAD");
8806 val
^= DF_P1_LAZYLOAD
;
8808 if (val
& DF_P1_GROUPPERM
)
8810 printf (" GROUPPERM");
8811 val
^= DF_P1_GROUPPERM
;
8814 printf (" %lx", val
);
8823 printf (_("Flags:"));
8824 if (entry
->d_un
.d_val
== 0)
8825 printf (_(" None\n"));
8828 unsigned long int val
= entry
->d_un
.d_val
;
8835 if (val
& DF_1_GLOBAL
)
8840 if (val
& DF_1_GROUP
)
8845 if (val
& DF_1_NODELETE
)
8847 printf (" NODELETE");
8848 val
^= DF_1_NODELETE
;
8850 if (val
& DF_1_LOADFLTR
)
8852 printf (" LOADFLTR");
8853 val
^= DF_1_LOADFLTR
;
8855 if (val
& DF_1_INITFIRST
)
8857 printf (" INITFIRST");
8858 val
^= DF_1_INITFIRST
;
8860 if (val
& DF_1_NOOPEN
)
8865 if (val
& DF_1_ORIGIN
)
8870 if (val
& DF_1_DIRECT
)
8875 if (val
& DF_1_TRANS
)
8880 if (val
& DF_1_INTERPOSE
)
8882 printf (" INTERPOSE");
8883 val
^= DF_1_INTERPOSE
;
8885 if (val
& DF_1_NODEFLIB
)
8887 printf (" NODEFLIB");
8888 val
^= DF_1_NODEFLIB
;
8890 if (val
& DF_1_NODUMP
)
8895 if (val
& DF_1_CONFALT
)
8897 printf (" CONFALT");
8898 val
^= DF_1_CONFALT
;
8900 if (val
& DF_1_ENDFILTEE
)
8902 printf (" ENDFILTEE");
8903 val
^= DF_1_ENDFILTEE
;
8905 if (val
& DF_1_DISPRELDNE
)
8907 printf (" DISPRELDNE");
8908 val
^= DF_1_DISPRELDNE
;
8910 if (val
& DF_1_DISPRELPND
)
8912 printf (" DISPRELPND");
8913 val
^= DF_1_DISPRELPND
;
8915 if (val
& DF_1_NODIRECT
)
8917 printf (" NODIRECT");
8918 val
^= DF_1_NODIRECT
;
8920 if (val
& DF_1_IGNMULDEF
)
8922 printf (" IGNMULDEF");
8923 val
^= DF_1_IGNMULDEF
;
8925 if (val
& DF_1_NOKSYMS
)
8927 printf (" NOKSYMS");
8928 val
^= DF_1_NOKSYMS
;
8930 if (val
& DF_1_NOHDR
)
8935 if (val
& DF_1_EDITED
)
8940 if (val
& DF_1_NORELOC
)
8942 printf (" NORELOC");
8943 val
^= DF_1_NORELOC
;
8945 if (val
& DF_1_SYMINTPOSE
)
8947 printf (" SYMINTPOSE");
8948 val
^= DF_1_SYMINTPOSE
;
8950 if (val
& DF_1_GLOBAUDIT
)
8952 printf (" GLOBAUDIT");
8953 val
^= DF_1_GLOBAUDIT
;
8955 if (val
& DF_1_SINGLETON
)
8957 printf (" SINGLETON");
8958 val
^= DF_1_SINGLETON
;
8961 printf (" %lx", val
);
8968 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8970 puts (get_dynamic_type (entry
->d_un
.d_val
));
8990 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8996 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8997 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9003 switch (entry
->d_tag
)
9006 printf (_("Shared library: [%s]"), name
);
9008 if (streq (name
, program_interpreter
))
9009 printf (_(" program interpreter"));
9013 printf (_("Library soname: [%s]"), name
);
9017 printf (_("Library rpath: [%s]"), name
);
9021 printf (_("Library runpath: [%s]"), name
);
9025 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9030 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9043 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9047 case DT_INIT_ARRAYSZ
:
9048 case DT_FINI_ARRAYSZ
:
9049 case DT_GNU_CONFLICTSZ
:
9050 case DT_GNU_LIBLISTSZ
:
9053 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9054 printf (_(" (bytes)\n"));
9064 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9077 if (entry
->d_tag
== DT_USED
9078 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9080 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9084 printf (_("Not needed object: [%s]\n"), name
);
9089 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9095 /* The value of this entry is ignored. */
9100 case DT_GNU_PRELINKED
:
9104 time_t atime
= entry
->d_un
.d_val
;
9106 tmp
= gmtime (&atime
);
9107 /* PR 17533 file: 041-1244816-0.004. */
9109 printf (_("<corrupt time val: %lx"),
9110 (unsigned long) atime
);
9112 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9113 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9114 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9120 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9123 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9129 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9130 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9135 switch (elf_header
.e_machine
)
9138 case EM_MIPS_RS3_LE
:
9139 dynamic_section_mips_val (entry
);
9142 dynamic_section_parisc_val (entry
);
9145 dynamic_section_ia64_val (entry
);
9148 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9160 get_ver_flags (unsigned int flags
)
9162 static char buff
[32];
9169 if (flags
& VER_FLG_BASE
)
9170 strcat (buff
, "BASE ");
9172 if (flags
& VER_FLG_WEAK
)
9174 if (flags
& VER_FLG_BASE
)
9175 strcat (buff
, "| ");
9177 strcat (buff
, "WEAK ");
9180 if (flags
& VER_FLG_INFO
)
9182 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9183 strcat (buff
, "| ");
9185 strcat (buff
, "INFO ");
9188 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9189 strcat (buff
, _("| <unknown>"));
9194 /* Display the contents of the version sections. */
9197 process_version_sections (FILE * file
)
9199 Elf_Internal_Shdr
* section
;
9206 for (i
= 0, section
= section_headers
;
9207 i
< elf_header
.e_shnum
;
9210 switch (section
->sh_type
)
9212 case SHT_GNU_verdef
:
9214 Elf_External_Verdef
* edefs
;
9221 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9222 printable_section_name (section
),
9225 printf (_(" Addr: 0x"));
9226 printf_vma (section
->sh_addr
);
9227 printf (_(" Offset: %#08lx Link: %u (%s)"),
9228 (unsigned long) section
->sh_offset
, section
->sh_link
,
9229 printable_section_name_from_index (section
->sh_link
));
9231 edefs
= (Elf_External_Verdef
*)
9232 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9233 _("version definition section"));
9236 endbuf
= (char *) edefs
+ section
->sh_size
;
9238 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9241 Elf_External_Verdef
* edef
;
9242 Elf_Internal_Verdef ent
;
9243 Elf_External_Verdaux
* eaux
;
9244 Elf_Internal_Verdaux aux
;
9248 /* Check for very large indicies. */
9249 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9252 vstart
= ((char *) edefs
) + idx
;
9253 if (vstart
+ sizeof (*edef
) > endbuf
)
9256 edef
= (Elf_External_Verdef
*) vstart
;
9258 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9259 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9260 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9261 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9262 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9263 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9264 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9266 printf (_(" %#06x: Rev: %d Flags: %s"),
9267 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9269 printf (_(" Index: %d Cnt: %d "),
9270 ent
.vd_ndx
, ent
.vd_cnt
);
9272 /* Check for overflow. */
9273 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9276 vstart
+= ent
.vd_aux
;
9278 eaux
= (Elf_External_Verdaux
*) vstart
;
9280 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9281 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9283 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9284 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9286 printf (_("Name index: %ld\n"), aux
.vda_name
);
9288 isum
= idx
+ ent
.vd_aux
;
9290 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9292 /* Check for overflow. */
9293 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9296 isum
+= aux
.vda_next
;
9297 vstart
+= aux
.vda_next
;
9299 eaux
= (Elf_External_Verdaux
*) vstart
;
9300 if (vstart
+ sizeof (*eaux
) > endbuf
)
9303 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9304 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9306 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9307 printf (_(" %#06x: Parent %d: %s\n"),
9308 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9310 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9311 isum
, j
, aux
.vda_name
);
9315 printf (_(" Version def aux past end of section\n"));
9317 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9318 if (idx
+ ent
.vd_next
<= idx
)
9324 if (cnt
< section
->sh_info
)
9325 printf (_(" Version definition past end of section\n"));
9331 case SHT_GNU_verneed
:
9333 Elf_External_Verneed
* eneed
;
9340 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9341 printable_section_name (section
), section
->sh_info
);
9343 printf (_(" Addr: 0x"));
9344 printf_vma (section
->sh_addr
);
9345 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9346 (unsigned long) section
->sh_offset
, section
->sh_link
,
9347 printable_section_name_from_index (section
->sh_link
));
9349 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9350 section
->sh_offset
, 1,
9352 _("Version Needs section"));
9355 endbuf
= (char *) eneed
+ section
->sh_size
;
9357 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9359 Elf_External_Verneed
* entry
;
9360 Elf_Internal_Verneed ent
;
9365 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9368 vstart
= ((char *) eneed
) + idx
;
9369 if (vstart
+ sizeof (*entry
) > endbuf
)
9372 entry
= (Elf_External_Verneed
*) vstart
;
9374 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9375 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9376 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9377 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9378 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9380 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9382 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9383 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9385 printf (_(" File: %lx"), ent
.vn_file
);
9387 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9389 /* Check for overflow. */
9390 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9393 vstart
+= ent
.vn_aux
;
9395 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9397 Elf_External_Vernaux
* eaux
;
9398 Elf_Internal_Vernaux aux
;
9400 if (vstart
+ sizeof (*eaux
) > endbuf
)
9402 eaux
= (Elf_External_Vernaux
*) vstart
;
9404 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9405 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9406 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9407 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9408 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9410 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9411 printf (_(" %#06x: Name: %s"),
9412 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9414 printf (_(" %#06x: Name index: %lx"),
9415 isum
, aux
.vna_name
);
9417 printf (_(" Flags: %s Version: %d\n"),
9418 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9420 /* Check for overflow. */
9421 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9424 isum
+= aux
.vna_next
;
9425 vstart
+= aux
.vna_next
;
9429 warn (_("Missing Version Needs auxillary information\n"));
9431 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9433 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9434 cnt
= section
->sh_info
;
9440 if (cnt
< section
->sh_info
)
9441 warn (_("Missing Version Needs information\n"));
9447 case SHT_GNU_versym
:
9449 Elf_Internal_Shdr
* link_section
;
9452 unsigned char * edata
;
9453 unsigned short * data
;
9455 Elf_Internal_Sym
* symbols
;
9456 Elf_Internal_Shdr
* string_sec
;
9457 unsigned long num_syms
;
9460 if (section
->sh_link
>= elf_header
.e_shnum
)
9463 link_section
= section_headers
+ section
->sh_link
;
9464 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9466 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9471 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9472 if (symbols
== NULL
)
9475 string_sec
= section_headers
+ link_section
->sh_link
;
9477 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9478 string_sec
->sh_size
,
9479 _("version string table"));
9486 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9487 printable_section_name (section
), (unsigned long) total
);
9489 printf (_(" Addr: "));
9490 printf_vma (section
->sh_addr
);
9491 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9492 (unsigned long) section
->sh_offset
, section
->sh_link
,
9493 printable_section_name (link_section
));
9495 off
= offset_from_vma (file
,
9496 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9497 total
* sizeof (short));
9498 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9500 _("version symbol data"));
9508 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9510 for (cnt
= total
; cnt
--;)
9511 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9516 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9519 int check_def
, check_need
;
9522 printf (" %03x:", cnt
);
9524 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9525 switch (data
[cnt
+ j
])
9528 fputs (_(" 0 (*local*) "), stdout
);
9532 fputs (_(" 1 (*global*) "), stdout
);
9536 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9537 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9539 /* If this index value is greater than the size of the symbols
9540 array, break to avoid an out-of-bounds read. */
9541 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9543 warn (_("invalid index into symbol array\n"));
9549 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9550 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9553 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9560 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9562 Elf_Internal_Verneed ivn
;
9563 unsigned long offset
;
9565 offset
= offset_from_vma
9566 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9567 sizeof (Elf_External_Verneed
));
9571 Elf_Internal_Vernaux ivna
;
9572 Elf_External_Verneed evn
;
9573 Elf_External_Vernaux evna
;
9574 unsigned long a_off
;
9576 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9577 _("version need")) == NULL
)
9580 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9581 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9583 a_off
= offset
+ ivn
.vn_aux
;
9587 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9588 1, _("version need aux (2)")) == NULL
)
9595 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9596 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9599 a_off
+= ivna
.vna_next
;
9601 while (ivna
.vna_other
!= data
[cnt
+ j
]
9602 && ivna
.vna_next
!= 0);
9604 if (ivna
.vna_other
== data
[cnt
+ j
])
9606 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9608 if (ivna
.vna_name
>= string_sec
->sh_size
)
9609 name
= _("*invalid*");
9611 name
= strtab
+ ivna
.vna_name
;
9612 nn
+= printf ("(%s%-*s",
9614 12 - (int) strlen (name
),
9620 offset
+= ivn
.vn_next
;
9622 while (ivn
.vn_next
);
9625 if (check_def
&& data
[cnt
+ j
] != 0x8001
9626 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9628 Elf_Internal_Verdef ivd
;
9629 Elf_External_Verdef evd
;
9630 unsigned long offset
;
9632 offset
= offset_from_vma
9633 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9638 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9639 _("version def")) == NULL
)
9642 /* PR 17531: file: 046-1082287-0.004. */
9643 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
9648 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9649 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9652 offset
+= ivd
.vd_next
;
9654 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9655 && ivd
.vd_next
!= 0);
9657 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9659 Elf_External_Verdaux evda
;
9660 Elf_Internal_Verdaux ivda
;
9662 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9664 if (get_data (&evda
, file
,
9665 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9667 _("version def aux")) == NULL
)
9670 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9672 if (ivda
.vda_name
>= string_sec
->sh_size
)
9673 name
= _("*invalid*");
9675 name
= strtab
+ ivda
.vda_name
;
9676 nn
+= printf ("(%s%-*s",
9678 12 - (int) strlen (name
),
9684 printf ("%*c", 18 - nn
, ' ');
9702 printf (_("\nNo version information found in this file.\n"));
9708 get_symbol_binding (unsigned int binding
)
9710 static char buff
[32];
9714 case STB_LOCAL
: return "LOCAL";
9715 case STB_GLOBAL
: return "GLOBAL";
9716 case STB_WEAK
: return "WEAK";
9718 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9719 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9721 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9723 if (binding
== STB_GNU_UNIQUE
9724 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9725 /* GNU is still using the default value 0. */
9726 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9728 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9731 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9737 get_symbol_type (unsigned int type
)
9739 static char buff
[32];
9743 case STT_NOTYPE
: return "NOTYPE";
9744 case STT_OBJECT
: return "OBJECT";
9745 case STT_FUNC
: return "FUNC";
9746 case STT_SECTION
: return "SECTION";
9747 case STT_FILE
: return "FILE";
9748 case STT_COMMON
: return "COMMON";
9749 case STT_TLS
: return "TLS";
9750 case STT_RELC
: return "RELC";
9751 case STT_SRELC
: return "SRELC";
9753 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9755 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9756 return "THUMB_FUNC";
9758 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9761 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9762 return "PARISC_MILLI";
9764 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9766 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9768 if (elf_header
.e_machine
== EM_PARISC
)
9770 if (type
== STT_HP_OPAQUE
)
9772 if (type
== STT_HP_STUB
)
9776 if (type
== STT_GNU_IFUNC
9777 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9778 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9779 /* GNU is still using the default value 0. */
9780 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9783 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9786 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9792 get_symbol_visibility (unsigned int visibility
)
9796 case STV_DEFAULT
: return "DEFAULT";
9797 case STV_INTERNAL
: return "INTERNAL";
9798 case STV_HIDDEN
: return "HIDDEN";
9799 case STV_PROTECTED
: return "PROTECTED";
9801 error (_("Unrecognized visibility value: %u"), visibility
);
9802 return _("<unknown>");
9807 get_mips_symbol_other (unsigned int other
)
9819 case STO_MICROMIPS
| STO_MIPS_PIC
:
9820 return "MICROMIPS, MIPS PIC";
9829 get_ia64_symbol_other (unsigned int other
)
9833 static char res
[32];
9837 /* Function types is for images and .STB files only. */
9838 switch (elf_header
.e_type
)
9842 switch (VMS_ST_FUNC_TYPE (other
))
9844 case VMS_SFT_CODE_ADDR
:
9845 strcat (res
, " CA");
9847 case VMS_SFT_SYMV_IDX
:
9848 strcat (res
, " VEC");
9851 strcat (res
, " FD");
9853 case VMS_SFT_RESERVE
:
9854 strcat (res
, " RSV");
9857 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9858 VMS_ST_FUNC_TYPE (other
));
9859 strcat (res
, " <unknown>");
9866 switch (VMS_ST_LINKAGE (other
))
9868 case VMS_STL_IGNORE
:
9869 strcat (res
, " IGN");
9871 case VMS_STL_RESERVE
:
9872 strcat (res
, " RSV");
9875 strcat (res
, " STD");
9878 strcat (res
, " LNK");
9881 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9882 VMS_ST_LINKAGE (other
));
9883 strcat (res
, " <unknown>");
9896 get_ppc64_symbol_other (unsigned int other
)
9898 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9900 static char buf
[32];
9901 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9902 PPC64_LOCAL_ENTRY_OFFSET (other
));
9909 get_symbol_other (unsigned int other
)
9911 const char * result
= NULL
;
9912 static char buff
[32];
9917 switch (elf_header
.e_machine
)
9920 result
= get_mips_symbol_other (other
);
9923 result
= get_ia64_symbol_other (other
);
9926 result
= get_ppc64_symbol_other (other
);
9935 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9940 get_symbol_index_type (unsigned int type
)
9942 static char buff
[32];
9946 case SHN_UNDEF
: return "UND";
9947 case SHN_ABS
: return "ABS";
9948 case SHN_COMMON
: return "COM";
9950 if (type
== SHN_IA_64_ANSI_COMMON
9951 && elf_header
.e_machine
== EM_IA_64
9952 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9954 else if ((elf_header
.e_machine
== EM_X86_64
9955 || elf_header
.e_machine
== EM_L1OM
9956 || elf_header
.e_machine
== EM_K1OM
)
9957 && type
== SHN_X86_64_LCOMMON
)
9959 else if ((type
== SHN_MIPS_SCOMMON
9960 && elf_header
.e_machine
== EM_MIPS
)
9961 || (type
== SHN_TIC6X_SCOMMON
9962 && elf_header
.e_machine
== EM_TI_C6000
))
9964 else if (type
== SHN_MIPS_SUNDEFINED
9965 && elf_header
.e_machine
== EM_MIPS
)
9967 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9968 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9969 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9970 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9971 else if (type
>= SHN_LORESERVE
)
9972 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9973 else if (type
>= elf_header
.e_shnum
)
9974 sprintf (buff
, _("bad section index[%3d]"), type
);
9976 sprintf (buff
, "%3d", type
);
9984 get_dynamic_data (FILE * file
, size_t number
, unsigned int ent_size
)
9986 unsigned char * e_data
;
9989 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
9990 attempting to allocate memory when the read is bound to fail. */
9991 if (ent_size
* number
> current_file_size
)
9993 error (_("Invalid number of dynamic entries: %lu\n"),
9994 (unsigned long) number
);
9998 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
10001 error (_("Out of memory reading %lu dynamic entries\n"),
10002 (unsigned long) number
);
10006 if (fread (e_data
, ent_size
, number
, file
) != number
)
10008 error (_("Unable to read in %lu bytes of dynamic data\n"),
10009 (unsigned long) (number
* ent_size
));
10014 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
10015 if (i_data
== NULL
)
10017 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10018 (unsigned long) number
);
10024 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10032 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10034 Elf_Internal_Sym
* psym
;
10037 n
= print_vma (si
, DEC_5
);
10039 fputs (&" "[n
], stdout
);
10040 printf (" %3lu: ", hn
);
10042 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10044 printf (_("<No info available for dynamic symbol number %lu>\n"),
10045 (unsigned long) si
);
10049 psym
= dynamic_symbols
+ si
;
10050 print_vma (psym
->st_value
, LONG_HEX
);
10052 print_vma (psym
->st_size
, DEC_5
);
10054 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10055 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10056 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10057 /* Check to see if any other bits in the st_other field are set.
10058 Note - displaying this information disrupts the layout of the
10059 table being generated, but for the moment this case is very
10061 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10062 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10063 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10064 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10065 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10067 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10071 static const char *
10072 get_symbol_version_string (FILE *file
, int is_dynsym
,
10073 const char *strtab
,
10074 unsigned long int strtab_size
,
10075 unsigned int si
, Elf_Internal_Sym
*psym
,
10076 enum versioned_symbol_info
*sym_info
,
10077 unsigned short *vna_other
)
10079 const char *version_string
= NULL
;
10082 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10084 unsigned char data
[2];
10085 unsigned short vers_data
;
10086 unsigned long offset
;
10090 offset
= offset_from_vma
10091 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10092 sizeof data
+ si
* sizeof (vers_data
));
10094 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10095 sizeof (data
), 1, _("version data")) == NULL
)
10098 vers_data
= byte_get (data
, 2);
10100 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
10101 && section_headers
[psym
->st_shndx
].sh_type
10104 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10106 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10108 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10109 && (is_nobits
|| ! check_def
))
10111 Elf_External_Verneed evn
;
10112 Elf_Internal_Verneed ivn
;
10113 Elf_Internal_Vernaux ivna
;
10115 /* We must test both. */
10116 offset
= offset_from_vma
10117 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10122 unsigned long vna_off
;
10124 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10125 _("version need")) == NULL
)
10128 ivna
.vna_other
= 0;
10133 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10134 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10136 vna_off
= offset
+ ivn
.vn_aux
;
10140 Elf_External_Vernaux evna
;
10142 if (get_data (&evna
, file
, vna_off
,
10144 _("version need aux (3)")) == NULL
)
10147 ivna
.vna_other
= 0;
10152 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10153 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10154 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10157 vna_off
+= ivna
.vna_next
;
10159 while (ivna
.vna_other
!= vers_data
10160 && ivna
.vna_next
!= 0);
10162 if (ivna
.vna_other
== vers_data
)
10165 offset
+= ivn
.vn_next
;
10167 while (ivn
.vn_next
!= 0);
10169 if (ivna
.vna_other
== vers_data
)
10171 *sym_info
= symbol_undefined
;
10172 *vna_other
= ivna
.vna_other
;
10173 version_string
= (ivna
.vna_name
< strtab_size
10174 ? strtab
+ ivna
.vna_name
10178 else if (! is_nobits
)
10179 error (_("bad dynamic symbol\n"));
10186 if (vers_data
!= 0x8001
10187 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10189 Elf_Internal_Verdef ivd
;
10190 Elf_Internal_Verdaux ivda
;
10191 Elf_External_Verdaux evda
;
10194 off
= offset_from_vma
10196 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10197 sizeof (Elf_External_Verdef
));
10201 Elf_External_Verdef evd
;
10203 if (get_data (&evd
, file
, off
, sizeof (evd
),
10204 1, _("version def")) == NULL
)
10212 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10213 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10214 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10217 off
+= ivd
.vd_next
;
10219 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10220 && ivd
.vd_next
!= 0);
10222 off
-= ivd
.vd_next
;
10225 if (get_data (&evda
, file
, off
, sizeof (evda
),
10226 1, _("version def aux")) == NULL
)
10227 return version_string
;
10229 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10231 if (psym
->st_name
!= ivda
.vda_name
)
10233 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10234 ? symbol_hidden
: symbol_public
);
10235 version_string
= (ivda
.vda_name
< strtab_size
10236 ? strtab
+ ivda
.vda_name
10243 return version_string
;
10246 /* Dump the symbol table. */
10248 process_symbol_table (FILE * file
)
10250 Elf_Internal_Shdr
* section
;
10251 bfd_size_type nbuckets
= 0;
10252 bfd_size_type nchains
= 0;
10253 bfd_vma
* buckets
= NULL
;
10254 bfd_vma
* chains
= NULL
;
10255 bfd_vma ngnubuckets
= 0;
10256 bfd_vma
* gnubuckets
= NULL
;
10257 bfd_vma
* gnuchains
= NULL
;
10258 bfd_vma gnusymidx
= 0;
10259 bfd_size_type ngnuchains
= 0;
10261 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10264 if (dynamic_info
[DT_HASH
]
10266 || (do_using_dynamic
10268 && dynamic_strings
!= NULL
)))
10270 unsigned char nb
[8];
10271 unsigned char nc
[8];
10272 unsigned int hash_ent_size
= 4;
10274 if ((elf_header
.e_machine
== EM_ALPHA
10275 || elf_header
.e_machine
== EM_S390
10276 || elf_header
.e_machine
== EM_S390_OLD
)
10277 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10281 (archive_file_offset
10282 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10283 sizeof nb
+ sizeof nc
)),
10286 error (_("Unable to seek to start of dynamic information\n"));
10290 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10292 error (_("Failed to read in number of buckets\n"));
10296 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10298 error (_("Failed to read in number of chains\n"));
10302 nbuckets
= byte_get (nb
, hash_ent_size
);
10303 nchains
= byte_get (nc
, hash_ent_size
);
10305 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10306 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10309 if (buckets
== NULL
|| chains
== NULL
)
10311 if (do_using_dynamic
)
10322 if (dynamic_info_DT_GNU_HASH
10324 || (do_using_dynamic
10326 && dynamic_strings
!= NULL
)))
10328 unsigned char nb
[16];
10329 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10330 bfd_vma buckets_vma
;
10333 (archive_file_offset
10334 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10338 error (_("Unable to seek to start of dynamic information\n"));
10342 if (fread (nb
, 16, 1, file
) != 1)
10344 error (_("Failed to read in number of buckets\n"));
10348 ngnubuckets
= byte_get (nb
, 4);
10349 gnusymidx
= byte_get (nb
+ 4, 4);
10350 bitmaskwords
= byte_get (nb
+ 8, 4);
10351 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10353 buckets_vma
+= bitmaskwords
* 4;
10355 buckets_vma
+= bitmaskwords
* 8;
10358 (archive_file_offset
10359 + offset_from_vma (file
, buckets_vma
, 4)),
10362 error (_("Unable to seek to start of dynamic information\n"));
10366 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10368 if (gnubuckets
== NULL
)
10371 for (i
= 0; i
< ngnubuckets
; i
++)
10372 if (gnubuckets
[i
] != 0)
10374 if (gnubuckets
[i
] < gnusymidx
)
10377 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10378 maxchain
= gnubuckets
[i
];
10381 if (maxchain
== 0xffffffff)
10384 maxchain
-= gnusymidx
;
10387 (archive_file_offset
10388 + offset_from_vma (file
, buckets_vma
10389 + 4 * (ngnubuckets
+ maxchain
), 4)),
10392 error (_("Unable to seek to start of dynamic information\n"));
10398 if (fread (nb
, 4, 1, file
) != 1)
10400 error (_("Failed to determine last chain length\n"));
10404 if (maxchain
+ 1 == 0)
10409 while ((byte_get (nb
, 4) & 1) == 0);
10412 (archive_file_offset
10413 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10416 error (_("Unable to seek to start of dynamic information\n"));
10420 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10421 ngnuchains
= maxchain
;
10424 if (gnuchains
== NULL
)
10429 if (do_using_dynamic
)
10434 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10436 && do_using_dynamic
10437 && dynamic_strings
!= NULL
10438 && dynamic_symbols
!= NULL
)
10442 if (dynamic_info
[DT_HASH
])
10446 printf (_("\nSymbol table for image:\n"));
10448 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10450 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10452 for (hn
= 0; hn
< nbuckets
; hn
++)
10457 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10458 print_dynamic_symbol (si
, hn
);
10462 if (dynamic_info_DT_GNU_HASH
)
10464 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10466 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10468 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10470 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10471 if (gnubuckets
[hn
] != 0)
10473 bfd_vma si
= gnubuckets
[hn
];
10474 bfd_vma off
= si
- gnusymidx
;
10478 print_dynamic_symbol (si
, hn
);
10481 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10485 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10486 && section_headers
!= NULL
)
10490 for (i
= 0, section
= section_headers
;
10491 i
< elf_header
.e_shnum
;
10495 char * strtab
= NULL
;
10496 unsigned long int strtab_size
= 0;
10497 Elf_Internal_Sym
* symtab
;
10498 Elf_Internal_Sym
* psym
;
10499 unsigned long num_syms
;
10501 if ((section
->sh_type
!= SHT_SYMTAB
10502 && section
->sh_type
!= SHT_DYNSYM
)
10504 && section
->sh_type
== SHT_SYMTAB
))
10507 if (section
->sh_entsize
== 0)
10509 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10510 printable_section_name (section
));
10514 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10515 printable_section_name (section
),
10516 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10519 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10521 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10523 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10524 if (symtab
== NULL
)
10527 if (section
->sh_link
== elf_header
.e_shstrndx
)
10529 strtab
= string_table
;
10530 strtab_size
= string_table_length
;
10532 else if (section
->sh_link
< elf_header
.e_shnum
)
10534 Elf_Internal_Shdr
* string_sec
;
10536 string_sec
= section_headers
+ section
->sh_link
;
10538 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10539 1, string_sec
->sh_size
,
10540 _("string table"));
10541 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10544 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10546 const char *version_string
;
10547 enum versioned_symbol_info sym_info
;
10548 unsigned short vna_other
;
10550 printf ("%6d: ", si
);
10551 print_vma (psym
->st_value
, LONG_HEX
);
10553 print_vma (psym
->st_size
, DEC_5
);
10554 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10555 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10556 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10557 /* Check to see if any other bits in the st_other field are set.
10558 Note - displaying this information disrupts the layout of the
10559 table being generated, but for the moment this case is very rare. */
10560 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10561 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10562 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10563 print_symbol (25, psym
->st_name
< strtab_size
10564 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10567 = get_symbol_version_string (file
,
10568 section
->sh_type
== SHT_DYNSYM
,
10569 strtab
, strtab_size
, si
,
10570 psym
, &sym_info
, &vna_other
);
10571 if (version_string
)
10573 if (sym_info
== symbol_undefined
)
10574 printf ("@%s (%d)", version_string
, vna_other
);
10576 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10584 if (strtab
!= string_table
)
10590 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10592 if (do_histogram
&& buckets
!= NULL
)
10594 unsigned long * lengths
;
10595 unsigned long * counts
;
10598 unsigned long maxlength
= 0;
10599 unsigned long nzero_counts
= 0;
10600 unsigned long nsyms
= 0;
10602 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10603 (unsigned long) nbuckets
);
10605 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10606 if (lengths
== NULL
)
10608 error (_("Out of memory allocating space for histogram buckets\n"));
10612 printf (_(" Length Number %% of total Coverage\n"));
10613 for (hn
= 0; hn
< nbuckets
; ++hn
)
10615 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10618 if (maxlength
< ++lengths
[hn
])
10621 /* PR binutils/17531: A corrupt binary could contain broken
10622 histogram data. Do not go into an infinite loop trying
10624 if (chains
[si
] == si
)
10626 error (_("histogram chain links to itself\n"));
10632 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10633 if (counts
== NULL
)
10636 error (_("Out of memory allocating space for histogram counts\n"));
10640 for (hn
= 0; hn
< nbuckets
; ++hn
)
10641 ++counts
[lengths
[hn
]];
10646 printf (" 0 %-10lu (%5.1f%%)\n",
10647 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10648 for (i
= 1; i
<= maxlength
; ++i
)
10650 nzero_counts
+= counts
[i
] * i
;
10651 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10652 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10653 (nzero_counts
* 100.0) / nsyms
);
10661 if (buckets
!= NULL
)
10667 if (do_histogram
&& gnubuckets
!= NULL
)
10669 unsigned long * lengths
;
10670 unsigned long * counts
;
10672 unsigned long maxlength
= 0;
10673 unsigned long nzero_counts
= 0;
10674 unsigned long nsyms
= 0;
10676 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10677 (unsigned long) ngnubuckets
);
10679 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10680 if (lengths
== NULL
)
10682 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10686 printf (_(" Length Number %% of total Coverage\n"));
10688 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10689 if (gnubuckets
[hn
] != 0)
10691 bfd_vma off
, length
= 1;
10693 for (off
= gnubuckets
[hn
] - gnusymidx
;
10694 /* PR 17531 file: 010-77222-0.004. */
10695 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
10698 lengths
[hn
] = length
;
10699 if (length
> maxlength
)
10700 maxlength
= length
;
10704 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10705 if (counts
== NULL
)
10708 error (_("Out of memory allocating space for gnu histogram counts\n"));
10712 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10713 ++counts
[lengths
[hn
]];
10715 if (ngnubuckets
> 0)
10718 printf (" 0 %-10lu (%5.1f%%)\n",
10719 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10720 for (j
= 1; j
<= maxlength
; ++j
)
10722 nzero_counts
+= counts
[j
] * j
;
10723 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10724 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10725 (nzero_counts
* 100.0) / nsyms
);
10739 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10743 if (dynamic_syminfo
== NULL
10745 /* No syminfo, this is ok. */
10748 /* There better should be a dynamic symbol section. */
10749 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10753 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10754 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10756 printf (_(" Num: Name BoundTo Flags\n"));
10757 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10759 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10761 printf ("%4d: ", i
);
10762 if (i
>= num_dynamic_syms
)
10763 printf (_("<corrupt index>"));
10764 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10765 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10767 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10770 switch (dynamic_syminfo
[i
].si_boundto
)
10772 case SYMINFO_BT_SELF
:
10773 fputs ("SELF ", stdout
);
10775 case SYMINFO_BT_PARENT
:
10776 fputs ("PARENT ", stdout
);
10779 if (dynamic_syminfo
[i
].si_boundto
> 0
10780 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10781 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10783 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10787 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10791 if (flags
& SYMINFO_FLG_DIRECT
)
10792 printf (" DIRECT");
10793 if (flags
& SYMINFO_FLG_PASSTHRU
)
10794 printf (" PASSTHRU");
10795 if (flags
& SYMINFO_FLG_COPY
)
10797 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10798 printf (" LAZYLOAD");
10806 /* Check to see if the given reloc needs to be handled in a target specific
10807 manner. If so then process the reloc and return TRUE otherwise return
10811 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10812 unsigned char * start
,
10813 Elf_Internal_Sym
* symtab
)
10815 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10817 switch (elf_header
.e_machine
)
10820 case EM_MSP430_OLD
:
10822 static Elf_Internal_Sym
* saved_sym
= NULL
;
10824 switch (reloc_type
)
10826 case 10: /* R_MSP430_SYM_DIFF */
10827 if (uses_msp430x_relocs ())
10829 case 21: /* R_MSP430X_SYM_DIFF */
10830 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10833 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10834 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10835 goto handle_sym_diff
;
10837 case 5: /* R_MSP430_16_BYTE */
10838 case 9: /* R_MSP430_8 */
10839 if (uses_msp430x_relocs ())
10841 goto handle_sym_diff
;
10843 case 2: /* R_MSP430_ABS16 */
10844 case 15: /* R_MSP430X_ABS16 */
10845 if (! uses_msp430x_relocs ())
10847 goto handle_sym_diff
;
10850 if (saved_sym
!= NULL
)
10854 value
= reloc
->r_addend
10855 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10856 - saved_sym
->st_value
);
10858 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10866 if (saved_sym
!= NULL
)
10867 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10874 case EM_CYGNUS_MN10300
:
10876 static Elf_Internal_Sym
* saved_sym
= NULL
;
10878 switch (reloc_type
)
10880 case 34: /* R_MN10300_ALIGN */
10882 case 33: /* R_MN10300_SYM_DIFF */
10883 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10885 case 1: /* R_MN10300_32 */
10886 case 2: /* R_MN10300_16 */
10887 if (saved_sym
!= NULL
)
10891 value
= reloc
->r_addend
10892 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10893 - saved_sym
->st_value
);
10895 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10902 if (saved_sym
!= NULL
)
10903 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
10913 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10914 DWARF debug sections. This is a target specific test. Note - we do not
10915 go through the whole including-target-headers-multiple-times route, (as
10916 we have already done with <elf/h8.h>) because this would become very
10917 messy and even then this function would have to contain target specific
10918 information (the names of the relocs instead of their numeric values).
10919 FIXME: This is not the correct way to solve this problem. The proper way
10920 is to have target specific reloc sizing and typing functions created by
10921 the reloc-macros.h header, in the same way that it already creates the
10922 reloc naming functions. */
10925 is_32bit_abs_reloc (unsigned int reloc_type
)
10927 switch (elf_header
.e_machine
)
10931 return reloc_type
== 1; /* R_386_32. */
10933 return reloc_type
== 1; /* R_68K_32. */
10935 return reloc_type
== 1; /* R_860_32. */
10937 return reloc_type
== 2; /* R_960_32. */
10939 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10941 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10943 return reloc_type
== 1; /* R_ARC_32. */
10945 return reloc_type
== 2; /* R_ARM_ABS32 */
10948 return reloc_type
== 1;
10949 case EM_ADAPTEVA_EPIPHANY
:
10950 return reloc_type
== 3;
10952 return reloc_type
== 0x12; /* R_byte4_data. */
10954 return reloc_type
== 3; /* R_CRIS_32. */
10956 return reloc_type
== 3; /* R_CR16_NUM32. */
10958 return reloc_type
== 15; /* R_CRX_NUM32. */
10959 case EM_CYGNUS_FRV
:
10960 return reloc_type
== 1;
10961 case EM_CYGNUS_D10V
:
10963 return reloc_type
== 6; /* R_D10V_32. */
10964 case EM_CYGNUS_D30V
:
10966 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10968 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10969 case EM_CYGNUS_FR30
:
10971 return reloc_type
== 3; /* R_FR30_32. */
10975 return reloc_type
== 1; /* R_H8_DIR32. */
10977 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10980 return reloc_type
== 2; /* R_IP2K_32. */
10982 return reloc_type
== 2; /* R_IQ2000_32. */
10983 case EM_LATTICEMICO32
:
10984 return reloc_type
== 3; /* R_LM32_32. */
10987 return reloc_type
== 3; /* R_M32C_32. */
10989 return reloc_type
== 34; /* R_M32R_32_RELA. */
10991 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10992 case EM_CYGNUS_MEP
:
10993 return reloc_type
== 4; /* R_MEP_32. */
10995 return reloc_type
== 2; /* R_METAG_ADDR32. */
10996 case EM_MICROBLAZE
:
10997 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10999 return reloc_type
== 2; /* R_MIPS_32. */
11001 return reloc_type
== 4; /* R_MMIX_32. */
11002 case EM_CYGNUS_MN10200
:
11004 return reloc_type
== 1; /* R_MN10200_32. */
11005 case EM_CYGNUS_MN10300
:
11007 return reloc_type
== 1; /* R_MN10300_32. */
11009 return reloc_type
== 1; /* R_MOXIE_32. */
11010 case EM_MSP430_OLD
:
11012 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11014 return reloc_type
== 2; /* R_MT_32. */
11016 return reloc_type
== 20; /* R_NDS32_RELA. */
11017 case EM_ALTERA_NIOS2
:
11018 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11020 return reloc_type
== 1; /* R_NIOS_32. */
11022 return reloc_type
== 1; /* R_OR1K_32. */
11024 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11025 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11028 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11030 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11032 return reloc_type
== 1; /* R_PPC_ADDR32. */
11034 return reloc_type
== 1; /* R_RL78_DIR32. */
11036 return reloc_type
== 1; /* R_RX_DIR32. */
11038 return reloc_type
== 1; /* R_I370_ADDR31. */
11041 return reloc_type
== 4; /* R_S390_32. */
11043 return reloc_type
== 8; /* R_SCORE_ABS32. */
11045 return reloc_type
== 1; /* R_SH_DIR32. */
11046 case EM_SPARC32PLUS
:
11049 return reloc_type
== 3 /* R_SPARC_32. */
11050 || reloc_type
== 23; /* R_SPARC_UA32. */
11052 return reloc_type
== 6; /* R_SPU_ADDR32 */
11054 return reloc_type
== 1; /* R_C6000_ABS32. */
11056 return reloc_type
== 2; /* R_TILEGX_32. */
11058 return reloc_type
== 1; /* R_TILEPRO_32. */
11059 case EM_CYGNUS_V850
:
11061 return reloc_type
== 6; /* R_V850_ABS32. */
11063 return reloc_type
== 0x33; /* R_V810_WORD. */
11065 return reloc_type
== 1; /* R_VAX_32. */
11069 return reloc_type
== 10; /* R_X86_64_32. */
11072 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11074 return reloc_type
== 4; /* R_XGATE_32. */
11076 return reloc_type
== 1; /* R_XSTROMY16_32. */
11077 case EM_XTENSA_OLD
:
11079 return reloc_type
== 1; /* R_XTENSA_32. */
11082 static unsigned int prev_warn
= 0;
11084 /* Avoid repeating the same warning multiple times. */
11085 if (prev_warn
!= elf_header
.e_machine
)
11086 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11087 elf_header
.e_machine
);
11088 prev_warn
= elf_header
.e_machine
;
11094 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11095 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11098 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11100 switch (elf_header
.e_machine
)
11104 return reloc_type
== 2; /* R_386_PC32. */
11106 return reloc_type
== 4; /* R_68K_PC32. */
11108 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11109 case EM_ADAPTEVA_EPIPHANY
:
11110 return reloc_type
== 6;
11112 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11114 return reloc_type
== 3; /* R_ARM_REL32 */
11115 case EM_MICROBLAZE
:
11116 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11118 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11120 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11122 return reloc_type
== 26; /* R_PPC_REL32. */
11124 return reloc_type
== 26; /* R_PPC64_REL32. */
11127 return reloc_type
== 5; /* R_390_PC32. */
11129 return reloc_type
== 2; /* R_SH_REL32. */
11130 case EM_SPARC32PLUS
:
11133 return reloc_type
== 6; /* R_SPARC_DISP32. */
11135 return reloc_type
== 13; /* R_SPU_REL32. */
11137 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11139 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11143 return reloc_type
== 2; /* R_X86_64_PC32. */
11144 case EM_XTENSA_OLD
:
11146 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11148 /* Do not abort or issue an error message here. Not all targets use
11149 pc-relative 32-bit relocs in their DWARF debug information and we
11150 have already tested for target coverage in is_32bit_abs_reloc. A
11151 more helpful warning message will be generated by apply_relocations
11152 anyway, so just return. */
11157 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11158 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11161 is_64bit_abs_reloc (unsigned int reloc_type
)
11163 switch (elf_header
.e_machine
)
11166 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11168 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11170 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11172 return reloc_type
== 80; /* R_PARISC_DIR64. */
11174 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11175 case EM_SPARC32PLUS
:
11178 return reloc_type
== 54; /* R_SPARC_UA64. */
11182 return reloc_type
== 1; /* R_X86_64_64. */
11185 return reloc_type
== 22; /* R_S390_64. */
11187 return reloc_type
== 1; /* R_TILEGX_64. */
11189 return reloc_type
== 18; /* R_MIPS_64. */
11195 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11196 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11199 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11201 switch (elf_header
.e_machine
)
11204 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11206 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11208 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11210 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11212 return reloc_type
== 44; /* R_PPC64_REL64. */
11213 case EM_SPARC32PLUS
:
11216 return reloc_type
== 46; /* R_SPARC_DISP64. */
11220 return reloc_type
== 24; /* R_X86_64_PC64. */
11223 return reloc_type
== 23; /* R_S390_PC64. */
11225 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11231 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11232 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11235 is_24bit_abs_reloc (unsigned int reloc_type
)
11237 switch (elf_header
.e_machine
)
11239 case EM_CYGNUS_MN10200
:
11241 return reloc_type
== 4; /* R_MN10200_24. */
11247 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11248 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11251 is_16bit_abs_reloc (unsigned int reloc_type
)
11253 switch (elf_header
.e_machine
)
11257 return reloc_type
== 4; /* R_AVR_16. */
11258 case EM_ADAPTEVA_EPIPHANY
:
11259 return reloc_type
== 5;
11260 case EM_CYGNUS_D10V
:
11262 return reloc_type
== 3; /* R_D10V_16. */
11266 return reloc_type
== R_H8_DIR16
;
11269 return reloc_type
== 1; /* R_IP2K_16. */
11272 return reloc_type
== 1; /* R_M32C_16 */
11274 if (uses_msp430x_relocs ())
11275 return reloc_type
== 2; /* R_MSP430_ABS16. */
11276 case EM_MSP430_OLD
:
11277 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11279 return reloc_type
== 19; /* R_NDS32_RELA. */
11280 case EM_ALTERA_NIOS2
:
11281 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11283 return reloc_type
== 9; /* R_NIOS_16. */
11285 return reloc_type
== 2; /* R_OR1K_16. */
11287 return reloc_type
== 2; /* R_C6000_ABS16. */
11290 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11291 case EM_CYGNUS_MN10200
:
11293 return reloc_type
== 2; /* R_MN10200_16. */
11294 case EM_CYGNUS_MN10300
:
11296 return reloc_type
== 2; /* R_MN10300_16. */
11298 return reloc_type
== 3; /* R_XGATE_16. */
11304 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11305 relocation entries (possibly formerly used for SHT_GROUP sections). */
11308 is_none_reloc (unsigned int reloc_type
)
11310 switch (elf_header
.e_machine
)
11312 case EM_68K
: /* R_68K_NONE. */
11313 case EM_386
: /* R_386_NONE. */
11314 case EM_SPARC32PLUS
:
11316 case EM_SPARC
: /* R_SPARC_NONE. */
11317 case EM_MIPS
: /* R_MIPS_NONE. */
11318 case EM_PARISC
: /* R_PARISC_NONE. */
11319 case EM_ALPHA
: /* R_ALPHA_NONE. */
11320 case EM_ADAPTEVA_EPIPHANY
:
11321 case EM_PPC
: /* R_PPC_NONE. */
11322 case EM_PPC64
: /* R_PPC64_NONE. */
11323 case EM_ARM
: /* R_ARM_NONE. */
11324 case EM_IA_64
: /* R_IA64_NONE. */
11325 case EM_SH
: /* R_SH_NONE. */
11327 case EM_S390
: /* R_390_NONE. */
11328 case EM_CRIS
: /* R_CRIS_NONE. */
11329 case EM_X86_64
: /* R_X86_64_NONE. */
11330 case EM_L1OM
: /* R_X86_64_NONE. */
11331 case EM_K1OM
: /* R_X86_64_NONE. */
11332 case EM_MN10300
: /* R_MN10300_NONE. */
11333 case EM_MOXIE
: /* R_MOXIE_NONE. */
11334 case EM_M32R
: /* R_M32R_NONE. */
11335 case EM_TI_C6000
:/* R_C6000_NONE. */
11336 case EM_TILEGX
: /* R_TILEGX_NONE. */
11337 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11339 case EM_C166
: /* R_XC16X_NONE. */
11340 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11341 case EM_NIOS32
: /* R_NIOS_NONE. */
11342 case EM_OR1K
: /* R_OR1K_NONE. */
11343 return reloc_type
== 0;
11345 return reloc_type
== 0 || reloc_type
== 256;
11347 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11348 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11349 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11350 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11351 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11352 case EM_XTENSA_OLD
:
11354 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11355 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11356 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11357 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11359 return reloc_type
== 3; /* R_METAG_NONE. */
11364 /* Apply relocations to a section.
11365 Note: So far support has been added only for those relocations
11366 which can be found in debug sections.
11367 FIXME: Add support for more relocations ? */
11370 apply_relocations (void * file
,
11371 Elf_Internal_Shdr
* section
,
11372 unsigned char * start
)
11374 Elf_Internal_Shdr
* relsec
;
11375 unsigned char * end
= start
+ section
->sh_size
;
11377 if (elf_header
.e_type
!= ET_REL
)
11380 /* Find the reloc section associated with the section. */
11381 for (relsec
= section_headers
;
11382 relsec
< section_headers
+ elf_header
.e_shnum
;
11385 bfd_boolean is_rela
;
11386 unsigned long num_relocs
;
11387 Elf_Internal_Rela
* relocs
;
11388 Elf_Internal_Rela
* rp
;
11389 Elf_Internal_Shdr
* symsec
;
11390 Elf_Internal_Sym
* symtab
;
11391 unsigned long num_syms
;
11392 Elf_Internal_Sym
* sym
;
11394 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11395 || relsec
->sh_info
>= elf_header
.e_shnum
11396 || section_headers
+ relsec
->sh_info
!= section
11397 || relsec
->sh_size
== 0
11398 || relsec
->sh_link
>= elf_header
.e_shnum
)
11401 is_rela
= relsec
->sh_type
== SHT_RELA
;
11405 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11406 relsec
->sh_size
, & relocs
, & num_relocs
))
11411 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11412 relsec
->sh_size
, & relocs
, & num_relocs
))
11416 /* SH uses RELA but uses in place value instead of the addend field. */
11417 if (elf_header
.e_machine
== EM_SH
)
11420 symsec
= section_headers
+ relsec
->sh_link
;
11421 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11423 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11426 unsigned int reloc_type
;
11427 unsigned int reloc_size
;
11428 unsigned char * rloc
;
11429 unsigned long sym_index
;
11431 reloc_type
= get_reloc_type (rp
->r_info
);
11433 if (target_specific_reloc_handling (rp
, start
, symtab
))
11435 else if (is_none_reloc (reloc_type
))
11437 else if (is_32bit_abs_reloc (reloc_type
)
11438 || is_32bit_pcrel_reloc (reloc_type
))
11440 else if (is_64bit_abs_reloc (reloc_type
)
11441 || is_64bit_pcrel_reloc (reloc_type
))
11443 else if (is_24bit_abs_reloc (reloc_type
))
11445 else if (is_16bit_abs_reloc (reloc_type
))
11449 static unsigned int prev_reloc
= 0;
11450 if (reloc_type
!= prev_reloc
)
11451 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11452 reloc_type
, printable_section_name (section
));
11453 prev_reloc
= reloc_type
;
11457 rloc
= start
+ rp
->r_offset
;
11458 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11460 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11461 (unsigned long) rp
->r_offset
,
11462 printable_section_name (section
));
11466 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11467 if (sym_index
>= num_syms
)
11469 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11470 sym_index
, printable_section_name (section
));
11473 sym
= symtab
+ sym_index
;
11475 /* If the reloc has a symbol associated with it,
11476 make sure that it is of an appropriate type.
11478 Relocations against symbols without type can happen.
11479 Gcc -feliminate-dwarf2-dups may generate symbols
11480 without type for debug info.
11482 Icc generates relocations against function symbols
11483 instead of local labels.
11485 Relocations against object symbols can happen, eg when
11486 referencing a global array. For an example of this see
11487 the _clz.o binary in libgcc.a. */
11489 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11491 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11492 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11493 (long int)(rp
- relocs
),
11494 printable_section_name (relsec
));
11500 addend
+= rp
->r_addend
;
11501 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11502 partial_inplace. */
11504 || (elf_header
.e_machine
== EM_XTENSA
11505 && reloc_type
== 1)
11506 || ((elf_header
.e_machine
== EM_PJ
11507 || elf_header
.e_machine
== EM_PJ_OLD
)
11508 && reloc_type
== 1)
11509 || ((elf_header
.e_machine
== EM_D30V
11510 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11511 && reloc_type
== 12))
11512 addend
+= byte_get (rloc
, reloc_size
);
11514 if (is_32bit_pcrel_reloc (reloc_type
)
11515 || is_64bit_pcrel_reloc (reloc_type
))
11517 /* On HPPA, all pc-relative relocations are biased by 8. */
11518 if (elf_header
.e_machine
== EM_PARISC
)
11520 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11524 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11533 #ifdef SUPPORT_DISASSEMBLY
11535 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11537 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11539 /* FIXME: XXX -- to be done --- XXX */
11545 /* Reads in the contents of SECTION from FILE, returning a pointer
11546 to a malloc'ed buffer or NULL if something went wrong. */
11549 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11551 bfd_size_type num_bytes
;
11553 num_bytes
= section
->sh_size
;
11555 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11557 printf (_("\nSection '%s' has no data to dump.\n"),
11558 printable_section_name (section
));
11562 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11563 _("section contents"));
11568 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11570 Elf_Internal_Shdr
* relsec
;
11571 bfd_size_type num_bytes
;
11575 bfd_boolean some_strings_shown
;
11577 start
= get_section_contents (section
, file
);
11581 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11583 /* If the section being dumped has relocations against it the user might
11584 be expecting these relocations to have been applied. Check for this
11585 case and issue a warning message in order to avoid confusion.
11586 FIXME: Maybe we ought to have an option that dumps a section with
11587 relocs applied ? */
11588 for (relsec
= section_headers
;
11589 relsec
< section_headers
+ elf_header
.e_shnum
;
11592 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11593 || relsec
->sh_info
>= elf_header
.e_shnum
11594 || section_headers
+ relsec
->sh_info
!= section
11595 || relsec
->sh_size
== 0
11596 || relsec
->sh_link
>= elf_header
.e_shnum
)
11599 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11603 num_bytes
= section
->sh_size
;
11605 end
= start
+ num_bytes
;
11606 some_strings_shown
= FALSE
;
11610 while (!ISPRINT (* data
))
11611 if (++ data
>= end
)
11616 size_t maxlen
= end
- data
;
11619 /* PR 11128: Use two separate invocations in order to work
11620 around bugs in the Solaris 8 implementation of printf. */
11621 printf (" [%6tx] ", data
- start
);
11623 printf (" [%6Ix] ", (size_t) (data
- start
));
11627 print_symbol ((int) maxlen
, data
);
11629 data
+= strnlen (data
, maxlen
);
11633 printf (_("<corrupt>\n"));
11636 some_strings_shown
= TRUE
;
11640 if (! some_strings_shown
)
11641 printf (_(" No strings found in this section."));
11649 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11651 bfd_boolean relocate
)
11653 Elf_Internal_Shdr
* relsec
;
11654 bfd_size_type bytes
;
11656 unsigned char * data
;
11657 unsigned char * start
;
11659 start
= (unsigned char *) get_section_contents (section
, file
);
11663 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11667 apply_relocations (file
, section
, start
);
11671 /* If the section being dumped has relocations against it the user might
11672 be expecting these relocations to have been applied. Check for this
11673 case and issue a warning message in order to avoid confusion.
11674 FIXME: Maybe we ought to have an option that dumps a section with
11675 relocs applied ? */
11676 for (relsec
= section_headers
;
11677 relsec
< section_headers
+ elf_header
.e_shnum
;
11680 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11681 || relsec
->sh_info
>= elf_header
.e_shnum
11682 || section_headers
+ relsec
->sh_info
!= section
11683 || relsec
->sh_size
== 0
11684 || relsec
->sh_link
>= elf_header
.e_shnum
)
11687 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11692 addr
= section
->sh_addr
;
11693 bytes
= section
->sh_size
;
11702 lbytes
= (bytes
> 16 ? 16 : bytes
);
11704 printf (" 0x%8.8lx ", (unsigned long) addr
);
11706 for (j
= 0; j
< 16; j
++)
11709 printf ("%2.2x", data
[j
]);
11717 for (j
= 0; j
< lbytes
; j
++)
11720 if (k
>= ' ' && k
< 0x7f)
11738 /* Uncompresses a section that was compressed using zlib, in place. */
11741 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11742 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11744 #ifndef HAVE_ZLIB_H
11747 dwarf_size_type compressed_size
= *size
;
11748 unsigned char * compressed_buffer
= *buffer
;
11749 dwarf_size_type uncompressed_size
;
11750 unsigned char * uncompressed_buffer
;
11753 dwarf_size_type header_size
= 12;
11755 /* Read the zlib header. In this case, it should be "ZLIB" followed
11756 by the uncompressed section size, 8 bytes in big-endian order. */
11757 if (compressed_size
< header_size
11758 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11761 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11762 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11763 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11764 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11765 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11766 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11767 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11768 uncompressed_size
+= compressed_buffer
[11];
11770 /* It is possible the section consists of several compressed
11771 buffers concatenated together, so we uncompress in a loop. */
11772 strm
.zalloc
= NULL
;
11774 strm
.opaque
= NULL
;
11775 strm
.avail_in
= compressed_size
- header_size
;
11776 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11777 strm
.avail_out
= uncompressed_size
;
11778 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11780 rc
= inflateInit (& strm
);
11781 while (strm
.avail_in
> 0)
11785 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11786 + (uncompressed_size
- strm
.avail_out
));
11787 rc
= inflate (&strm
, Z_FINISH
);
11788 if (rc
!= Z_STREAM_END
)
11790 rc
= inflateReset (& strm
);
11792 rc
= inflateEnd (& strm
);
11794 || strm
.avail_out
!= 0)
11797 free (compressed_buffer
);
11798 *buffer
= uncompressed_buffer
;
11799 *size
= uncompressed_size
;
11803 free (uncompressed_buffer
);
11804 /* Indicate decompression failure. */
11807 #endif /* HAVE_ZLIB_H */
11811 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11812 Elf_Internal_Shdr
* sec
, void * file
)
11814 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11817 /* If it is already loaded, do nothing. */
11818 if (section
->start
!= NULL
)
11821 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11822 section
->address
= sec
->sh_addr
;
11823 section
->user_data
= NULL
;
11824 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11826 sec
->sh_size
, buf
);
11827 if (section
->start
== NULL
)
11831 section
->size
= sec
->sh_size
;
11832 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11833 sec
->sh_size
= section
->size
;
11836 if (section
->start
== NULL
)
11839 if (debug_displays
[debug
].relocate
)
11840 apply_relocations ((FILE *) file
, sec
, section
->start
);
11845 /* If this is not NULL, load_debug_section will only look for sections
11846 within the list of sections given here. */
11847 unsigned int *section_subset
= NULL
;
11850 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11852 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11853 Elf_Internal_Shdr
* sec
;
11855 /* Locate the debug section. */
11856 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11858 section
->name
= section
->uncompressed_name
;
11861 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11863 section
->name
= section
->compressed_name
;
11868 /* If we're loading from a subset of sections, and we've loaded
11869 a section matching this name before, it's likely that it's a
11871 if (section_subset
!= NULL
)
11872 free_debug_section (debug
);
11874 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11878 free_debug_section (enum dwarf_section_display_enum debug
)
11880 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11882 if (section
->start
== NULL
)
11885 free ((char *) section
->start
);
11886 section
->start
= NULL
;
11887 section
->address
= 0;
11892 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11894 char * name
= SECTION_NAME (section
);
11895 const char * print_name
= printable_section_name (section
);
11896 bfd_size_type length
;
11900 length
= section
->sh_size
;
11903 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
11906 if (section
->sh_type
== SHT_NOBITS
)
11908 /* There is no point in dumping the contents of a debugging section
11909 which has the NOBITS type - the bits in the file will be random.
11910 This can happen when a file containing a .eh_frame section is
11911 stripped with the --only-keep-debug command line option. */
11912 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11917 if (const_strneq (name
, ".gnu.linkonce.wi."))
11918 name
= ".debug_info";
11920 /* See if we know how to display the contents of this section. */
11921 for (i
= 0; i
< max
; i
++)
11922 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11923 || (i
== line
&& const_strneq (name
, ".debug_line."))
11924 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11926 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11927 int secondary
= (section
!= find_section (name
));
11930 free_debug_section ((enum dwarf_section_display_enum
) i
);
11932 if (i
== line
&& const_strneq (name
, ".debug_line."))
11934 else if (streq (sec
->uncompressed_name
, name
))
11935 sec
->name
= sec
->uncompressed_name
;
11937 sec
->name
= sec
->compressed_name
;
11938 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11941 /* If this debug section is part of a CU/TU set in a .dwp file,
11942 restrict load_debug_section to the sections in that set. */
11943 section_subset
= find_cu_tu_set (file
, shndx
);
11945 result
&= debug_displays
[i
].display (sec
, file
);
11947 section_subset
= NULL
;
11949 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11950 free_debug_section ((enum dwarf_section_display_enum
) i
);
11958 printf (_("Unrecognized debug section: %s\n"), print_name
);
11965 /* Set DUMP_SECTS for all sections where dumps were requested
11966 based on section name. */
11969 initialise_dumps_byname (void)
11971 struct dump_list_entry
* cur
;
11973 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11978 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11979 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11981 request_dump_bynumber (i
, cur
->type
);
11986 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11992 process_section_contents (FILE * file
)
11994 Elf_Internal_Shdr
* section
;
12000 initialise_dumps_byname ();
12002 for (i
= 0, section
= section_headers
;
12003 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12006 #ifdef SUPPORT_DISASSEMBLY
12007 if (dump_sects
[i
] & DISASS_DUMP
)
12008 disassemble_section (section
, file
);
12010 if (dump_sects
[i
] & HEX_DUMP
)
12011 dump_section_as_bytes (section
, file
, FALSE
);
12013 if (dump_sects
[i
] & RELOC_DUMP
)
12014 dump_section_as_bytes (section
, file
, TRUE
);
12016 if (dump_sects
[i
] & STRING_DUMP
)
12017 dump_section_as_strings (section
, file
);
12019 if (dump_sects
[i
] & DEBUG_DUMP
)
12020 display_debug_section (i
, section
, file
);
12023 /* Check to see if the user requested a
12024 dump of a section that does not exist. */
12025 while (i
++ < num_dump_sects
)
12027 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12031 process_mips_fpe_exception (int mask
)
12036 if (mask
& OEX_FPU_INEX
)
12037 fputs ("INEX", stdout
), first
= 0;
12038 if (mask
& OEX_FPU_UFLO
)
12039 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12040 if (mask
& OEX_FPU_OFLO
)
12041 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12042 if (mask
& OEX_FPU_DIV0
)
12043 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12044 if (mask
& OEX_FPU_INVAL
)
12045 printf ("%sINVAL", first
? "" : "|");
12048 fputs ("0", stdout
);
12051 /* Display's the value of TAG at location P. If TAG is
12052 greater than 0 it is assumed to be an unknown tag, and
12053 a message is printed to this effect. Otherwise it is
12054 assumed that a message has already been printed.
12056 If the bottom bit of TAG is set it assumed to have a
12057 string value, otherwise it is assumed to have an integer
12060 Returns an updated P pointing to the first unread byte
12061 beyond the end of TAG's value.
12063 Reads at or beyond END will not be made. */
12065 static unsigned char *
12066 display_tag_value (int tag
,
12068 const unsigned char * const end
)
12073 printf (" Tag_unknown_%d: ", tag
);
12077 warn (_("<corrupt tag>\n"));
12081 /* PR 17531 file: 027-19978-0.004. */
12082 size_t maxlen
= (end
- p
) - 1;
12087 print_symbol ((int) maxlen
, (const char *) p
);
12088 p
+= strnlen ((char *) p
, maxlen
) + 1;
12092 printf (_("<corrupt string tag>"));
12093 p
= (unsigned char *) end
;
12101 val
= read_uleb128 (p
, &len
, end
);
12103 printf ("%ld (0x%lx)\n", val
, val
);
12110 /* ARM EABI attributes section. */
12115 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12117 const char ** table
;
12118 } arm_attr_public_tag
;
12120 static const char * arm_attr_tag_CPU_arch
[] =
12121 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12122 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12123 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12124 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12125 {"No", "Thumb-1", "Thumb-2"};
12126 static const char * arm_attr_tag_FP_arch
[] =
12127 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12128 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12129 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12130 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12131 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12132 static const char * arm_attr_tag_PCS_config
[] =
12133 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12134 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12135 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12136 {"V6", "SB", "TLS", "Unused"};
12137 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12138 {"Absolute", "PC-relative", "SB-relative", "None"};
12139 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12140 {"Absolute", "PC-relative", "None"};
12141 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12142 {"None", "direct", "GOT-indirect"};
12143 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12144 {"None", "??? 1", "2", "??? 3", "4"};
12145 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12146 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12147 {"Unused", "Needed", "Sign only"};
12148 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12149 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12150 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12151 {"Unused", "Finite", "RTABI", "IEEE 754"};
12152 static const char * arm_attr_tag_ABI_enum_size
[] =
12153 {"Unused", "small", "int", "forced to int"};
12154 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12155 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12156 static const char * arm_attr_tag_ABI_VFP_args
[] =
12157 {"AAPCS", "VFP registers", "custom"};
12158 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12159 {"AAPCS", "WMMX registers", "custom"};
12160 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12161 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12162 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12163 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12164 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12165 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12166 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12167 static const char * arm_attr_tag_FP_HP_extension
[] =
12168 {"Not Allowed", "Allowed"};
12169 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12170 {"None", "IEEE 754", "Alternative Format"};
12171 static const char * arm_attr_tag_MPextension_use
[] =
12172 {"Not Allowed", "Allowed"};
12173 static const char * arm_attr_tag_DIV_use
[] =
12174 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12175 "Allowed in v7-A with integer division extension"};
12176 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12177 static const char * arm_attr_tag_Virtualization_use
[] =
12178 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12179 "TrustZone and Virtualization Extensions"};
12180 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12181 {"Not Allowed", "Allowed"};
12183 #define LOOKUP(id, name) \
12184 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12185 static arm_attr_public_tag arm_attr_public_tags
[] =
12187 {4, "CPU_raw_name", 1, NULL
},
12188 {5, "CPU_name", 1, NULL
},
12189 LOOKUP(6, CPU_arch
),
12190 {7, "CPU_arch_profile", 0, NULL
},
12191 LOOKUP(8, ARM_ISA_use
),
12192 LOOKUP(9, THUMB_ISA_use
),
12193 LOOKUP(10, FP_arch
),
12194 LOOKUP(11, WMMX_arch
),
12195 LOOKUP(12, Advanced_SIMD_arch
),
12196 LOOKUP(13, PCS_config
),
12197 LOOKUP(14, ABI_PCS_R9_use
),
12198 LOOKUP(15, ABI_PCS_RW_data
),
12199 LOOKUP(16, ABI_PCS_RO_data
),
12200 LOOKUP(17, ABI_PCS_GOT_use
),
12201 LOOKUP(18, ABI_PCS_wchar_t
),
12202 LOOKUP(19, ABI_FP_rounding
),
12203 LOOKUP(20, ABI_FP_denormal
),
12204 LOOKUP(21, ABI_FP_exceptions
),
12205 LOOKUP(22, ABI_FP_user_exceptions
),
12206 LOOKUP(23, ABI_FP_number_model
),
12207 {24, "ABI_align_needed", 0, NULL
},
12208 {25, "ABI_align_preserved", 0, NULL
},
12209 LOOKUP(26, ABI_enum_size
),
12210 LOOKUP(27, ABI_HardFP_use
),
12211 LOOKUP(28, ABI_VFP_args
),
12212 LOOKUP(29, ABI_WMMX_args
),
12213 LOOKUP(30, ABI_optimization_goals
),
12214 LOOKUP(31, ABI_FP_optimization_goals
),
12215 {32, "compatibility", 0, NULL
},
12216 LOOKUP(34, CPU_unaligned_access
),
12217 LOOKUP(36, FP_HP_extension
),
12218 LOOKUP(38, ABI_FP_16bit_format
),
12219 LOOKUP(42, MPextension_use
),
12220 LOOKUP(44, DIV_use
),
12221 {64, "nodefaults", 0, NULL
},
12222 {65, "also_compatible_with", 0, NULL
},
12223 LOOKUP(66, T2EE_use
),
12224 {67, "conformance", 1, NULL
},
12225 LOOKUP(68, Virtualization_use
),
12226 LOOKUP(70, MPextension_use_legacy
)
12230 static unsigned char *
12231 display_arm_attribute (unsigned char * p
,
12232 const unsigned char * const end
)
12237 arm_attr_public_tag
* attr
;
12241 tag
= read_uleb128 (p
, &len
, end
);
12244 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12246 if (arm_attr_public_tags
[i
].tag
== tag
)
12248 attr
= &arm_attr_public_tags
[i
];
12255 printf (" Tag_%s: ", attr
->name
);
12256 switch (attr
->type
)
12261 case 7: /* Tag_CPU_arch_profile. */
12262 val
= read_uleb128 (p
, &len
, end
);
12266 case 0: printf (_("None\n")); break;
12267 case 'A': printf (_("Application\n")); break;
12268 case 'R': printf (_("Realtime\n")); break;
12269 case 'M': printf (_("Microcontroller\n")); break;
12270 case 'S': printf (_("Application or Realtime\n")); break;
12271 default: printf ("??? (%d)\n", val
); break;
12275 case 24: /* Tag_align_needed. */
12276 val
= read_uleb128 (p
, &len
, end
);
12280 case 0: printf (_("None\n")); break;
12281 case 1: printf (_("8-byte\n")); break;
12282 case 2: printf (_("4-byte\n")); break;
12283 case 3: printf ("??? 3\n"); break;
12286 printf (_("8-byte and up to %d-byte extended\n"),
12289 printf ("??? (%d)\n", val
);
12294 case 25: /* Tag_align_preserved. */
12295 val
= read_uleb128 (p
, &len
, end
);
12299 case 0: printf (_("None\n")); break;
12300 case 1: printf (_("8-byte, except leaf SP\n")); break;
12301 case 2: printf (_("8-byte\n")); break;
12302 case 3: printf ("??? 3\n"); break;
12305 printf (_("8-byte and up to %d-byte extended\n"),
12308 printf ("??? (%d)\n", val
);
12313 case 32: /* Tag_compatibility. */
12315 val
= read_uleb128 (p
, &len
, end
);
12317 printf (_("flag = %d, vendor = "), val
);
12320 size_t maxlen
= (end
- p
) - 1;
12322 print_symbol ((int) maxlen
, (const char *) p
);
12323 p
+= strnlen ((char *) p
, maxlen
) + 1;
12327 printf (_("<corrupt>"));
12328 p
= (unsigned char *) end
;
12334 case 64: /* Tag_nodefaults. */
12335 /* PR 17531: file: 001-505008-0.01. */
12338 printf (_("True\n"));
12341 case 65: /* Tag_also_compatible_with. */
12342 val
= read_uleb128 (p
, &len
, end
);
12344 if (val
== 6 /* Tag_CPU_arch. */)
12346 val
= read_uleb128 (p
, &len
, end
);
12348 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12349 printf ("??? (%d)\n", val
);
12351 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12355 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12360 printf (_("<unknown: %d>\n"), tag
);
12366 return display_tag_value (-1, p
, end
);
12368 return display_tag_value (0, p
, end
);
12371 assert (attr
->type
& 0x80);
12372 val
= read_uleb128 (p
, &len
, end
);
12374 type
= attr
->type
& 0x7f;
12376 printf ("??? (%d)\n", val
);
12378 printf ("%s\n", attr
->table
[val
]);
12383 return display_tag_value (tag
, p
, end
);
12386 static unsigned char *
12387 display_gnu_attribute (unsigned char * p
,
12388 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12389 const unsigned char * const end
)
12395 tag
= read_uleb128 (p
, &len
, end
);
12398 /* Tag_compatibility is the only generic GNU attribute defined at
12402 val
= read_uleb128 (p
, &len
, end
);
12405 printf (_("flag = %d, vendor = "), val
);
12408 printf (_("<corrupt>\n"));
12409 warn (_("corrupt vendor attribute\n"));
12415 size_t maxlen
= (end
- p
) - 1;
12417 print_symbol ((int) maxlen
, (const char *) p
);
12418 p
+= strnlen ((char *) p
, maxlen
) + 1;
12422 printf (_("<corrupt>"));
12423 p
= (unsigned char *) end
;
12430 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12431 return display_proc_gnu_attribute (p
, tag
, end
);
12433 return display_tag_value (tag
, p
, end
);
12436 static unsigned char *
12437 display_power_gnu_attribute (unsigned char * p
,
12439 const unsigned char * const end
)
12444 if (tag
== Tag_GNU_Power_ABI_FP
)
12446 val
= read_uleb128 (p
, &len
, end
);
12448 printf (" Tag_GNU_Power_ABI_FP: ");
12453 printf (_("Hard or soft float\n"));
12456 printf (_("Hard float\n"));
12459 printf (_("Soft float\n"));
12462 printf (_("Single-precision hard float\n"));
12465 printf ("??? (%d)\n", val
);
12471 if (tag
== Tag_GNU_Power_ABI_Vector
)
12473 val
= read_uleb128 (p
, &len
, end
);
12475 printf (" Tag_GNU_Power_ABI_Vector: ");
12479 printf (_("Any\n"));
12482 printf (_("Generic\n"));
12485 printf ("AltiVec\n");
12491 printf ("??? (%d)\n", val
);
12497 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12501 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12505 val
= read_uleb128 (p
, &len
, end
);
12507 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12511 printf (_("Any\n"));
12514 printf ("r3/r4\n");
12517 printf (_("Memory\n"));
12520 printf ("??? (%d)\n", val
);
12526 return display_tag_value (tag
& 1, p
, end
);
12530 display_sparc_hwcaps (int mask
)
12536 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12537 fputs ("mul32", stdout
), first
= 0;
12538 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12539 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12540 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12541 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12542 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12543 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12544 if (mask
& ELF_SPARC_HWCAP_POPC
)
12545 printf ("%spopc", first
? "" : "|"), first
= 0;
12546 if (mask
& ELF_SPARC_HWCAP_VIS
)
12547 printf ("%svis", first
? "" : "|"), first
= 0;
12548 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12549 printf ("%svis2", first
? "" : "|"), first
= 0;
12550 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12551 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12552 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12553 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12554 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12555 printf ("%svis3", first
? "" : "|"), first
= 0;
12556 if (mask
& ELF_SPARC_HWCAP_HPC
)
12557 printf ("%shpc", first
? "" : "|"), first
= 0;
12558 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12559 printf ("%srandom", first
? "" : "|"), first
= 0;
12560 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12561 printf ("%strans", first
? "" : "|"), first
= 0;
12562 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12563 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12564 if (mask
& ELF_SPARC_HWCAP_IMA
)
12565 printf ("%sima", first
? "" : "|"), first
= 0;
12566 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12567 printf ("%scspare", first
? "" : "|"), first
= 0;
12570 fputc ('0', stdout
);
12571 fputc ('\n', stdout
);
12575 display_sparc_hwcaps2 (int mask
)
12581 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12582 fputs ("fjathplus", stdout
), first
= 0;
12583 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12584 printf ("%svis3b", first
? "" : "|"), first
= 0;
12585 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12586 printf ("%sadp", first
? "" : "|"), first
= 0;
12587 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12588 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12589 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12590 printf ("%smwait", first
? "" : "|"), first
= 0;
12591 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12592 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12593 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12594 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12595 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12596 printf ("%snsec", first
? "" : "|"), first
= 0;
12597 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12598 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12599 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12600 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12601 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12602 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12605 fputc ('0', stdout
);
12606 fputc ('\n', stdout
);
12609 static unsigned char *
12610 display_sparc_gnu_attribute (unsigned char * p
,
12612 const unsigned char * const end
)
12617 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12619 val
= read_uleb128 (p
, &len
, end
);
12621 printf (" Tag_GNU_Sparc_HWCAPS: ");
12622 display_sparc_hwcaps (val
);
12625 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12627 val
= read_uleb128 (p
, &len
, end
);
12629 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12630 display_sparc_hwcaps2 (val
);
12634 return display_tag_value (tag
, p
, end
);
12638 print_mips_fp_abi_value (int val
)
12642 case Val_GNU_MIPS_ABI_FP_ANY
:
12643 printf (_("Hard or soft float\n"));
12645 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12646 printf (_("Hard float (double precision)\n"));
12648 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12649 printf (_("Hard float (single precision)\n"));
12651 case Val_GNU_MIPS_ABI_FP_SOFT
:
12652 printf (_("Soft float\n"));
12654 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12655 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12657 case Val_GNU_MIPS_ABI_FP_XX
:
12658 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12660 case Val_GNU_MIPS_ABI_FP_64
:
12661 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12663 case Val_GNU_MIPS_ABI_FP_64A
:
12664 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12667 printf ("??? (%d)\n", val
);
12672 static unsigned char *
12673 display_mips_gnu_attribute (unsigned char * p
,
12675 const unsigned char * const end
)
12677 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12682 val
= read_uleb128 (p
, &len
, end
);
12684 printf (" Tag_GNU_MIPS_ABI_FP: ");
12686 print_mips_fp_abi_value (val
);
12691 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12696 val
= read_uleb128 (p
, &len
, end
);
12698 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12702 case Val_GNU_MIPS_ABI_MSA_ANY
:
12703 printf (_("Any MSA or not\n"));
12705 case Val_GNU_MIPS_ABI_MSA_128
:
12706 printf (_("128-bit MSA\n"));
12709 printf ("??? (%d)\n", val
);
12715 return display_tag_value (tag
& 1, p
, end
);
12718 static unsigned char *
12719 display_tic6x_attribute (unsigned char * p
,
12720 const unsigned char * const end
)
12726 tag
= read_uleb128 (p
, &len
, end
);
12732 val
= read_uleb128 (p
, &len
, end
);
12734 printf (" Tag_ISA: ");
12738 case C6XABI_Tag_ISA_none
:
12739 printf (_("None\n"));
12741 case C6XABI_Tag_ISA_C62X
:
12744 case C6XABI_Tag_ISA_C67X
:
12747 case C6XABI_Tag_ISA_C67XP
:
12748 printf ("C67x+\n");
12750 case C6XABI_Tag_ISA_C64X
:
12753 case C6XABI_Tag_ISA_C64XP
:
12754 printf ("C64x+\n");
12756 case C6XABI_Tag_ISA_C674X
:
12757 printf ("C674x\n");
12760 printf ("??? (%d)\n", val
);
12765 case Tag_ABI_wchar_t
:
12766 val
= read_uleb128 (p
, &len
, end
);
12768 printf (" Tag_ABI_wchar_t: ");
12772 printf (_("Not used\n"));
12775 printf (_("2 bytes\n"));
12778 printf (_("4 bytes\n"));
12781 printf ("??? (%d)\n", val
);
12786 case Tag_ABI_stack_align_needed
:
12787 val
= read_uleb128 (p
, &len
, end
);
12789 printf (" Tag_ABI_stack_align_needed: ");
12793 printf (_("8-byte\n"));
12796 printf (_("16-byte\n"));
12799 printf ("??? (%d)\n", val
);
12804 case Tag_ABI_stack_align_preserved
:
12805 val
= read_uleb128 (p
, &len
, end
);
12807 printf (" Tag_ABI_stack_align_preserved: ");
12811 printf (_("8-byte\n"));
12814 printf (_("16-byte\n"));
12817 printf ("??? (%d)\n", val
);
12823 val
= read_uleb128 (p
, &len
, end
);
12825 printf (" Tag_ABI_DSBT: ");
12829 printf (_("DSBT addressing not used\n"));
12832 printf (_("DSBT addressing used\n"));
12835 printf ("??? (%d)\n", val
);
12841 val
= read_uleb128 (p
, &len
, end
);
12843 printf (" Tag_ABI_PID: ");
12847 printf (_("Data addressing position-dependent\n"));
12850 printf (_("Data addressing position-independent, GOT near DP\n"));
12853 printf (_("Data addressing position-independent, GOT far from DP\n"));
12856 printf ("??? (%d)\n", val
);
12862 val
= read_uleb128 (p
, &len
, end
);
12864 printf (" Tag_ABI_PIC: ");
12868 printf (_("Code addressing position-dependent\n"));
12871 printf (_("Code addressing position-independent\n"));
12874 printf ("??? (%d)\n", val
);
12879 case Tag_ABI_array_object_alignment
:
12880 val
= read_uleb128 (p
, &len
, end
);
12882 printf (" Tag_ABI_array_object_alignment: ");
12886 printf (_("8-byte\n"));
12889 printf (_("4-byte\n"));
12892 printf (_("16-byte\n"));
12895 printf ("??? (%d)\n", val
);
12900 case Tag_ABI_array_object_align_expected
:
12901 val
= read_uleb128 (p
, &len
, end
);
12903 printf (" Tag_ABI_array_object_align_expected: ");
12907 printf (_("8-byte\n"));
12910 printf (_("4-byte\n"));
12913 printf (_("16-byte\n"));
12916 printf ("??? (%d)\n", val
);
12921 case Tag_ABI_compatibility
:
12923 val
= read_uleb128 (p
, &len
, end
);
12925 printf (" Tag_ABI_compatibility: ");
12926 printf (_("flag = %d, vendor = "), val
);
12929 size_t maxlen
= (end
- p
) - 1;
12931 print_symbol ((int) maxlen
, (const char *) p
);
12932 p
+= strnlen ((char *) p
, maxlen
) + 1;
12936 printf (_("<corrupt>"));
12937 p
= (unsigned char *) end
;
12943 case Tag_ABI_conformance
:
12945 printf (" Tag_ABI_conformance: \"");
12948 size_t maxlen
= (end
- p
) - 1;
12950 print_symbol ((int) maxlen
, (const char *) p
);
12951 p
+= strnlen ((char *) p
, maxlen
) + 1;
12955 printf (_("<corrupt>"));
12956 p
= (unsigned char *) end
;
12963 return display_tag_value (tag
, p
, end
);
12967 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12969 unsigned long addr
= 0;
12970 size_t bytes
= end
- p
;
12977 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12979 printf (" 0x%8.8lx ", addr
);
12981 for (j
= 0; j
< 16; j
++)
12984 printf ("%2.2x", p
[j
]);
12992 for (j
= 0; j
< lbytes
; j
++)
12995 if (k
>= ' ' && k
< 0x7f)
13011 static unsigned char *
13012 display_msp430x_attribute (unsigned char * p
,
13013 const unsigned char * const end
)
13019 tag
= read_uleb128 (p
, & len
, end
);
13024 case OFBA_MSPABI_Tag_ISA
:
13025 val
= read_uleb128 (p
, &len
, end
);
13027 printf (" Tag_ISA: ");
13030 case 0: printf (_("None\n")); break;
13031 case 1: printf (_("MSP430\n")); break;
13032 case 2: printf (_("MSP430X\n")); break;
13033 default: printf ("??? (%d)\n", val
); break;
13037 case OFBA_MSPABI_Tag_Code_Model
:
13038 val
= read_uleb128 (p
, &len
, end
);
13040 printf (" Tag_Code_Model: ");
13043 case 0: printf (_("None\n")); break;
13044 case 1: printf (_("Small\n")); break;
13045 case 2: printf (_("Large\n")); break;
13046 default: printf ("??? (%d)\n", val
); break;
13050 case OFBA_MSPABI_Tag_Data_Model
:
13051 val
= read_uleb128 (p
, &len
, end
);
13053 printf (" Tag_Data_Model: ");
13056 case 0: printf (_("None\n")); break;
13057 case 1: printf (_("Small\n")); break;
13058 case 2: printf (_("Large\n")); break;
13059 case 3: printf (_("Restricted Large\n")); break;
13060 default: printf ("??? (%d)\n", val
); break;
13065 printf (_(" <unknown tag %d>: "), tag
);
13072 size_t maxlen
= (end
- p
) - 1;
13074 print_symbol ((int) maxlen
, (const char *) p
);
13075 p
+= strnlen ((char *) p
, maxlen
) + 1;
13079 printf (_("<corrupt>"));
13080 p
= (unsigned char *) end
;
13086 val
= read_uleb128 (p
, &len
, end
);
13088 printf ("%d (0x%x)\n", val
, val
);
13098 process_attributes (FILE * file
,
13099 const char * public_name
,
13100 unsigned int proc_type
,
13101 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13102 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13104 Elf_Internal_Shdr
* sect
;
13107 /* Find the section header so that we get the size. */
13108 for (i
= 0, sect
= section_headers
;
13109 i
< elf_header
.e_shnum
;
13112 unsigned char * contents
;
13115 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13118 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13119 sect
->sh_size
, _("attributes"));
13120 if (contents
== NULL
)
13126 bfd_vma section_len
;
13128 section_len
= sect
->sh_size
- 1;
13131 while (section_len
> 0)
13134 unsigned int namelen
;
13135 bfd_boolean public_section
;
13136 bfd_boolean gnu_section
;
13138 if (section_len
<= 4)
13140 error (_("Tag section ends prematurely\n"));
13143 attr_len
= byte_get (p
, 4);
13146 if (attr_len
> section_len
)
13148 error (_("Bad attribute length (%u > %u)\n"),
13149 (unsigned) attr_len
, (unsigned) section_len
);
13150 attr_len
= section_len
;
13152 /* PR 17531: file: 001-101425-0.004 */
13153 else if (attr_len
< 5)
13155 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13159 section_len
-= attr_len
;
13162 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13163 if (namelen
== 0 || namelen
>= attr_len
)
13165 error (_("Corrupt attribute section name\n"));
13169 printf (_("Attribute Section: "));
13170 print_symbol (INT_MAX
, (const char *) p
);
13173 if (public_name
&& streq ((char *) p
, public_name
))
13174 public_section
= TRUE
;
13176 public_section
= FALSE
;
13178 if (streq ((char *) p
, "gnu"))
13179 gnu_section
= TRUE
;
13181 gnu_section
= FALSE
;
13184 attr_len
-= namelen
;
13186 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13191 unsigned char * end
;
13193 /* PR binutils/17531: Safe handling of corrupt files. */
13196 error (_("Unused bytes at end of section\n"));
13202 size
= byte_get (p
, 4);
13203 if (size
> attr_len
)
13205 error (_("Bad subsection length (%u > %u)\n"),
13206 (unsigned) size
, (unsigned) attr_len
);
13209 /* PR binutils/17531: Safe handling of corrupt files. */
13212 error (_("Bad subsection length (%u < 6)\n"),
13219 end
= p
+ size
- 1;
13220 assert (end
<= contents
+ sect
->sh_size
);
13226 printf (_("File Attributes\n"));
13229 printf (_("Section Attributes:"));
13232 printf (_("Symbol Attributes:"));
13238 val
= read_uleb128 (p
, &j
, end
);
13242 printf (" %d", val
);
13247 printf (_("Unknown tag: %d\n"), tag
);
13248 public_section
= FALSE
;
13252 if (public_section
&& display_pub_attribute
!= NULL
)
13255 p
= display_pub_attribute (p
, end
);
13258 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13261 p
= display_gnu_attribute (p
,
13262 display_proc_gnu_attribute
,
13268 printf (_(" Unknown attribute:\n"));
13269 display_raw_attribute (p
, end
);
13278 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13286 process_arm_specific (FILE * file
)
13288 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13289 display_arm_attribute
, NULL
);
13293 process_power_specific (FILE * file
)
13295 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13296 display_power_gnu_attribute
);
13300 process_sparc_specific (FILE * file
)
13302 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13303 display_sparc_gnu_attribute
);
13307 process_tic6x_specific (FILE * file
)
13309 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13310 display_tic6x_attribute
, NULL
);
13314 process_msp430x_specific (FILE * file
)
13316 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13317 display_msp430x_attribute
, NULL
);
13320 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13321 Print the Address, Access and Initial fields of an entry at VMA ADDR
13322 and return the VMA of the next entry. */
13325 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13328 print_vma (addr
, LONG_HEX
);
13330 if (addr
< pltgot
+ 0xfff0)
13331 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13333 printf ("%10s", "");
13336 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13341 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13342 print_vma (entry
, LONG_HEX
);
13344 return addr
+ (is_32bit_elf
? 4 : 8);
13347 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13348 PLTGOT. Print the Address and Initial fields of an entry at VMA
13349 ADDR and return the VMA of the next entry. */
13352 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
13355 print_vma (addr
, LONG_HEX
);
13358 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13363 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13364 print_vma (entry
, LONG_HEX
);
13366 return addr
+ (is_32bit_elf
? 4 : 8);
13370 print_mips_ases (unsigned int mask
)
13372 if (mask
& AFL_ASE_DSP
)
13373 fputs ("\n\tDSP ASE", stdout
);
13374 if (mask
& AFL_ASE_DSPR2
)
13375 fputs ("\n\tDSP R2 ASE", stdout
);
13376 if (mask
& AFL_ASE_EVA
)
13377 fputs ("\n\tEnhanced VA Scheme", stdout
);
13378 if (mask
& AFL_ASE_MCU
)
13379 fputs ("\n\tMCU (MicroController) ASE", stdout
);
13380 if (mask
& AFL_ASE_MDMX
)
13381 fputs ("\n\tMDMX ASE", stdout
);
13382 if (mask
& AFL_ASE_MIPS3D
)
13383 fputs ("\n\tMIPS-3D ASE", stdout
);
13384 if (mask
& AFL_ASE_MT
)
13385 fputs ("\n\tMT ASE", stdout
);
13386 if (mask
& AFL_ASE_SMARTMIPS
)
13387 fputs ("\n\tSmartMIPS ASE", stdout
);
13388 if (mask
& AFL_ASE_VIRT
)
13389 fputs ("\n\tVZ ASE", stdout
);
13390 if (mask
& AFL_ASE_MSA
)
13391 fputs ("\n\tMSA ASE", stdout
);
13392 if (mask
& AFL_ASE_MIPS16
)
13393 fputs ("\n\tMIPS16 ASE", stdout
);
13394 if (mask
& AFL_ASE_MICROMIPS
)
13395 fputs ("\n\tMICROMIPS ASE", stdout
);
13396 if (mask
& AFL_ASE_XPA
)
13397 fputs ("\n\tXPA ASE", stdout
);
13399 fprintf (stdout
, "\n\t%s", _("None"));
13400 else if ((mask
& ~AFL_ASE_MASK
) != 0)
13401 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
13405 print_mips_isa_ext (unsigned int isa_ext
)
13410 fputs (_("None"), stdout
);
13413 fputs ("RMI XLR", stdout
);
13415 case AFL_EXT_OCTEON3
:
13416 fputs ("Cavium Networks Octeon3", stdout
);
13418 case AFL_EXT_OCTEON2
:
13419 fputs ("Cavium Networks Octeon2", stdout
);
13421 case AFL_EXT_OCTEONP
:
13422 fputs ("Cavium Networks OcteonP", stdout
);
13424 case AFL_EXT_LOONGSON_3A
:
13425 fputs ("Loongson 3A", stdout
);
13427 case AFL_EXT_OCTEON
:
13428 fputs ("Cavium Networks Octeon", stdout
);
13431 fputs ("Toshiba R5900", stdout
);
13434 fputs ("MIPS R4650", stdout
);
13437 fputs ("LSI R4010", stdout
);
13440 fputs ("NEC VR4100", stdout
);
13443 fputs ("Toshiba R3900", stdout
);
13445 case AFL_EXT_10000
:
13446 fputs ("MIPS R10000", stdout
);
13449 fputs ("Broadcom SB-1", stdout
);
13452 fputs ("NEC VR4111/VR4181", stdout
);
13455 fputs ("NEC VR4120", stdout
);
13458 fputs ("NEC VR5400", stdout
);
13461 fputs ("NEC VR5500", stdout
);
13463 case AFL_EXT_LOONGSON_2E
:
13464 fputs ("ST Microelectronics Loongson 2E", stdout
);
13466 case AFL_EXT_LOONGSON_2F
:
13467 fputs ("ST Microelectronics Loongson 2F", stdout
);
13470 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13475 get_mips_reg_size (int reg_size
)
13477 return (reg_size
== AFL_REG_NONE
) ? 0
13478 : (reg_size
== AFL_REG_32
) ? 32
13479 : (reg_size
== AFL_REG_64
) ? 64
13480 : (reg_size
== AFL_REG_128
) ? 128
13485 process_mips_specific (FILE * file
)
13487 Elf_Internal_Dyn
* entry
;
13488 Elf_Internal_Shdr
*sect
= NULL
;
13489 size_t liblist_offset
= 0;
13490 size_t liblistno
= 0;
13491 size_t conflictsno
= 0;
13492 size_t options_offset
= 0;
13493 size_t conflicts_offset
= 0;
13494 size_t pltrelsz
= 0;
13496 bfd_vma pltgot
= 0;
13497 bfd_vma mips_pltgot
= 0;
13498 bfd_vma jmprel
= 0;
13499 bfd_vma local_gotno
= 0;
13500 bfd_vma gotsym
= 0;
13501 bfd_vma symtabno
= 0;
13503 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13504 display_mips_gnu_attribute
);
13506 sect
= find_section (".MIPS.abiflags");
13510 Elf_External_ABIFlags_v0
*abiflags_ext
;
13511 Elf_Internal_ABIFlags_v0 abiflags_in
;
13513 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13514 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13517 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13518 sect
->sh_size
, _("MIPS ABI Flags section"));
13521 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13522 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13523 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13524 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13525 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13526 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13527 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13528 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13529 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13530 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13531 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13533 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13534 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13535 if (abiflags_in
.isa_rev
> 1)
13536 printf ("r%d", abiflags_in
.isa_rev
);
13537 printf ("\nGPR size: %d",
13538 get_mips_reg_size (abiflags_in
.gpr_size
));
13539 printf ("\nCPR1 size: %d",
13540 get_mips_reg_size (abiflags_in
.cpr1_size
));
13541 printf ("\nCPR2 size: %d",
13542 get_mips_reg_size (abiflags_in
.cpr2_size
));
13543 fputs ("\nFP ABI: ", stdout
);
13544 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13545 fputs ("ISA Extension: ", stdout
);
13546 print_mips_isa_ext (abiflags_in
.isa_ext
);
13547 fputs ("\nASEs:", stdout
);
13548 print_mips_ases (abiflags_in
.ases
);
13549 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13550 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13551 fputc ('\n', stdout
);
13552 free (abiflags_ext
);
13557 /* We have a lot of special sections. Thanks SGI! */
13558 if (dynamic_section
== NULL
)
13559 /* No information available. */
13562 for (entry
= dynamic_section
;
13563 /* PR 17531 file: 012-50589-0.004. */
13564 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
13566 switch (entry
->d_tag
)
13568 case DT_MIPS_LIBLIST
:
13570 = offset_from_vma (file
, entry
->d_un
.d_val
,
13571 liblistno
* sizeof (Elf32_External_Lib
));
13573 case DT_MIPS_LIBLISTNO
:
13574 liblistno
= entry
->d_un
.d_val
;
13576 case DT_MIPS_OPTIONS
:
13577 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13579 case DT_MIPS_CONFLICT
:
13581 = offset_from_vma (file
, entry
->d_un
.d_val
,
13582 conflictsno
* sizeof (Elf32_External_Conflict
));
13584 case DT_MIPS_CONFLICTNO
:
13585 conflictsno
= entry
->d_un
.d_val
;
13588 pltgot
= entry
->d_un
.d_ptr
;
13590 case DT_MIPS_LOCAL_GOTNO
:
13591 local_gotno
= entry
->d_un
.d_val
;
13593 case DT_MIPS_GOTSYM
:
13594 gotsym
= entry
->d_un
.d_val
;
13596 case DT_MIPS_SYMTABNO
:
13597 symtabno
= entry
->d_un
.d_val
;
13599 case DT_MIPS_PLTGOT
:
13600 mips_pltgot
= entry
->d_un
.d_ptr
;
13603 pltrel
= entry
->d_un
.d_val
;
13606 pltrelsz
= entry
->d_un
.d_val
;
13609 jmprel
= entry
->d_un
.d_ptr
;
13615 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13617 Elf32_External_Lib
* elib
;
13620 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13622 sizeof (Elf32_External_Lib
),
13623 _("liblist section data"));
13626 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13627 (unsigned long) liblistno
);
13628 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13631 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13638 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13639 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13640 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13641 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13642 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13644 tmp
= gmtime (&atime
);
13645 snprintf (timebuf
, sizeof (timebuf
),
13646 "%04u-%02u-%02uT%02u:%02u:%02u",
13647 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13648 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13650 printf ("%3lu: ", (unsigned long) cnt
);
13651 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13652 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13654 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13655 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13656 liblist
.l_version
);
13658 if (liblist
.l_flags
== 0)
13662 static const struct
13669 { " EXACT_MATCH", LL_EXACT_MATCH
},
13670 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13671 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13672 { " EXPORTS", LL_EXPORTS
},
13673 { " DELAY_LOAD", LL_DELAY_LOAD
},
13674 { " DELTA", LL_DELTA
}
13676 int flags
= liblist
.l_flags
;
13679 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13680 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13682 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13683 flags
^= l_flags_vals
[fcnt
].bit
;
13686 printf (" %#x", (unsigned int) flags
);
13696 if (options_offset
!= 0)
13698 Elf_External_Options
* eopt
;
13699 Elf_Internal_Options
* iopt
;
13700 Elf_Internal_Options
* option
;
13703 sect
= section_headers
;
13705 /* Find the section header so that we get the size. */
13706 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
13707 /* PR 17533 file: 012-277276-0.004. */
13710 error (_("No MIPS_OPTIONS header found\n"));
13714 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13715 sect
->sh_size
, _("options"));
13718 iopt
= (Elf_Internal_Options
*)
13719 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13722 error (_("Out of memory allocatinf space for MIPS options\n"));
13729 while (offset
< sect
->sh_size
)
13731 Elf_External_Options
* eoption
;
13733 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13735 option
->kind
= BYTE_GET (eoption
->kind
);
13736 option
->size
= BYTE_GET (eoption
->size
);
13737 option
->section
= BYTE_GET (eoption
->section
);
13738 option
->info
= BYTE_GET (eoption
->info
);
13740 offset
+= option
->size
;
13746 printf (_("\nSection '%s' contains %d entries:\n"),
13747 printable_section_name (sect
), cnt
);
13755 switch (option
->kind
)
13758 /* This shouldn't happen. */
13759 printf (" NULL %d %lx", option
->section
, option
->info
);
13762 printf (" REGINFO ");
13763 if (elf_header
.e_machine
== EM_MIPS
)
13766 Elf32_External_RegInfo
* ereg
;
13767 Elf32_RegInfo reginfo
;
13769 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13770 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13771 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13772 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13773 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13774 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13775 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13777 printf ("GPR %08lx GP 0x%lx\n",
13778 reginfo
.ri_gprmask
,
13779 (unsigned long) reginfo
.ri_gp_value
);
13780 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13781 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13782 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13787 Elf64_External_RegInfo
* ereg
;
13788 Elf64_Internal_RegInfo reginfo
;
13790 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13791 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13792 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13793 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13794 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13795 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13796 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13798 printf ("GPR %08lx GP 0x",
13799 reginfo
.ri_gprmask
);
13800 printf_vma (reginfo
.ri_gp_value
);
13803 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13804 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13805 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13809 case ODK_EXCEPTIONS
:
13810 fputs (" EXCEPTIONS fpe_min(", stdout
);
13811 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13812 fputs (") fpe_max(", stdout
);
13813 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13814 fputs (")", stdout
);
13816 if (option
->info
& OEX_PAGE0
)
13817 fputs (" PAGE0", stdout
);
13818 if (option
->info
& OEX_SMM
)
13819 fputs (" SMM", stdout
);
13820 if (option
->info
& OEX_FPDBUG
)
13821 fputs (" FPDBUG", stdout
);
13822 if (option
->info
& OEX_DISMISS
)
13823 fputs (" DISMISS", stdout
);
13826 fputs (" PAD ", stdout
);
13827 if (option
->info
& OPAD_PREFIX
)
13828 fputs (" PREFIX", stdout
);
13829 if (option
->info
& OPAD_POSTFIX
)
13830 fputs (" POSTFIX", stdout
);
13831 if (option
->info
& OPAD_SYMBOL
)
13832 fputs (" SYMBOL", stdout
);
13835 fputs (" HWPATCH ", stdout
);
13836 if (option
->info
& OHW_R4KEOP
)
13837 fputs (" R4KEOP", stdout
);
13838 if (option
->info
& OHW_R8KPFETCH
)
13839 fputs (" R8KPFETCH", stdout
);
13840 if (option
->info
& OHW_R5KEOP
)
13841 fputs (" R5KEOP", stdout
);
13842 if (option
->info
& OHW_R5KCVTL
)
13843 fputs (" R5KCVTL", stdout
);
13846 fputs (" FILL ", stdout
);
13847 /* XXX Print content of info word? */
13850 fputs (" TAGS ", stdout
);
13851 /* XXX Print content of info word? */
13854 fputs (" HWAND ", stdout
);
13855 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13856 fputs (" R4KEOP_CHECKED", stdout
);
13857 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13858 fputs (" R4KEOP_CLEAN", stdout
);
13861 fputs (" HWOR ", stdout
);
13862 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13863 fputs (" R4KEOP_CHECKED", stdout
);
13864 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13865 fputs (" R4KEOP_CLEAN", stdout
);
13868 printf (" GP_GROUP %#06lx self-contained %#06lx",
13869 option
->info
& OGP_GROUP
,
13870 (option
->info
& OGP_SELF
) >> 16);
13873 printf (" IDENT %#06lx self-contained %#06lx",
13874 option
->info
& OGP_GROUP
,
13875 (option
->info
& OGP_SELF
) >> 16);
13878 /* This shouldn't happen. */
13879 printf (" %3d ??? %d %lx",
13880 option
->kind
, option
->section
, option
->info
);
13884 len
= sizeof (* eopt
);
13885 while (len
< option
->size
)
13886 if (((char *) option
)[len
] >= ' '
13887 && ((char *) option
)[len
] < 0x7f)
13888 printf ("%c", ((char *) option
)[len
++]);
13890 printf ("\\%03o", ((char *) option
)[len
++]);
13892 fputs ("\n", stdout
);
13900 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13902 Elf32_Conflict
* iconf
;
13905 if (dynamic_symbols
== NULL
)
13907 error (_("conflict list found without a dynamic symbol table\n"));
13911 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13914 error (_("Out of memory allocating space for dynamic conflicts\n"));
13920 Elf32_External_Conflict
* econf32
;
13922 econf32
= (Elf32_External_Conflict
*)
13923 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13924 sizeof (* econf32
), _("conflict"));
13928 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13929 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13935 Elf64_External_Conflict
* econf64
;
13937 econf64
= (Elf64_External_Conflict
*)
13938 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13939 sizeof (* econf64
), _("conflict"));
13943 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13944 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13949 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13950 (unsigned long) conflictsno
);
13951 puts (_(" Num: Index Value Name"));
13953 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13955 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13957 if (iconf
[cnt
] >= num_dynamic_syms
)
13958 printf (_("<corrupt symbol index>"));
13961 Elf_Internal_Sym
* psym
;
13963 psym
= & dynamic_symbols
[iconf
[cnt
]];
13964 print_vma (psym
->st_value
, FULL_HEX
);
13966 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13967 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13969 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13977 if (pltgot
!= 0 && local_gotno
!= 0)
13979 bfd_vma ent
, local_end
, global_end
;
13981 unsigned char * data
;
13985 addr_size
= (is_32bit_elf
? 4 : 8);
13986 local_end
= pltgot
+ local_gotno
* addr_size
;
13988 /* PR binutils/17533 file: 012-111227-0.004 */
13989 if (symtabno
< gotsym
)
13991 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13992 (long) gotsym
, (long) symtabno
);
13996 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13997 assert (global_end
>= local_end
);
13998 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13999 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14000 global_end
- pltgot
, 1,
14001 _("Global Offset Table data"));
14005 printf (_("\nPrimary GOT:\n"));
14006 printf (_(" Canonical gp value: "));
14007 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14010 printf (_(" Reserved entries:\n"));
14011 printf (_(" %*s %10s %*s Purpose\n"),
14012 addr_size
* 2, _("Address"), _("Access"),
14013 addr_size
* 2, _("Initial"));
14014 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14015 printf (_(" Lazy resolver\n"));
14017 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14018 >> (addr_size
* 8 - 1)) != 0)
14020 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14021 printf (_(" Module pointer (GNU extension)\n"));
14025 if (ent
< local_end
)
14027 printf (_(" Local entries:\n"));
14028 printf (" %*s %10s %*s\n",
14029 addr_size
* 2, _("Address"), _("Access"),
14030 addr_size
* 2, _("Initial"));
14031 while (ent
< local_end
)
14033 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14039 if (gotsym
< symtabno
)
14043 printf (_(" Global entries:\n"));
14044 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14045 addr_size
* 2, _("Address"),
14047 addr_size
* 2, _("Initial"),
14048 addr_size
* 2, _("Sym.Val."),
14050 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14051 _("Ndx"), _("Name"));
14053 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14055 for (i
= gotsym
; i
< symtabno
; i
++)
14057 ent
= print_mips_got_entry (data
, pltgot
, ent
);
14060 if (dynamic_symbols
== NULL
)
14061 printf (_("<no dynamic symbols>"));
14062 else if (i
< num_dynamic_syms
)
14064 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14066 print_vma (psym
->st_value
, LONG_HEX
);
14067 printf (" %-7s %3s ",
14068 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14069 get_symbol_index_type (psym
->st_shndx
));
14071 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14072 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14074 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14077 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14078 (unsigned long) i
);
14089 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14092 size_t offset
, rel_offset
;
14093 unsigned long count
, i
;
14094 unsigned char * data
;
14095 int addr_size
, sym_width
;
14096 Elf_Internal_Rela
* rels
;
14098 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14099 if (pltrel
== DT_RELA
)
14101 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14106 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14111 addr_size
= (is_32bit_elf
? 4 : 8);
14112 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14114 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14115 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14116 1, _("Procedure Linkage Table data"));
14120 printf ("\nPLT GOT:\n\n");
14121 printf (_(" Reserved entries:\n"));
14122 printf (_(" %*s %*s Purpose\n"),
14123 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14124 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14125 printf (_(" PLT lazy resolver\n"));
14126 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14127 printf (_(" Module pointer\n"));
14130 printf (_(" Entries:\n"));
14131 printf (" %*s %*s %*s %-7s %3s %s\n",
14132 addr_size
* 2, _("Address"),
14133 addr_size
* 2, _("Initial"),
14134 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14135 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14136 for (i
= 0; i
< count
; i
++)
14138 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14140 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14143 if (idx
>= num_dynamic_syms
)
14144 printf (_("<corrupt symbol index: %lu>"), idx
);
14147 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14149 print_vma (psym
->st_value
, LONG_HEX
);
14150 printf (" %-7s %3s ",
14151 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14152 get_symbol_index_type (psym
->st_shndx
));
14153 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14154 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14156 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14171 process_nds32_specific (FILE * file
)
14173 Elf_Internal_Shdr
*sect
= NULL
;
14175 sect
= find_section (".nds32_e_flags");
14178 unsigned int *flag
;
14180 printf ("\nNDS32 elf flags section:\n");
14181 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14182 sect
->sh_size
, _("NDS32 elf flags section"));
14184 switch ((*flag
) & 0x3)
14187 printf ("(VEC_SIZE):\tNo entry.\n");
14190 printf ("(VEC_SIZE):\t4 bytes\n");
14193 printf ("(VEC_SIZE):\t16 bytes\n");
14196 printf ("(VEC_SIZE):\treserved\n");
14205 process_gnu_liblist (FILE * file
)
14207 Elf_Internal_Shdr
* section
;
14208 Elf_Internal_Shdr
* string_sec
;
14209 Elf32_External_Lib
* elib
;
14211 size_t strtab_size
;
14218 for (i
= 0, section
= section_headers
;
14219 i
< elf_header
.e_shnum
;
14222 switch (section
->sh_type
)
14224 case SHT_GNU_LIBLIST
:
14225 if (section
->sh_link
>= elf_header
.e_shnum
)
14228 elib
= (Elf32_External_Lib
*)
14229 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14230 _("liblist section data"));
14234 string_sec
= section_headers
+ section
->sh_link
;
14236 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14237 string_sec
->sh_size
,
14238 _("liblist string table"));
14240 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14246 strtab_size
= string_sec
->sh_size
;
14248 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14249 printable_section_name (section
),
14250 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14252 puts (_(" Library Time Stamp Checksum Version Flags"));
14254 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14262 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14263 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14264 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14265 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14266 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14268 tmp
= gmtime (&atime
);
14269 snprintf (timebuf
, sizeof (timebuf
),
14270 "%04u-%02u-%02uT%02u:%02u:%02u",
14271 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14272 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14274 printf ("%3lu: ", (unsigned long) cnt
);
14276 printf ("%-20s", liblist
.l_name
< strtab_size
14277 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14279 printf ("%-20.20s", liblist
.l_name
< strtab_size
14280 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14281 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14282 liblist
.l_version
, liblist
.l_flags
);
14293 static const char *
14294 get_note_type (unsigned e_type
)
14296 static char buff
[64];
14298 if (elf_header
.e_type
== ET_CORE
)
14302 return _("NT_AUXV (auxiliary vector)");
14304 return _("NT_PRSTATUS (prstatus structure)");
14306 return _("NT_FPREGSET (floating point registers)");
14308 return _("NT_PRPSINFO (prpsinfo structure)");
14309 case NT_TASKSTRUCT
:
14310 return _("NT_TASKSTRUCT (task structure)");
14312 return _("NT_PRXFPREG (user_xfpregs structure)");
14314 return _("NT_PPC_VMX (ppc Altivec registers)");
14316 return _("NT_PPC_VSX (ppc VSX registers)");
14318 return _("NT_386_TLS (x86 TLS information)");
14319 case NT_386_IOPERM
:
14320 return _("NT_386_IOPERM (x86 I/O permissions)");
14321 case NT_X86_XSTATE
:
14322 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14323 case NT_S390_HIGH_GPRS
:
14324 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14325 case NT_S390_TIMER
:
14326 return _("NT_S390_TIMER (s390 timer register)");
14327 case NT_S390_TODCMP
:
14328 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14329 case NT_S390_TODPREG
:
14330 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14332 return _("NT_S390_CTRS (s390 control registers)");
14333 case NT_S390_PREFIX
:
14334 return _("NT_S390_PREFIX (s390 prefix register)");
14335 case NT_S390_LAST_BREAK
:
14336 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14337 case NT_S390_SYSTEM_CALL
:
14338 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14340 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14342 return _("NT_ARM_VFP (arm VFP registers)");
14344 return _("NT_ARM_TLS (AArch TLS registers)");
14345 case NT_ARM_HW_BREAK
:
14346 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14347 case NT_ARM_HW_WATCH
:
14348 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14350 return _("NT_PSTATUS (pstatus structure)");
14352 return _("NT_FPREGS (floating point registers)");
14354 return _("NT_PSINFO (psinfo structure)");
14356 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14358 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14359 case NT_WIN32PSTATUS
:
14360 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14362 return _("NT_SIGINFO (siginfo_t data)");
14364 return _("NT_FILE (mapped files)");
14372 return _("NT_VERSION (version)");
14374 return _("NT_ARCH (architecture)");
14379 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14384 print_core_note (Elf_Internal_Note
*pnote
)
14386 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
14387 bfd_vma count
, page_size
;
14388 unsigned char *descdata
, *filenames
, *descend
;
14390 if (pnote
->type
!= NT_FILE
)
14396 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14397 /* Still "successful". */
14402 if (pnote
->descsz
< 2 * addr_size
)
14404 printf (_(" Malformed note - too short for header\n"));
14408 descdata
= (unsigned char *) pnote
->descdata
;
14409 descend
= descdata
+ pnote
->descsz
;
14411 if (descdata
[pnote
->descsz
- 1] != '\0')
14413 printf (_(" Malformed note - does not end with \\0\n"));
14417 count
= byte_get (descdata
, addr_size
);
14418 descdata
+= addr_size
;
14420 page_size
= byte_get (descdata
, addr_size
);
14421 descdata
+= addr_size
;
14423 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
14425 printf (_(" Malformed note - too short for supplied file count\n"));
14429 printf (_(" Page size: "));
14430 print_vma (page_size
, DEC
);
14433 printf (_(" %*s%*s%*s\n"),
14434 (int) (2 + 2 * addr_size
), _("Start"),
14435 (int) (4 + 2 * addr_size
), _("End"),
14436 (int) (4 + 2 * addr_size
), _("Page Offset"));
14437 filenames
= descdata
+ count
* 3 * addr_size
;
14438 while (--count
> 0)
14440 bfd_vma start
, end
, file_ofs
;
14442 if (filenames
== descend
)
14444 printf (_(" Malformed note - filenames end too early\n"));
14448 start
= byte_get (descdata
, addr_size
);
14449 descdata
+= addr_size
;
14450 end
= byte_get (descdata
, addr_size
);
14451 descdata
+= addr_size
;
14452 file_ofs
= byte_get (descdata
, addr_size
);
14453 descdata
+= addr_size
;
14456 print_vma (start
, FULL_HEX
);
14458 print_vma (end
, FULL_HEX
);
14460 print_vma (file_ofs
, FULL_HEX
);
14461 printf ("\n %s\n", filenames
);
14463 filenames
+= 1 + strlen ((char *) filenames
);
14469 static const char *
14470 get_gnu_elf_note_type (unsigned e_type
)
14472 static char buff
[64];
14476 case NT_GNU_ABI_TAG
:
14477 return _("NT_GNU_ABI_TAG (ABI version tag)");
14479 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14480 case NT_GNU_BUILD_ID
:
14481 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14482 case NT_GNU_GOLD_VERSION
:
14483 return _("NT_GNU_GOLD_VERSION (gold version)");
14488 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14493 print_gnu_note (Elf_Internal_Note
*pnote
)
14495 switch (pnote
->type
)
14497 case NT_GNU_BUILD_ID
:
14501 printf (_(" Build ID: "));
14502 for (i
= 0; i
< pnote
->descsz
; ++i
)
14503 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14508 case NT_GNU_ABI_TAG
:
14510 unsigned long os
, major
, minor
, subminor
;
14511 const char *osname
;
14513 /* PR 17531: file: 030-599401-0.004. */
14514 if (pnote
->descsz
< 16)
14516 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14520 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14521 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14522 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14523 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14527 case GNU_ABI_TAG_LINUX
:
14530 case GNU_ABI_TAG_HURD
:
14533 case GNU_ABI_TAG_SOLARIS
:
14534 osname
= "Solaris";
14536 case GNU_ABI_TAG_FREEBSD
:
14537 osname
= "FreeBSD";
14539 case GNU_ABI_TAG_NETBSD
:
14543 osname
= "Unknown";
14547 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14548 major
, minor
, subminor
);
14552 case NT_GNU_GOLD_VERSION
:
14556 printf (_(" Version: "));
14557 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14558 printf ("%c", pnote
->descdata
[i
]);
14567 static const char *
14568 get_netbsd_elfcore_note_type (unsigned e_type
)
14570 static char buff
[64];
14572 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14574 /* NetBSD core "procinfo" structure. */
14575 return _("NetBSD procinfo structure");
14578 /* As of Jan 2002 there are no other machine-independent notes
14579 defined for NetBSD core files. If the note type is less
14580 than the start of the machine-dependent note types, we don't
14583 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14585 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14589 switch (elf_header
.e_machine
)
14591 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14592 and PT_GETFPREGS == mach+2. */
14597 case EM_SPARC32PLUS
:
14601 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14602 return _("PT_GETREGS (reg structure)");
14603 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14604 return _("PT_GETFPREGS (fpreg structure)");
14610 /* On all other arch's, PT_GETREGS == mach+1 and
14611 PT_GETFPREGS == mach+3. */
14615 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14616 return _("PT_GETREGS (reg structure)");
14617 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14618 return _("PT_GETFPREGS (fpreg structure)");
14624 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14625 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14629 static const char *
14630 get_stapsdt_note_type (unsigned e_type
)
14632 static char buff
[64];
14637 return _("NT_STAPSDT (SystemTap probe descriptors)");
14643 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14648 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14650 int addr_size
= is_32bit_elf
? 4 : 8;
14651 char *data
= pnote
->descdata
;
14652 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14653 bfd_vma pc
, base_addr
, semaphore
;
14654 char *provider
, *probe
, *arg_fmt
;
14656 pc
= byte_get ((unsigned char *) data
, addr_size
);
14658 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14660 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14664 data
+= strlen (data
) + 1;
14666 data
+= strlen (data
) + 1;
14668 data
+= strlen (data
) + 1;
14670 printf (_(" Provider: %s\n"), provider
);
14671 printf (_(" Name: %s\n"), probe
);
14672 printf (_(" Location: "));
14673 print_vma (pc
, FULL_HEX
);
14674 printf (_(", Base: "));
14675 print_vma (base_addr
, FULL_HEX
);
14676 printf (_(", Semaphore: "));
14677 print_vma (semaphore
, FULL_HEX
);
14679 printf (_(" Arguments: %s\n"), arg_fmt
);
14681 return data
== data_end
;
14684 static const char *
14685 get_ia64_vms_note_type (unsigned e_type
)
14687 static char buff
[64];
14692 return _("NT_VMS_MHD (module header)");
14694 return _("NT_VMS_LNM (language name)");
14696 return _("NT_VMS_SRC (source files)");
14698 return "NT_VMS_TITLE";
14700 return _("NT_VMS_EIDC (consistency check)");
14701 case NT_VMS_FPMODE
:
14702 return _("NT_VMS_FPMODE (FP mode)");
14703 case NT_VMS_LINKTIME
:
14704 return "NT_VMS_LINKTIME";
14705 case NT_VMS_IMGNAM
:
14706 return _("NT_VMS_IMGNAM (image name)");
14708 return _("NT_VMS_IMGID (image id)");
14709 case NT_VMS_LINKID
:
14710 return _("NT_VMS_LINKID (link id)");
14711 case NT_VMS_IMGBID
:
14712 return _("NT_VMS_IMGBID (build id)");
14713 case NT_VMS_GSTNAM
:
14714 return _("NT_VMS_GSTNAM (sym table name)");
14715 case NT_VMS_ORIG_DYN
:
14716 return "NT_VMS_ORIG_DYN";
14717 case NT_VMS_PATCHTIME
:
14718 return "NT_VMS_PATCHTIME";
14720 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14726 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14728 switch (pnote
->type
)
14731 if (pnote
->descsz
> 36)
14733 size_t l
= strlen (pnote
->descdata
+ 34);
14734 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14735 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14736 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14737 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14740 printf (_(" Invalid size\n"));
14743 printf (_(" Language: %s\n"), pnote
->descdata
);
14746 case NT_VMS_FPMODE
:
14747 printf (_(" Floating Point mode: "));
14748 printf ("0x%016" BFD_VMA_FMT
"x\n",
14749 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14751 case NT_VMS_LINKTIME
:
14752 printf (_(" Link time: "));
14754 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14757 case NT_VMS_PATCHTIME
:
14758 printf (_(" Patch time: "));
14760 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14763 case NT_VMS_ORIG_DYN
:
14764 printf (_(" Major id: %u, minor id: %u\n"),
14765 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14766 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14767 printf (_(" Last modified : "));
14769 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14770 printf (_("\n Link flags : "));
14771 printf ("0x%016" BFD_VMA_FMT
"x\n",
14772 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14773 printf (_(" Header flags: 0x%08x\n"),
14774 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14775 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14778 case NT_VMS_IMGNAM
:
14779 printf (_(" Image name: %s\n"), pnote
->descdata
);
14781 case NT_VMS_GSTNAM
:
14782 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14785 printf (_(" Image id: %s\n"), pnote
->descdata
);
14787 case NT_VMS_LINKID
:
14788 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14796 /* Note that by the ELF standard, the name field is already null byte
14797 terminated, and namesz includes the terminating null byte.
14798 I.E. the value of namesz for the name "FSF" is 4.
14800 If the value of namesz is zero, there is no name present. */
14802 process_note (Elf_Internal_Note
* pnote
)
14804 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14807 if (pnote
->namesz
== 0)
14808 /* If there is no note name, then use the default set of
14809 note type strings. */
14810 nt
= get_note_type (pnote
->type
);
14812 else if (const_strneq (pnote
->namedata
, "GNU"))
14813 /* GNU-specific object file notes. */
14814 nt
= get_gnu_elf_note_type (pnote
->type
);
14816 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14817 /* NetBSD-specific core file notes. */
14818 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14820 else if (strneq (pnote
->namedata
, "SPU/", 4))
14822 /* SPU-specific core file notes. */
14823 nt
= pnote
->namedata
+ 4;
14827 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14828 /* VMS/ia64-specific file notes. */
14829 nt
= get_ia64_vms_note_type (pnote
->type
);
14831 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14832 nt
= get_stapsdt_note_type (pnote
->type
);
14835 /* Don't recognize this note name; just use the default set of
14836 note type strings. */
14837 nt
= get_note_type (pnote
->type
);
14839 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14841 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14842 return print_ia64_vms_note (pnote
);
14843 else if (const_strneq (pnote
->namedata
, "GNU"))
14844 return print_gnu_note (pnote
);
14845 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14846 return print_stapsdt_note (pnote
);
14847 else if (const_strneq (pnote
->namedata
, "CORE"))
14848 return print_core_note (pnote
);
14855 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14857 Elf_External_Note
* pnotes
;
14858 Elf_External_Note
* external
;
14864 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14866 if (pnotes
== NULL
)
14871 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14872 (unsigned long) offset
, (unsigned long) length
);
14873 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14875 while ((char *) external
< (char *) pnotes
+ length
)
14877 Elf_Internal_Note inote
;
14880 char * temp
= NULL
;
14881 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14883 if (!is_ia64_vms ())
14885 /* PR binutils/15191
14886 Make sure that there is enough data to read. */
14887 min_notesz
= offsetof (Elf_External_Note
, name
);
14888 if (data_remaining
< min_notesz
)
14890 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14891 (int) data_remaining
);
14894 inote
.type
= BYTE_GET (external
->type
);
14895 inote
.namesz
= BYTE_GET (external
->namesz
);
14896 inote
.namedata
= external
->name
;
14897 inote
.descsz
= BYTE_GET (external
->descsz
);
14898 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14899 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14900 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14904 Elf64_External_VMS_Note
*vms_external
;
14906 /* PR binutils/15191
14907 Make sure that there is enough data to read. */
14908 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14909 if (data_remaining
< min_notesz
)
14911 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14912 (int) data_remaining
);
14916 vms_external
= (Elf64_External_VMS_Note
*) external
;
14917 inote
.type
= BYTE_GET (vms_external
->type
);
14918 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14919 inote
.namedata
= vms_external
->name
;
14920 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14921 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14922 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14923 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14926 if (inote
.descdata
< (char *) external
+ min_notesz
14927 || next
< (char *) external
+ min_notesz
14928 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
14929 || inote
.namedata
+ inote
.namesz
< inote
.namedata
14930 || inote
.descdata
+ inote
.descsz
< inote
.descdata
14931 || data_remaining
< (size_t)(next
- (char *) external
))
14933 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14934 (unsigned long) ((char *) external
- (char *) pnotes
));
14935 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14936 inote
.type
, inote
.namesz
, inote
.descsz
);
14940 external
= (Elf_External_Note
*) next
;
14942 /* Verify that name is null terminated. It appears that at least
14943 one version of Linux (RedHat 6.0) generates corefiles that don't
14944 comply with the ELF spec by failing to include the null byte in
14946 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14948 temp
= (char *) malloc (inote
.namesz
+ 1);
14951 error (_("Out of memory allocating space for inote name\n"));
14956 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14957 temp
[inote
.namesz
] = 0;
14959 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14960 inote
.namedata
= temp
;
14963 res
&= process_note (& inote
);
14978 process_corefile_note_segments (FILE * file
)
14980 Elf_Internal_Phdr
* segment
;
14984 if (! get_program_headers (file
))
14987 for (i
= 0, segment
= program_headers
;
14988 i
< elf_header
.e_phnum
;
14991 if (segment
->p_type
== PT_NOTE
)
14992 res
&= process_corefile_note_segment (file
,
14993 (bfd_vma
) segment
->p_offset
,
14994 (bfd_vma
) segment
->p_filesz
);
15001 process_note_sections (FILE * file
)
15003 Elf_Internal_Shdr
* section
;
15008 for (i
= 0, section
= section_headers
;
15009 i
< elf_header
.e_shnum
&& section
!= NULL
;
15011 if (section
->sh_type
== SHT_NOTE
)
15013 res
&= process_corefile_note_segment (file
,
15014 (bfd_vma
) section
->sh_offset
,
15015 (bfd_vma
) section
->sh_size
);
15020 /* Try processing NOTE segments instead. */
15021 return process_corefile_note_segments (file
);
15027 process_notes (FILE * file
)
15029 /* If we have not been asked to display the notes then do nothing. */
15033 if (elf_header
.e_type
!= ET_CORE
)
15034 return process_note_sections (file
);
15036 /* No program headers means no NOTE segment. */
15037 if (elf_header
.e_phnum
> 0)
15038 return process_corefile_note_segments (file
);
15040 printf (_("No note segments present in the core file.\n"));
15045 process_arch_specific (FILE * file
)
15050 switch (elf_header
.e_machine
)
15053 return process_arm_specific (file
);
15055 case EM_MIPS_RS3_LE
:
15056 return process_mips_specific (file
);
15059 return process_nds32_specific (file
);
15062 return process_power_specific (file
);
15065 case EM_SPARC32PLUS
:
15067 return process_sparc_specific (file
);
15070 return process_tic6x_specific (file
);
15073 return process_msp430x_specific (file
);
15081 get_file_header (FILE * file
)
15083 /* Read in the identity array. */
15084 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15087 /* Determine how to read the rest of the header. */
15088 switch (elf_header
.e_ident
[EI_DATA
])
15090 default: /* fall through */
15091 case ELFDATANONE
: /* fall through */
15093 byte_get
= byte_get_little_endian
;
15094 byte_put
= byte_put_little_endian
;
15097 byte_get
= byte_get_big_endian
;
15098 byte_put
= byte_put_big_endian
;
15102 /* For now we only support 32 bit and 64 bit ELF files. */
15103 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
15105 /* Read in the rest of the header. */
15108 Elf32_External_Ehdr ehdr32
;
15110 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
15113 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
15114 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
15115 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
15116 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
15117 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
15118 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
15119 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
15120 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
15121 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
15122 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
15123 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
15124 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
15125 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
15129 Elf64_External_Ehdr ehdr64
;
15131 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15132 we will not be able to cope with the 64bit data found in
15133 64 ELF files. Detect this now and abort before we start
15134 overwriting things. */
15135 if (sizeof (bfd_vma
) < 8)
15137 error (_("This instance of readelf has been built without support for a\n\
15138 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15142 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
15145 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
15146 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
15147 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
15148 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
15149 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
15150 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
15151 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
15152 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
15153 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
15154 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
15155 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
15156 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
15157 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
15160 if (elf_header
.e_shoff
)
15162 /* There may be some extensions in the first section header. Don't
15163 bomb if we can't read it. */
15165 get_32bit_section_headers (file
, TRUE
);
15167 get_64bit_section_headers (file
, TRUE
);
15173 /* Process one ELF object file according to the command line options.
15174 This file may actually be stored in an archive. The file is
15175 positioned at the start of the ELF object. */
15178 process_object (char * file_name
, FILE * file
)
15182 if (! get_file_header (file
))
15184 error (_("%s: Failed to read file header\n"), file_name
);
15188 /* Initialise per file variables. */
15189 for (i
= ARRAY_SIZE (version_info
); i
--;)
15190 version_info
[i
] = 0;
15192 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
15193 dynamic_info
[i
] = 0;
15194 dynamic_info_DT_GNU_HASH
= 0;
15196 /* Process the file. */
15198 printf (_("\nFile: %s\n"), file_name
);
15200 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15201 Note we do this even if cmdline_dump_sects is empty because we
15202 must make sure that the dump_sets array is zeroed out before each
15203 object file is processed. */
15204 if (num_dump_sects
> num_cmdline_dump_sects
)
15205 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
15207 if (num_cmdline_dump_sects
> 0)
15209 if (num_dump_sects
== 0)
15210 /* A sneaky way of allocating the dump_sects array. */
15211 request_dump_bynumber (num_cmdline_dump_sects
, 0);
15213 assert (num_dump_sects
>= num_cmdline_dump_sects
);
15214 memcpy (dump_sects
, cmdline_dump_sects
,
15215 num_cmdline_dump_sects
* sizeof (* dump_sects
));
15218 if (! process_file_header ())
15221 if (! process_section_headers (file
))
15223 /* Without loaded section headers we cannot process lots of
15225 do_unwind
= do_version
= do_dump
= do_arch
= 0;
15227 if (! do_using_dynamic
)
15228 do_syms
= do_dyn_syms
= do_reloc
= 0;
15231 if (! process_section_groups (file
))
15233 /* Without loaded section groups we cannot process unwind. */
15237 if (process_program_headers (file
))
15238 process_dynamic_section (file
);
15240 process_relocs (file
);
15242 process_unwind (file
);
15244 process_symbol_table (file
);
15246 process_syminfo (file
);
15248 process_version_sections (file
);
15250 process_section_contents (file
);
15252 process_notes (file
);
15254 process_gnu_liblist (file
);
15256 process_arch_specific (file
);
15258 if (program_headers
)
15260 free (program_headers
);
15261 program_headers
= NULL
;
15264 if (section_headers
)
15266 free (section_headers
);
15267 section_headers
= NULL
;
15272 free (string_table
);
15273 string_table
= NULL
;
15274 string_table_length
= 0;
15277 if (dynamic_strings
)
15279 free (dynamic_strings
);
15280 dynamic_strings
= NULL
;
15281 dynamic_strings_length
= 0;
15284 if (dynamic_symbols
)
15286 free (dynamic_symbols
);
15287 dynamic_symbols
= NULL
;
15288 num_dynamic_syms
= 0;
15291 if (dynamic_syminfo
)
15293 free (dynamic_syminfo
);
15294 dynamic_syminfo
= NULL
;
15297 if (dynamic_section
)
15299 free (dynamic_section
);
15300 dynamic_section
= NULL
;
15303 if (section_headers_groups
)
15305 free (section_headers_groups
);
15306 section_headers_groups
= NULL
;
15309 if (section_groups
)
15311 struct group_list
* g
;
15312 struct group_list
* next
;
15314 for (i
= 0; i
< group_count
; i
++)
15316 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
15323 free (section_groups
);
15324 section_groups
= NULL
;
15327 free_debug_memory ();
15332 /* Process an ELF archive.
15333 On entry the file is positioned just after the ARMAG string. */
15336 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
15338 struct archive_info arch
;
15339 struct archive_info nested_arch
;
15345 /* The ARCH structure is used to hold information about this archive. */
15346 arch
.file_name
= NULL
;
15348 arch
.index_array
= NULL
;
15349 arch
.sym_table
= NULL
;
15350 arch
.longnames
= NULL
;
15352 /* The NESTED_ARCH structure is used as a single-item cache of information
15353 about a nested archive (when members of a thin archive reside within
15354 another regular archive file). */
15355 nested_arch
.file_name
= NULL
;
15356 nested_arch
.file
= NULL
;
15357 nested_arch
.index_array
= NULL
;
15358 nested_arch
.sym_table
= NULL
;
15359 nested_arch
.longnames
= NULL
;
15361 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
15367 if (do_archive_index
)
15369 if (arch
.sym_table
== NULL
)
15370 error (_("%s: unable to dump the index as none was found\n"), file_name
);
15373 unsigned long i
, l
;
15374 unsigned long current_pos
;
15376 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15377 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
15378 current_pos
= ftell (file
);
15380 for (i
= l
= 0; i
< arch
.index_num
; i
++)
15382 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
15384 char * member_name
;
15386 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
15388 if (member_name
!= NULL
)
15390 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
15392 if (qualified_name
!= NULL
)
15394 printf (_("Contents of binary %s at offset "), qualified_name
);
15395 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
15397 free (qualified_name
);
15402 if (l
>= arch
.sym_size
)
15404 error (_("%s: end of the symbol table reached before the end of the index\n"),
15408 /* PR 17531: file: 0b6630b2. */
15409 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
15410 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
15413 if (arch
.uses_64bit_indicies
)
15418 if (l
< arch
.sym_size
)
15419 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15420 file_name
, arch
.sym_size
- l
);
15422 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
15424 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
15430 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
15431 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
15432 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
15433 && !do_section_groups
&& !do_dyn_syms
)
15435 ret
= 0; /* Archive index only. */
15446 char * qualified_name
;
15448 /* Read the next archive header. */
15449 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
15451 error (_("%s: failed to seek to next archive header\n"), file_name
);
15454 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
15455 if (got
!= sizeof arch
.arhdr
)
15459 error (_("%s: failed to read archive header\n"), file_name
);
15463 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
15465 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
15470 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
15472 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
15473 if (archive_file_size
& 01)
15474 ++archive_file_size
;
15476 name
= get_archive_member_name (&arch
, &nested_arch
);
15479 error (_("%s: bad archive file name\n"), file_name
);
15483 namelen
= strlen (name
);
15485 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15486 if (qualified_name
== NULL
)
15488 error (_("%s: bad archive file name\n"), file_name
);
15493 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15495 /* This is a proxy for an external member of a thin archive. */
15496 FILE * member_file
;
15497 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15498 if (member_file_name
== NULL
)
15504 member_file
= fopen (member_file_name
, "rb");
15505 if (member_file
== NULL
)
15507 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15508 free (member_file_name
);
15513 archive_file_offset
= arch
.nested_member_origin
;
15515 ret
|= process_object (qualified_name
, member_file
);
15517 fclose (member_file
);
15518 free (member_file_name
);
15520 else if (is_thin_archive
)
15522 /* PR 15140: Allow for corrupt thin archives. */
15523 if (nested_arch
.file
== NULL
)
15525 error (_("%s: contains corrupt thin archive: %s\n"),
15531 /* This is a proxy for a member of a nested archive. */
15532 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15534 /* The nested archive file will have been opened and setup by
15535 get_archive_member_name. */
15536 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15538 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15543 ret
|= process_object (qualified_name
, nested_arch
.file
);
15547 archive_file_offset
= arch
.next_arhdr_offset
;
15548 arch
.next_arhdr_offset
+= archive_file_size
;
15550 ret
|= process_object (qualified_name
, file
);
15553 if (dump_sects
!= NULL
)
15557 num_dump_sects
= 0;
15560 free (qualified_name
);
15564 if (nested_arch
.file
!= NULL
)
15565 fclose (nested_arch
.file
);
15566 release_archive (&nested_arch
);
15567 release_archive (&arch
);
15573 process_file (char * file_name
)
15576 struct stat statbuf
;
15577 char armag
[SARMAG
];
15580 if (stat (file_name
, &statbuf
) < 0)
15582 if (errno
== ENOENT
)
15583 error (_("'%s': No such file\n"), file_name
);
15585 error (_("Could not locate '%s'. System error message: %s\n"),
15586 file_name
, strerror (errno
));
15590 if (! S_ISREG (statbuf
.st_mode
))
15592 error (_("'%s' is not an ordinary file\n"), file_name
);
15596 file
= fopen (file_name
, "rb");
15599 error (_("Input file '%s' is not readable.\n"), file_name
);
15603 if (fread (armag
, SARMAG
, 1, file
) != 1)
15605 error (_("%s: Failed to read file's magic number\n"), file_name
);
15610 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15612 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15613 ret
= process_archive (file_name
, file
, FALSE
);
15614 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15615 ret
= process_archive (file_name
, file
, TRUE
);
15618 if (do_archive_index
)
15619 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15623 archive_file_size
= archive_file_offset
= 0;
15624 ret
= process_object (file_name
, file
);
15629 current_file_size
= 0;
15633 #ifdef SUPPORT_DISASSEMBLY
15634 /* Needed by the i386 disassembler. For extra credit, someone could
15635 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15639 print_address (unsigned int addr
, FILE * outfile
)
15641 fprintf (outfile
,"0x%8.8x", addr
);
15644 /* Needed by the i386 disassembler. */
15646 db_task_printsym (unsigned int addr
)
15648 print_address (addr
, stderr
);
15653 main (int argc
, char ** argv
)
15657 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15658 setlocale (LC_MESSAGES
, "");
15660 #if defined (HAVE_SETLOCALE)
15661 setlocale (LC_CTYPE
, "");
15663 bindtextdomain (PACKAGE
, LOCALEDIR
);
15664 textdomain (PACKAGE
);
15666 expandargv (&argc
, &argv
);
15668 parse_args (argc
, argv
);
15670 if (num_dump_sects
> 0)
15672 /* Make a copy of the dump_sects array. */
15673 cmdline_dump_sects
= (dump_type
*)
15674 malloc (num_dump_sects
* sizeof (* dump_sects
));
15675 if (cmdline_dump_sects
== NULL
)
15676 error (_("Out of memory allocating dump request table.\n"));
15679 memcpy (cmdline_dump_sects
, dump_sects
,
15680 num_dump_sects
* sizeof (* dump_sects
));
15681 num_cmdline_dump_sects
= num_dump_sects
;
15685 if (optind
< (argc
- 1))
15689 while (optind
< argc
)
15690 err
|= process_file (argv
[optind
++]);
15692 if (dump_sects
!= NULL
)
15694 if (cmdline_dump_sects
!= NULL
)
15695 free (cmdline_dump_sects
);