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 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 unsigned int 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
277 #define SECTION_NAME(X) \
278 ((X) == NULL ? _("<none>") \
279 : string_table == NULL ? _("<no-name>") \
280 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
281 : string_table + (X)->sh_name))
283 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
285 #define GET_ELF_SYMBOLS(file, section, sym_count) \
286 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
287 : get_64bit_elf_symbols (file, section, sym_count))
289 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
290 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
291 already been called and verified that the string exists. */
292 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
294 #define REMOVE_ARCH_BITS(ADDR) \
297 if (elf_header.e_machine == EM_ARM) \
302 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
303 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
304 using malloc and fill that. In either case return the pointer to the start of
305 the retrieved data or NULL if something went wrong. If something does go wrong
306 emit an error message using REASON as part of the context. */
309 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
314 if (size
== 0 || nmemb
== 0)
317 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
320 error (_("Unable to seek to 0x%lx for %s\n"),
321 (unsigned long) archive_file_offset
+ offset
, reason
);
328 /* Check for overflow. */
329 if (nmemb
< (~(size_t) 0 - 1) / size
)
330 /* + 1 so that we can '\0' terminate invalid string table sections. */
331 mvar
= malloc (size
* nmemb
+ 1);
336 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
337 (unsigned long)(size
* nmemb
), reason
);
341 ((char *) mvar
)[size
* nmemb
] = '\0';
344 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
347 error (_("Unable to read in 0x%lx bytes of %s\n"),
348 (unsigned long)(size
* nmemb
), reason
);
357 /* Print a VMA value. */
360 print_vma (bfd_vma vma
, print_mode mode
)
373 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
380 return printf ("%5" BFD_VMA_FMT
"d", vma
);
388 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
391 return printf ("%" BFD_VMA_FMT
"d", vma
);
394 return printf ("%" BFD_VMA_FMT
"u", vma
);
399 /* Display a symbol on stdout. Handles the display of control characters and
400 multibye characters (assuming the host environment supports them).
402 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
404 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
405 padding as necessary.
407 Returns the number of emitted characters. */
410 print_symbol (int width
, const char *symbol
)
412 bfd_boolean extra_padding
= FALSE
;
414 #ifdef HAVE_MBSTATE_T
421 /* Keep the width positive. This also helps. */
423 extra_padding
= TRUE
;
427 /* Set the remaining width to a very large value.
428 This simplifies the code below. */
429 width_remaining
= INT_MAX
;
431 width_remaining
= width
;
433 #ifdef HAVE_MBSTATE_T
434 /* Initialise the multibyte conversion state. */
435 memset (& state
, 0, sizeof (state
));
438 while (width_remaining
)
441 const char c
= *symbol
++;
446 /* Do not print control characters directly as they can affect terminal
447 settings. Such characters usually appear in the names generated
448 by the assembler for local labels. */
451 if (width_remaining
< 2)
454 printf ("^%c", c
+ 0x40);
455 width_remaining
-= 2;
458 else if (ISPRINT (c
))
466 #ifdef HAVE_MBSTATE_T
469 /* Let printf do the hard work of displaying multibyte characters. */
470 printf ("%.1s", symbol
- 1);
474 #ifdef HAVE_MBSTATE_T
475 /* Try to find out how many bytes made up the character that was
476 just printed. Advance the symbol pointer past the bytes that
478 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
482 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
487 if (extra_padding
&& num_printed
< width
)
489 /* Fill in the remaining spaces. */
490 printf ("%-*s", width
- num_printed
, " ");
497 /* Return a pointer to section NAME, or NULL if no such section exists. */
499 static Elf_Internal_Shdr
*
500 find_section (const char * name
)
504 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
505 if (streq (SECTION_NAME (section_headers
+ i
), name
))
506 return section_headers
+ i
;
511 /* Return a pointer to a section containing ADDR, or NULL if no such
514 static Elf_Internal_Shdr
*
515 find_section_by_address (bfd_vma addr
)
519 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
521 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
522 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
529 /* Return a pointer to section NAME, or NULL if no such section exists,
530 restricted to the list of sections given in SET. */
532 static Elf_Internal_Shdr
*
533 find_section_in_set (const char * name
, unsigned int * set
)
539 while ((i
= *set
++) > 0)
540 if (streq (SECTION_NAME (section_headers
+ i
), name
))
541 return section_headers
+ i
;
544 return find_section (name
);
547 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
550 static inline unsigned long
551 read_uleb128 (unsigned char *data
,
552 unsigned int *length_return
,
553 const unsigned char * const end
)
555 return read_leb128 (data
, length_return
, FALSE
, end
);
558 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
559 This OS has so many departures from the ELF standard that we test it at
565 return elf_header
.e_machine
== EM_IA_64
566 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
569 /* Guess the relocation size commonly used by the specific machines. */
572 guess_is_rela (unsigned int e_machine
)
576 /* Targets that use REL relocations. */
591 /* Targets that use RELA relocations. */
595 case EM_ADAPTEVA_EPIPHANY
:
597 case EM_ALTERA_NIOS2
:
616 case EM_LATTICEMICO32
:
625 case EM_CYGNUS_MN10200
:
627 case EM_CYGNUS_MN10300
:
660 case EM_MICROBLAZE_OLD
:
681 warn (_("Don't know about relocations on this machine architecture\n"));
687 slurp_rela_relocs (FILE * file
,
688 unsigned long rel_offset
,
689 unsigned long rel_size
,
690 Elf_Internal_Rela
** relasp
,
691 unsigned long * nrelasp
)
693 Elf_Internal_Rela
* relas
;
694 unsigned long nrelas
;
699 Elf32_External_Rela
* erelas
;
701 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
702 rel_size
, _("32-bit relocation data"));
706 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
708 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
709 sizeof (Elf_Internal_Rela
));
714 error (_("out of memory parsing relocs\n"));
718 for (i
= 0; i
< nrelas
; i
++)
720 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
721 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
722 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
729 Elf64_External_Rela
* erelas
;
731 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
732 rel_size
, _("64-bit relocation data"));
736 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
738 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
739 sizeof (Elf_Internal_Rela
));
744 error (_("out of memory parsing relocs\n"));
748 for (i
= 0; i
< nrelas
; i
++)
750 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
751 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
752 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
754 /* The #ifdef BFD64 below is to prevent a compile time
755 warning. We know that if we do not have a 64 bit data
756 type that we will never execute this code anyway. */
758 if (elf_header
.e_machine
== EM_MIPS
759 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
761 /* In little-endian objects, r_info isn't really a
762 64-bit little-endian value: it has a 32-bit
763 little-endian symbol index followed by four
764 individual byte fields. Reorder INFO
766 bfd_vma inf
= relas
[i
].r_info
;
767 inf
= (((inf
& 0xffffffff) << 32)
768 | ((inf
>> 56) & 0xff)
769 | ((inf
>> 40) & 0xff00)
770 | ((inf
>> 24) & 0xff0000)
771 | ((inf
>> 8) & 0xff000000));
772 relas
[i
].r_info
= inf
;
785 slurp_rel_relocs (FILE * file
,
786 unsigned long rel_offset
,
787 unsigned long rel_size
,
788 Elf_Internal_Rela
** relsp
,
789 unsigned long * nrelsp
)
791 Elf_Internal_Rela
* rels
;
797 Elf32_External_Rel
* erels
;
799 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
800 rel_size
, _("32-bit relocation data"));
804 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
806 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
811 error (_("out of memory parsing relocs\n"));
815 for (i
= 0; i
< nrels
; i
++)
817 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
818 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
819 rels
[i
].r_addend
= 0;
826 Elf64_External_Rel
* erels
;
828 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
829 rel_size
, _("64-bit relocation data"));
833 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
835 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
840 error (_("out of memory parsing relocs\n"));
844 for (i
= 0; i
< nrels
; i
++)
846 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
847 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
848 rels
[i
].r_addend
= 0;
850 /* The #ifdef BFD64 below is to prevent a compile time
851 warning. We know that if we do not have a 64 bit data
852 type that we will never execute this code anyway. */
854 if (elf_header
.e_machine
== EM_MIPS
855 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
857 /* In little-endian objects, r_info isn't really a
858 64-bit little-endian value: it has a 32-bit
859 little-endian symbol index followed by four
860 individual byte fields. Reorder INFO
862 bfd_vma inf
= rels
[i
].r_info
;
863 inf
= (((inf
& 0xffffffff) << 32)
864 | ((inf
>> 56) & 0xff)
865 | ((inf
>> 40) & 0xff00)
866 | ((inf
>> 24) & 0xff0000)
867 | ((inf
>> 8) & 0xff000000));
868 rels
[i
].r_info
= inf
;
880 /* Returns the reloc type extracted from the reloc info field. */
883 get_reloc_type (bfd_vma reloc_info
)
886 return ELF32_R_TYPE (reloc_info
);
888 switch (elf_header
.e_machine
)
891 /* Note: We assume that reloc_info has already been adjusted for us. */
892 return ELF64_MIPS_R_TYPE (reloc_info
);
895 return ELF64_R_TYPE_ID (reloc_info
);
898 return ELF64_R_TYPE (reloc_info
);
902 /* Return the symbol index extracted from the reloc info field. */
905 get_reloc_symindex (bfd_vma reloc_info
)
907 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
910 static inline bfd_boolean
911 uses_msp430x_relocs (void)
914 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
915 /* GCC uses osabi == ELFOSBI_STANDALONE. */
916 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
917 /* TI compiler uses ELFOSABI_NONE. */
918 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
921 /* Display the contents of the relocation data found at the specified
925 dump_relocations (FILE * file
,
926 unsigned long rel_offset
,
927 unsigned long rel_size
,
928 Elf_Internal_Sym
* symtab
,
931 unsigned long strtablen
,
935 Elf_Internal_Rela
* rels
;
937 if (is_rela
== UNKNOWN
)
938 is_rela
= guess_is_rela (elf_header
.e_machine
);
942 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
947 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
956 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
958 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
963 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
965 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
973 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
975 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
980 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
982 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
986 for (i
= 0; i
< rel_size
; i
++)
991 bfd_vma symtab_index
;
994 offset
= rels
[i
].r_offset
;
995 inf
= rels
[i
].r_info
;
997 type
= get_reloc_type (inf
);
998 symtab_index
= get_reloc_symindex (inf
);
1002 printf ("%8.8lx %8.8lx ",
1003 (unsigned long) offset
& 0xffffffff,
1004 (unsigned long) inf
& 0xffffffff);
1008 #if BFD_HOST_64BIT_LONG
1010 ? "%16.16lx %16.16lx "
1011 : "%12.12lx %12.12lx ",
1013 #elif BFD_HOST_64BIT_LONG_LONG
1016 ? "%16.16llx %16.16llx "
1017 : "%12.12llx %12.12llx ",
1021 ? "%16.16I64x %16.16I64x "
1022 : "%12.12I64x %12.12I64x ",
1027 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1028 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1029 _bfd_int64_high (offset
),
1030 _bfd_int64_low (offset
),
1031 _bfd_int64_high (inf
),
1032 _bfd_int64_low (inf
));
1036 switch (elf_header
.e_machine
)
1043 rtype
= elf_aarch64_reloc_type (type
);
1047 case EM_CYGNUS_M32R
:
1048 rtype
= elf_m32r_reloc_type (type
);
1053 rtype
= elf_i386_reloc_type (type
);
1058 rtype
= elf_m68hc11_reloc_type (type
);
1062 rtype
= elf_m68k_reloc_type (type
);
1066 rtype
= elf_i960_reloc_type (type
);
1071 rtype
= elf_avr_reloc_type (type
);
1074 case EM_OLD_SPARCV9
:
1075 case EM_SPARC32PLUS
:
1078 rtype
= elf_sparc_reloc_type (type
);
1082 rtype
= elf_spu_reloc_type (type
);
1086 rtype
= v800_reloc_type (type
);
1089 case EM_CYGNUS_V850
:
1090 rtype
= v850_reloc_type (type
);
1094 case EM_CYGNUS_D10V
:
1095 rtype
= elf_d10v_reloc_type (type
);
1099 case EM_CYGNUS_D30V
:
1100 rtype
= elf_d30v_reloc_type (type
);
1104 rtype
= elf_dlx_reloc_type (type
);
1108 rtype
= elf_sh_reloc_type (type
);
1112 case EM_CYGNUS_MN10300
:
1113 rtype
= elf_mn10300_reloc_type (type
);
1117 case EM_CYGNUS_MN10200
:
1118 rtype
= elf_mn10200_reloc_type (type
);
1122 case EM_CYGNUS_FR30
:
1123 rtype
= elf_fr30_reloc_type (type
);
1127 rtype
= elf_frv_reloc_type (type
);
1131 rtype
= elf_mcore_reloc_type (type
);
1135 rtype
= elf_mmix_reloc_type (type
);
1139 rtype
= elf_moxie_reloc_type (type
);
1143 if (uses_msp430x_relocs ())
1145 rtype
= elf_msp430x_reloc_type (type
);
1149 rtype
= elf_msp430_reloc_type (type
);
1153 rtype
= elf_nds32_reloc_type (type
);
1157 rtype
= elf_ppc_reloc_type (type
);
1161 rtype
= elf_ppc64_reloc_type (type
);
1165 case EM_MIPS_RS3_LE
:
1166 rtype
= elf_mips_reloc_type (type
);
1170 rtype
= elf_alpha_reloc_type (type
);
1174 rtype
= elf_arm_reloc_type (type
);
1178 rtype
= elf_arc_reloc_type (type
);
1182 rtype
= elf_hppa_reloc_type (type
);
1188 rtype
= elf_h8_reloc_type (type
);
1192 rtype
= elf_or1k_reloc_type (type
);
1197 rtype
= elf_pj_reloc_type (type
);
1200 rtype
= elf_ia64_reloc_type (type
);
1204 rtype
= elf_cris_reloc_type (type
);
1208 rtype
= elf_i860_reloc_type (type
);
1214 rtype
= elf_x86_64_reloc_type (type
);
1218 rtype
= i370_reloc_type (type
);
1223 rtype
= elf_s390_reloc_type (type
);
1227 rtype
= elf_score_reloc_type (type
);
1231 rtype
= elf_xstormy16_reloc_type (type
);
1235 rtype
= elf_crx_reloc_type (type
);
1239 rtype
= elf_vax_reloc_type (type
);
1242 case EM_ADAPTEVA_EPIPHANY
:
1243 rtype
= elf_epiphany_reloc_type (type
);
1248 rtype
= elf_ip2k_reloc_type (type
);
1252 rtype
= elf_iq2000_reloc_type (type
);
1257 rtype
= elf_xtensa_reloc_type (type
);
1260 case EM_LATTICEMICO32
:
1261 rtype
= elf_lm32_reloc_type (type
);
1266 rtype
= elf_m32c_reloc_type (type
);
1270 rtype
= elf_mt_reloc_type (type
);
1274 rtype
= elf_bfin_reloc_type (type
);
1278 rtype
= elf_mep_reloc_type (type
);
1282 rtype
= elf_cr16_reloc_type (type
);
1286 case EM_MICROBLAZE_OLD
:
1287 rtype
= elf_microblaze_reloc_type (type
);
1291 rtype
= elf_rl78_reloc_type (type
);
1295 rtype
= elf_rx_reloc_type (type
);
1299 rtype
= elf_metag_reloc_type (type
);
1304 rtype
= elf_xc16x_reloc_type (type
);
1308 rtype
= elf_tic6x_reloc_type (type
);
1312 rtype
= elf_tilegx_reloc_type (type
);
1316 rtype
= elf_tilepro_reloc_type (type
);
1320 rtype
= elf_xgate_reloc_type (type
);
1323 case EM_ALTERA_NIOS2
:
1324 rtype
= elf_nios2_reloc_type (type
);
1329 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1331 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1333 if (elf_header
.e_machine
== EM_ALPHA
1335 && streq (rtype
, "R_ALPHA_LITUSE")
1338 switch (rels
[i
].r_addend
)
1340 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1341 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1342 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1343 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1344 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1345 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1346 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1347 default: rtype
= NULL
;
1350 printf (" (%s)", rtype
);
1354 printf (_("<unknown addend: %lx>"),
1355 (unsigned long) rels
[i
].r_addend
);
1358 else if (symtab_index
)
1360 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1361 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1364 Elf_Internal_Sym
* psym
;
1366 psym
= symtab
+ symtab_index
;
1370 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1374 unsigned int width
= is_32bit_elf
? 8 : 14;
1376 /* Relocations against GNU_IFUNC symbols do not use the value
1377 of the symbol as the address to relocate against. Instead
1378 they invoke the function named by the symbol and use its
1379 result as the address for relocation.
1381 To indicate this to the user, do not display the value of
1382 the symbol in the "Symbols's Value" field. Instead show
1383 its name followed by () as a hint that the symbol is
1387 || psym
->st_name
== 0
1388 || psym
->st_name
>= strtablen
)
1391 name
= strtab
+ psym
->st_name
;
1393 len
= print_symbol (width
, name
);
1394 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1398 print_vma (psym
->st_value
, LONG_HEX
);
1400 printf (is_32bit_elf
? " " : " ");
1403 if (psym
->st_name
== 0)
1405 const char * sec_name
= "<null>";
1408 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1410 if (psym
->st_shndx
< elf_header
.e_shnum
)
1412 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1413 else if (psym
->st_shndx
== SHN_ABS
)
1415 else if (psym
->st_shndx
== SHN_COMMON
)
1416 sec_name
= "COMMON";
1417 else if ((elf_header
.e_machine
== EM_MIPS
1418 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1419 || (elf_header
.e_machine
== EM_TI_C6000
1420 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1421 sec_name
= "SCOMMON";
1422 else if (elf_header
.e_machine
== EM_MIPS
1423 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1424 sec_name
= "SUNDEF";
1425 else if ((elf_header
.e_machine
== EM_X86_64
1426 || elf_header
.e_machine
== EM_L1OM
1427 || elf_header
.e_machine
== EM_K1OM
)
1428 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1429 sec_name
= "LARGE_COMMON";
1430 else if (elf_header
.e_machine
== EM_IA_64
1431 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1432 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1433 sec_name
= "ANSI_COM";
1434 else if (is_ia64_vms ()
1435 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1436 sec_name
= "VMS_SYMVEC";
1439 sprintf (name_buf
, "<section 0x%x>",
1440 (unsigned int) psym
->st_shndx
);
1441 sec_name
= name_buf
;
1444 print_symbol (22, sec_name
);
1446 else if (strtab
== NULL
)
1447 printf (_("<string table index: %3ld>"), psym
->st_name
);
1448 else if (psym
->st_name
>= strtablen
)
1449 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1451 print_symbol (22, strtab
+ psym
->st_name
);
1455 bfd_signed_vma off
= rels
[i
].r_addend
;
1458 printf (" - %" BFD_VMA_FMT
"x", - off
);
1460 printf (" + %" BFD_VMA_FMT
"x", off
);
1466 bfd_signed_vma off
= rels
[i
].r_addend
;
1468 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1470 printf ("-%" BFD_VMA_FMT
"x", - off
);
1472 printf ("%" BFD_VMA_FMT
"x", off
);
1475 if (elf_header
.e_machine
== EM_SPARCV9
1477 && streq (rtype
, "R_SPARC_OLO10"))
1478 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1483 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1485 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1486 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1487 const char * rtype2
= elf_mips_reloc_type (type2
);
1488 const char * rtype3
= elf_mips_reloc_type (type3
);
1490 printf (" Type2: ");
1493 printf (_("unrecognized: %-7lx"),
1494 (unsigned long) type2
& 0xffffffff);
1496 printf ("%-17.17s", rtype2
);
1498 printf ("\n Type3: ");
1501 printf (_("unrecognized: %-7lx"),
1502 (unsigned long) type3
& 0xffffffff);
1504 printf ("%-17.17s", rtype3
);
1515 get_mips_dynamic_type (unsigned long type
)
1519 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1520 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1521 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1522 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1523 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1524 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1525 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1526 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1527 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1528 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1529 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1530 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1531 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1532 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1533 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1534 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1535 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1536 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1537 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1538 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1539 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1540 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1541 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1542 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1543 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1544 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1545 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1546 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1547 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1548 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1549 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1550 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1551 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1552 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1553 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1554 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1555 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1556 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1557 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1558 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1559 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1560 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1561 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1562 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1563 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1570 get_sparc64_dynamic_type (unsigned long type
)
1574 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1581 get_ppc_dynamic_type (unsigned long type
)
1585 case DT_PPC_GOT
: return "PPC_GOT";
1586 case DT_PPC_OPT
: return "PPC_OPT";
1593 get_ppc64_dynamic_type (unsigned long type
)
1597 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1598 case DT_PPC64_OPD
: return "PPC64_OPD";
1599 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1600 case DT_PPC64_OPT
: return "PPC64_OPT";
1607 get_parisc_dynamic_type (unsigned long type
)
1611 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1612 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1613 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1614 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1615 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1616 case DT_HP_PREINIT
: return "HP_PREINIT";
1617 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1618 case DT_HP_NEEDED
: return "HP_NEEDED";
1619 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1620 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1621 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1622 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1623 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1624 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1625 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1626 case DT_HP_FILTERED
: return "HP_FILTERED";
1627 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1628 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1629 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1630 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1631 case DT_PLT
: return "PLT";
1632 case DT_PLT_SIZE
: return "PLT_SIZE";
1633 case DT_DLT
: return "DLT";
1634 case DT_DLT_SIZE
: return "DLT_SIZE";
1641 get_ia64_dynamic_type (unsigned long type
)
1645 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1646 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1647 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1648 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1649 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1650 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1651 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1652 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1653 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1654 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1655 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1656 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1657 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1658 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1659 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1660 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1661 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1662 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1663 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1664 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1665 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1666 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1667 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1668 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1669 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1670 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1671 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1672 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1673 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1674 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1675 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1682 get_alpha_dynamic_type (unsigned long type
)
1686 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1693 get_score_dynamic_type (unsigned long type
)
1697 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1698 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1699 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1700 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1701 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1702 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1709 get_tic6x_dynamic_type (unsigned long type
)
1713 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1714 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1715 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1716 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1717 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1718 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1725 get_nios2_dynamic_type (unsigned long type
)
1729 case DT_NIOS2_GP
: return "NIOS2_GP";
1736 get_dynamic_type (unsigned long type
)
1738 static char buff
[64];
1742 case DT_NULL
: return "NULL";
1743 case DT_NEEDED
: return "NEEDED";
1744 case DT_PLTRELSZ
: return "PLTRELSZ";
1745 case DT_PLTGOT
: return "PLTGOT";
1746 case DT_HASH
: return "HASH";
1747 case DT_STRTAB
: return "STRTAB";
1748 case DT_SYMTAB
: return "SYMTAB";
1749 case DT_RELA
: return "RELA";
1750 case DT_RELASZ
: return "RELASZ";
1751 case DT_RELAENT
: return "RELAENT";
1752 case DT_STRSZ
: return "STRSZ";
1753 case DT_SYMENT
: return "SYMENT";
1754 case DT_INIT
: return "INIT";
1755 case DT_FINI
: return "FINI";
1756 case DT_SONAME
: return "SONAME";
1757 case DT_RPATH
: return "RPATH";
1758 case DT_SYMBOLIC
: return "SYMBOLIC";
1759 case DT_REL
: return "REL";
1760 case DT_RELSZ
: return "RELSZ";
1761 case DT_RELENT
: return "RELENT";
1762 case DT_PLTREL
: return "PLTREL";
1763 case DT_DEBUG
: return "DEBUG";
1764 case DT_TEXTREL
: return "TEXTREL";
1765 case DT_JMPREL
: return "JMPREL";
1766 case DT_BIND_NOW
: return "BIND_NOW";
1767 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1768 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1769 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1770 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1771 case DT_RUNPATH
: return "RUNPATH";
1772 case DT_FLAGS
: return "FLAGS";
1774 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1775 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1777 case DT_CHECKSUM
: return "CHECKSUM";
1778 case DT_PLTPADSZ
: return "PLTPADSZ";
1779 case DT_MOVEENT
: return "MOVEENT";
1780 case DT_MOVESZ
: return "MOVESZ";
1781 case DT_FEATURE
: return "FEATURE";
1782 case DT_POSFLAG_1
: return "POSFLAG_1";
1783 case DT_SYMINSZ
: return "SYMINSZ";
1784 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1786 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1787 case DT_CONFIG
: return "CONFIG";
1788 case DT_DEPAUDIT
: return "DEPAUDIT";
1789 case DT_AUDIT
: return "AUDIT";
1790 case DT_PLTPAD
: return "PLTPAD";
1791 case DT_MOVETAB
: return "MOVETAB";
1792 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1794 case DT_VERSYM
: return "VERSYM";
1796 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1797 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1798 case DT_RELACOUNT
: return "RELACOUNT";
1799 case DT_RELCOUNT
: return "RELCOUNT";
1800 case DT_FLAGS_1
: return "FLAGS_1";
1801 case DT_VERDEF
: return "VERDEF";
1802 case DT_VERDEFNUM
: return "VERDEFNUM";
1803 case DT_VERNEED
: return "VERNEED";
1804 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1806 case DT_AUXILIARY
: return "AUXILIARY";
1807 case DT_USED
: return "USED";
1808 case DT_FILTER
: return "FILTER";
1810 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1811 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1812 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1813 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1814 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1815 case DT_GNU_HASH
: return "GNU_HASH";
1818 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1820 const char * result
;
1822 switch (elf_header
.e_machine
)
1825 case EM_MIPS_RS3_LE
:
1826 result
= get_mips_dynamic_type (type
);
1829 result
= get_sparc64_dynamic_type (type
);
1832 result
= get_ppc_dynamic_type (type
);
1835 result
= get_ppc64_dynamic_type (type
);
1838 result
= get_ia64_dynamic_type (type
);
1841 result
= get_alpha_dynamic_type (type
);
1844 result
= get_score_dynamic_type (type
);
1847 result
= get_tic6x_dynamic_type (type
);
1849 case EM_ALTERA_NIOS2
:
1850 result
= get_nios2_dynamic_type (type
);
1860 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1862 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1863 || (elf_header
.e_machine
== EM_PARISC
1864 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1866 const char * result
;
1868 switch (elf_header
.e_machine
)
1871 result
= get_parisc_dynamic_type (type
);
1874 result
= get_ia64_dynamic_type (type
);
1884 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1888 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1895 get_file_type (unsigned e_type
)
1897 static char buff
[32];
1901 case ET_NONE
: return _("NONE (None)");
1902 case ET_REL
: return _("REL (Relocatable file)");
1903 case ET_EXEC
: return _("EXEC (Executable file)");
1904 case ET_DYN
: return _("DYN (Shared object file)");
1905 case ET_CORE
: return _("CORE (Core file)");
1908 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1909 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1910 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1911 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1913 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1919 get_machine_name (unsigned e_machine
)
1921 static char buff
[64]; /* XXX */
1925 case EM_NONE
: return _("None");
1926 case EM_AARCH64
: return "AArch64";
1927 case EM_M32
: return "WE32100";
1928 case EM_SPARC
: return "Sparc";
1929 case EM_SPU
: return "SPU";
1930 case EM_386
: return "Intel 80386";
1931 case EM_68K
: return "MC68000";
1932 case EM_88K
: return "MC88000";
1933 case EM_486
: return "Intel 80486";
1934 case EM_860
: return "Intel 80860";
1935 case EM_MIPS
: return "MIPS R3000";
1936 case EM_S370
: return "IBM System/370";
1937 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1938 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1939 case EM_PARISC
: return "HPPA";
1940 case EM_PPC_OLD
: return "Power PC (old)";
1941 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1942 case EM_960
: return "Intel 90860";
1943 case EM_PPC
: return "PowerPC";
1944 case EM_PPC64
: return "PowerPC64";
1945 case EM_FR20
: return "Fujitsu FR20";
1946 case EM_RH32
: return "TRW RH32";
1947 case EM_MCORE
: return "MCORE";
1948 case EM_ARM
: return "ARM";
1949 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1950 case EM_SH
: return "Renesas / SuperH SH";
1951 case EM_SPARCV9
: return "Sparc v9";
1952 case EM_TRICORE
: return "Siemens Tricore";
1953 case EM_ARC
: return "ARC";
1954 case EM_H8_300
: return "Renesas H8/300";
1955 case EM_H8_300H
: return "Renesas H8/300H";
1956 case EM_H8S
: return "Renesas H8S";
1957 case EM_H8_500
: return "Renesas H8/500";
1958 case EM_IA_64
: return "Intel IA-64";
1959 case EM_MIPS_X
: return "Stanford MIPS-X";
1960 case EM_COLDFIRE
: return "Motorola Coldfire";
1961 case EM_ALPHA
: return "Alpha";
1962 case EM_CYGNUS_D10V
:
1963 case EM_D10V
: return "d10v";
1964 case EM_CYGNUS_D30V
:
1965 case EM_D30V
: return "d30v";
1966 case EM_CYGNUS_M32R
:
1967 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1968 case EM_CYGNUS_V850
:
1969 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1970 case EM_V850
: return "Renesas V850";
1971 case EM_CYGNUS_MN10300
:
1972 case EM_MN10300
: return "mn10300";
1973 case EM_CYGNUS_MN10200
:
1974 case EM_MN10200
: return "mn10200";
1975 case EM_MOXIE
: return "Moxie";
1976 case EM_CYGNUS_FR30
:
1977 case EM_FR30
: return "Fujitsu FR30";
1978 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1980 case EM_PJ
: return "picoJava";
1981 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1982 case EM_PCP
: return "Siemens PCP";
1983 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1984 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1985 case EM_STARCORE
: return "Motorola Star*Core processor";
1986 case EM_ME16
: return "Toyota ME16 processor";
1987 case EM_ST100
: return "STMicroelectronics ST100 processor";
1988 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1989 case EM_PDSP
: return "Sony DSP processor";
1990 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1991 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1992 case EM_FX66
: return "Siemens FX66 microcontroller";
1993 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1994 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1995 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1996 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1997 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1998 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1999 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2000 case EM_SVX
: return "Silicon Graphics SVx";
2001 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2002 case EM_VAX
: return "Digital VAX";
2004 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2005 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2006 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2007 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2008 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2009 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2010 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2011 case EM_PRISM
: return "Vitesse Prism";
2012 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2013 case EM_L1OM
: return "Intel L1OM";
2014 case EM_K1OM
: return "Intel K1OM";
2016 case EM_S390
: return "IBM S/390";
2017 case EM_SCORE
: return "SUNPLUS S+Core";
2018 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2019 case EM_OR1K
: return "OpenRISC 1000";
2020 case EM_ARC_A5
: return "ARC International ARCompact processor";
2021 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2022 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2023 case EM_DLX
: return "OpenDLX";
2025 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2026 case EM_IQ2000
: return "Vitesse IQ2000";
2028 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2029 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2030 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2031 case EM_NS32K
: return "National Semiconductor 32000 series";
2032 case EM_TPC
: return "Tenor Network TPC processor";
2033 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2034 case EM_MAX
: return "MAX Processor";
2035 case EM_CR
: return "National Semiconductor CompactRISC";
2036 case EM_F2MC16
: return "Fujitsu F2MC16";
2037 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2038 case EM_LATTICEMICO32
: return "Lattice Mico32";
2040 case EM_M32C
: return "Renesas M32c";
2041 case EM_MT
: return "Morpho Techologies MT processor";
2042 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2043 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2044 case EM_SEP
: return "Sharp embedded microprocessor";
2045 case EM_ARCA
: return "Arca RISC microprocessor";
2046 case EM_UNICORE
: return "Unicore";
2047 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2048 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2049 case EM_NIOS32
: return "Altera Nios";
2050 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2052 case EM_XC16X
: return "Infineon Technologies xc16x";
2053 case EM_M16C
: return "Renesas M16C series microprocessors";
2054 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2055 case EM_CE
: return "Freescale Communication Engine RISC core";
2056 case EM_TSK3000
: return "Altium TSK3000 core";
2057 case EM_RS08
: return "Freescale RS08 embedded processor";
2058 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2059 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2060 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2061 case EM_SE_C17
: return "Seiko Epson C17 family";
2062 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2063 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2064 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2065 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2066 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2067 case EM_R32C
: return "Renesas R32C series microprocessors";
2068 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2069 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2070 case EM_8051
: return "Intel 8051 and variants";
2071 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2072 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2073 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2074 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2075 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2076 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2077 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2078 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2081 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2082 case EM_RL78
: return "Renesas RL78";
2083 case EM_RX
: return "Renesas RX";
2084 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2085 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2086 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2087 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2088 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2089 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2090 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2091 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2092 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2093 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2094 case EM_CUDA
: return "NVIDIA CUDA architecture";
2095 case EM_XGATE
: return "Motorola XGATE embedded processor";
2097 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2103 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2108 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2109 e_flags
&= ~ EF_ARM_EABIMASK
;
2111 /* Handle "generic" ARM flags. */
2112 if (e_flags
& EF_ARM_RELEXEC
)
2114 strcat (buf
, ", relocatable executable");
2115 e_flags
&= ~ EF_ARM_RELEXEC
;
2118 if (e_flags
& EF_ARM_HASENTRY
)
2120 strcat (buf
, ", has entry point");
2121 e_flags
&= ~ EF_ARM_HASENTRY
;
2124 /* Now handle EABI specific flags. */
2128 strcat (buf
, ", <unrecognized EABI>");
2133 case EF_ARM_EABI_VER1
:
2134 strcat (buf
, ", Version1 EABI");
2139 /* Process flags one bit at a time. */
2140 flag
= e_flags
& - e_flags
;
2145 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2146 strcat (buf
, ", sorted symbol tables");
2156 case EF_ARM_EABI_VER2
:
2157 strcat (buf
, ", Version2 EABI");
2162 /* Process flags one bit at a time. */
2163 flag
= e_flags
& - e_flags
;
2168 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2169 strcat (buf
, ", sorted symbol tables");
2172 case EF_ARM_DYNSYMSUSESEGIDX
:
2173 strcat (buf
, ", dynamic symbols use segment index");
2176 case EF_ARM_MAPSYMSFIRST
:
2177 strcat (buf
, ", mapping symbols precede others");
2187 case EF_ARM_EABI_VER3
:
2188 strcat (buf
, ", Version3 EABI");
2191 case EF_ARM_EABI_VER4
:
2192 strcat (buf
, ", Version4 EABI");
2197 /* Process flags one bit at a time. */
2198 flag
= e_flags
& - e_flags
;
2204 strcat (buf
, ", BE8");
2208 strcat (buf
, ", LE8");
2219 case EF_ARM_EABI_VER5
:
2220 strcat (buf
, ", Version5 EABI");
2225 /* Process flags one bit at a time. */
2226 flag
= e_flags
& - e_flags
;
2232 strcat (buf
, ", BE8");
2236 strcat (buf
, ", LE8");
2239 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2240 strcat (buf
, ", soft-float ABI");
2243 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2244 strcat (buf
, ", hard-float ABI");
2254 case EF_ARM_EABI_UNKNOWN
:
2255 strcat (buf
, ", GNU EABI");
2260 /* Process flags one bit at a time. */
2261 flag
= e_flags
& - e_flags
;
2266 case EF_ARM_INTERWORK
:
2267 strcat (buf
, ", interworking enabled");
2270 case EF_ARM_APCS_26
:
2271 strcat (buf
, ", uses APCS/26");
2274 case EF_ARM_APCS_FLOAT
:
2275 strcat (buf
, ", uses APCS/float");
2279 strcat (buf
, ", position independent");
2283 strcat (buf
, ", 8 bit structure alignment");
2286 case EF_ARM_NEW_ABI
:
2287 strcat (buf
, ", uses new ABI");
2290 case EF_ARM_OLD_ABI
:
2291 strcat (buf
, ", uses old ABI");
2294 case EF_ARM_SOFT_FLOAT
:
2295 strcat (buf
, ", software FP");
2298 case EF_ARM_VFP_FLOAT
:
2299 strcat (buf
, ", VFP");
2302 case EF_ARM_MAVERICK_FLOAT
:
2303 strcat (buf
, ", Maverick FP");
2314 strcat (buf
,_(", <unknown>"));
2318 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2327 static const char *ABI_STRINGS
[] =
2329 "ABI v0", /* use r5 as return register; only used in N1213HC */
2330 "ABI v1", /* use r0 as return register */
2331 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2332 "ABI v2fp", /* for FPU */
2336 static const char *VER_STRINGS
[] =
2338 "Andes ELF V1.3 or older",
2342 static const char *ARCH_STRINGS
[] =
2351 abi
= EF_NDS_ABI
& e_flags
;
2352 arch
= EF_NDS_ARCH
& e_flags
;
2353 config
= EF_NDS_INST
& e_flags
;
2354 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2356 memset (buf
, 0, size
);
2363 case E_NDS_ABI_V2FP
:
2364 case E_NDS_ABI_AABI
:
2365 case E_NDS_ABI_V2FP_PLUS
:
2366 /* In case there are holes in the array. */
2367 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2371 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2377 case E_NDS32_ELF_VER_1_2
:
2378 case E_NDS32_ELF_VER_1_3
:
2379 case E_NDS32_ELF_VER_1_4
:
2380 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2384 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2388 if (E_NDS_ABI_V0
== abi
)
2390 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2391 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2392 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2393 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2399 case E_NDS_ARCH_STAR_V1_0
:
2400 case E_NDS_ARCH_STAR_V2_0
:
2401 case E_NDS_ARCH_STAR_V3_0
:
2402 case E_NDS_ARCH_STAR_V3_M
:
2403 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2407 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2408 /* ARCH version determines how the e_flags are interpreted.
2409 If it is unknown, we cannot proceed. */
2413 /* Newer ABI; Now handle architecture specific flags. */
2414 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2416 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2417 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2419 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2420 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2422 if (config
& E_NDS32_HAS_DIV_INST
)
2423 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2425 if (config
& E_NDS32_HAS_16BIT_INST
)
2426 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2430 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2432 if (version
<= E_NDS32_ELF_VER_1_3
)
2433 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2435 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2438 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2439 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2441 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2442 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2444 if (config
& E_NDS32_HAS_16BIT_INST
)
2446 if (version
<= E_NDS32_ELF_VER_1_3
)
2447 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2449 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2453 if (config
& E_NDS32_HAS_EXT_INST
)
2454 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2456 if (config
& E_NDS32_HAS_EXT2_INST
)
2457 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2459 if (config
& E_NDS32_HAS_FPU_INST
)
2462 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2465 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2468 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2471 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2474 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2479 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2481 case E_NDS32_FPU_REG_8SP_4DP
:
2482 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2484 case E_NDS32_FPU_REG_16SP_8DP
:
2485 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2487 case E_NDS32_FPU_REG_32SP_16DP
:
2488 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2490 case E_NDS32_FPU_REG_32SP_32DP
:
2491 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2496 if (config
& E_NDS32_HAS_AUDIO_INST
)
2497 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2499 if (config
& E_NDS32_HAS_STRING_INST
)
2500 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2502 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2503 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2505 if (config
& E_NDS32_HAS_VIDEO_INST
)
2507 if (version
<= E_NDS32_ELF_VER_1_3
)
2508 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2510 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2513 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2514 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2516 if (config
& E_NDS32_HAS_L2C_INST
)
2517 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2521 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2523 static char buf
[1024];
2535 decode_ARM_machine_flags (e_flags
, buf
);
2539 if (e_flags
& EF_BFIN_PIC
)
2540 strcat (buf
, ", PIC");
2542 if (e_flags
& EF_BFIN_FDPIC
)
2543 strcat (buf
, ", FDPIC");
2545 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2546 strcat (buf
, ", code in L1");
2548 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2549 strcat (buf
, ", data in L1");
2554 switch (e_flags
& EF_FRV_CPU_MASK
)
2556 case EF_FRV_CPU_GENERIC
:
2560 strcat (buf
, ", fr???");
2563 case EF_FRV_CPU_FR300
:
2564 strcat (buf
, ", fr300");
2567 case EF_FRV_CPU_FR400
:
2568 strcat (buf
, ", fr400");
2570 case EF_FRV_CPU_FR405
:
2571 strcat (buf
, ", fr405");
2574 case EF_FRV_CPU_FR450
:
2575 strcat (buf
, ", fr450");
2578 case EF_FRV_CPU_FR500
:
2579 strcat (buf
, ", fr500");
2581 case EF_FRV_CPU_FR550
:
2582 strcat (buf
, ", fr550");
2585 case EF_FRV_CPU_SIMPLE
:
2586 strcat (buf
, ", simple");
2588 case EF_FRV_CPU_TOMCAT
:
2589 strcat (buf
, ", tomcat");
2595 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2596 strcat (buf
, ", m68000");
2597 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2598 strcat (buf
, ", cpu32");
2599 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2600 strcat (buf
, ", fido_a");
2603 char const * isa
= _("unknown");
2604 char const * mac
= _("unknown mac");
2605 char const * additional
= NULL
;
2607 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2609 case EF_M68K_CF_ISA_A_NODIV
:
2611 additional
= ", nodiv";
2613 case EF_M68K_CF_ISA_A
:
2616 case EF_M68K_CF_ISA_A_PLUS
:
2619 case EF_M68K_CF_ISA_B_NOUSP
:
2621 additional
= ", nousp";
2623 case EF_M68K_CF_ISA_B
:
2626 case EF_M68K_CF_ISA_C
:
2629 case EF_M68K_CF_ISA_C_NODIV
:
2631 additional
= ", nodiv";
2634 strcat (buf
, ", cf, isa ");
2637 strcat (buf
, additional
);
2638 if (e_flags
& EF_M68K_CF_FLOAT
)
2639 strcat (buf
, ", float");
2640 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2645 case EF_M68K_CF_MAC
:
2648 case EF_M68K_CF_EMAC
:
2651 case EF_M68K_CF_EMAC_B
:
2664 if (e_flags
& EF_PPC_EMB
)
2665 strcat (buf
, ", emb");
2667 if (e_flags
& EF_PPC_RELOCATABLE
)
2668 strcat (buf
, _(", relocatable"));
2670 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2671 strcat (buf
, _(", relocatable-lib"));
2675 if (e_flags
& EF_PPC64_ABI
)
2677 char abi
[] = ", abiv0";
2679 abi
[6] += e_flags
& EF_PPC64_ABI
;
2685 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2686 strcat (buf
, ", RH850 ABI");
2688 if (e_flags
& EF_V800_850E3
)
2689 strcat (buf
, ", V3 architecture");
2691 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2692 strcat (buf
, ", FPU not used");
2694 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2695 strcat (buf
, ", regmode: COMMON");
2697 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2698 strcat (buf
, ", r4 not used");
2700 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2701 strcat (buf
, ", r30 not used");
2703 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2704 strcat (buf
, ", r5 not used");
2706 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2707 strcat (buf
, ", r2 not used");
2709 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2711 switch (e_flags
& - e_flags
)
2713 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2714 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2715 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2716 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2717 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2718 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2719 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2720 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2721 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2722 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2723 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2724 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2725 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2726 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2727 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2728 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2735 case EM_CYGNUS_V850
:
2736 switch (e_flags
& EF_V850_ARCH
)
2738 case E_V850E3V5_ARCH
:
2739 strcat (buf
, ", v850e3v5");
2741 case E_V850E2V3_ARCH
:
2742 strcat (buf
, ", v850e2v3");
2745 strcat (buf
, ", v850e2");
2748 strcat (buf
, ", v850e1");
2751 strcat (buf
, ", v850e");
2754 strcat (buf
, ", v850");
2757 strcat (buf
, _(", unknown v850 architecture variant"));
2763 case EM_CYGNUS_M32R
:
2764 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2765 strcat (buf
, ", m32r");
2769 case EM_MIPS_RS3_LE
:
2770 if (e_flags
& EF_MIPS_NOREORDER
)
2771 strcat (buf
, ", noreorder");
2773 if (e_flags
& EF_MIPS_PIC
)
2774 strcat (buf
, ", pic");
2776 if (e_flags
& EF_MIPS_CPIC
)
2777 strcat (buf
, ", cpic");
2779 if (e_flags
& EF_MIPS_UCODE
)
2780 strcat (buf
, ", ugen_reserved");
2782 if (e_flags
& EF_MIPS_ABI2
)
2783 strcat (buf
, ", abi2");
2785 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2786 strcat (buf
, ", odk first");
2788 if (e_flags
& EF_MIPS_32BITMODE
)
2789 strcat (buf
, ", 32bitmode");
2791 if (e_flags
& EF_MIPS_NAN2008
)
2792 strcat (buf
, ", nan2008");
2794 if (e_flags
& EF_MIPS_FP64
)
2795 strcat (buf
, ", fp64");
2797 switch ((e_flags
& EF_MIPS_MACH
))
2799 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2800 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2801 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2802 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2803 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2804 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2805 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2806 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2807 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2808 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2809 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2810 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2811 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2812 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2813 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2814 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2815 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2817 /* We simply ignore the field in this case to avoid confusion:
2818 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2821 default: strcat (buf
, _(", unknown CPU")); break;
2824 switch ((e_flags
& EF_MIPS_ABI
))
2826 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2827 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2828 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2829 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2831 /* We simply ignore the field in this case to avoid confusion:
2832 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2833 This means it is likely to be an o32 file, but not for
2836 default: strcat (buf
, _(", unknown ABI")); break;
2839 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2840 strcat (buf
, ", mdmx");
2842 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2843 strcat (buf
, ", mips16");
2845 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2846 strcat (buf
, ", micromips");
2848 switch ((e_flags
& EF_MIPS_ARCH
))
2850 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2851 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2852 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2853 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2854 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2855 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2856 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2857 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
2858 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2859 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2860 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
2861 default: strcat (buf
, _(", unknown ISA")); break;
2866 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2870 switch ((e_flags
& EF_SH_MACH_MASK
))
2872 case EF_SH1
: strcat (buf
, ", sh1"); break;
2873 case EF_SH2
: strcat (buf
, ", sh2"); break;
2874 case EF_SH3
: strcat (buf
, ", sh3"); break;
2875 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2876 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2877 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2878 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2879 case EF_SH4
: strcat (buf
, ", sh4"); break;
2880 case EF_SH5
: strcat (buf
, ", sh5"); break;
2881 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2882 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2883 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2884 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2885 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2886 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2887 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2888 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2889 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2890 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2891 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2892 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2893 default: strcat (buf
, _(", unknown ISA")); break;
2896 if (e_flags
& EF_SH_PIC
)
2897 strcat (buf
, ", pic");
2899 if (e_flags
& EF_SH_FDPIC
)
2900 strcat (buf
, ", fdpic");
2904 if (e_flags
& EF_OR1K_NODELAY
)
2905 strcat (buf
, ", no delay");
2909 if (e_flags
& EF_SPARC_32PLUS
)
2910 strcat (buf
, ", v8+");
2912 if (e_flags
& EF_SPARC_SUN_US1
)
2913 strcat (buf
, ", ultrasparcI");
2915 if (e_flags
& EF_SPARC_SUN_US3
)
2916 strcat (buf
, ", ultrasparcIII");
2918 if (e_flags
& EF_SPARC_HAL_R1
)
2919 strcat (buf
, ", halr1");
2921 if (e_flags
& EF_SPARC_LEDATA
)
2922 strcat (buf
, ", ledata");
2924 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2925 strcat (buf
, ", tso");
2927 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2928 strcat (buf
, ", pso");
2930 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2931 strcat (buf
, ", rmo");
2935 switch (e_flags
& EF_PARISC_ARCH
)
2937 case EFA_PARISC_1_0
:
2938 strcpy (buf
, ", PA-RISC 1.0");
2940 case EFA_PARISC_1_1
:
2941 strcpy (buf
, ", PA-RISC 1.1");
2943 case EFA_PARISC_2_0
:
2944 strcpy (buf
, ", PA-RISC 2.0");
2949 if (e_flags
& EF_PARISC_TRAPNIL
)
2950 strcat (buf
, ", trapnil");
2951 if (e_flags
& EF_PARISC_EXT
)
2952 strcat (buf
, ", ext");
2953 if (e_flags
& EF_PARISC_LSB
)
2954 strcat (buf
, ", lsb");
2955 if (e_flags
& EF_PARISC_WIDE
)
2956 strcat (buf
, ", wide");
2957 if (e_flags
& EF_PARISC_NO_KABP
)
2958 strcat (buf
, ", no kabp");
2959 if (e_flags
& EF_PARISC_LAZYSWAP
)
2960 strcat (buf
, ", lazyswap");
2965 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2966 strcat (buf
, ", new calling convention");
2968 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2969 strcat (buf
, ", gnu calling convention");
2973 if ((e_flags
& EF_IA_64_ABI64
))
2974 strcat (buf
, ", 64-bit");
2976 strcat (buf
, ", 32-bit");
2977 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2978 strcat (buf
, ", reduced fp model");
2979 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2980 strcat (buf
, ", no function descriptors, constant gp");
2981 else if ((e_flags
& EF_IA_64_CONS_GP
))
2982 strcat (buf
, ", constant gp");
2983 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2984 strcat (buf
, ", absolute");
2985 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2987 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2988 strcat (buf
, ", vms_linkages");
2989 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2991 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2993 case EF_IA_64_VMS_COMCOD_WARNING
:
2994 strcat (buf
, ", warning");
2996 case EF_IA_64_VMS_COMCOD_ERROR
:
2997 strcat (buf
, ", error");
2999 case EF_IA_64_VMS_COMCOD_ABORT
:
3000 strcat (buf
, ", abort");
3009 if ((e_flags
& EF_VAX_NONPIC
))
3010 strcat (buf
, ", non-PIC");
3011 if ((e_flags
& EF_VAX_DFLOAT
))
3012 strcat (buf
, ", D-Float");
3013 if ((e_flags
& EF_VAX_GFLOAT
))
3014 strcat (buf
, ", G-Float");
3018 if (e_flags
& E_FLAG_RL78_G10
)
3019 strcat (buf
, ", G10");
3020 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3021 strcat (buf
, ", 64-bit doubles");
3025 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3026 strcat (buf
, ", 64-bit doubles");
3027 if (e_flags
& E_FLAG_RX_DSP
)
3028 strcat (buf
, ", dsp");
3029 if (e_flags
& E_FLAG_RX_PID
)
3030 strcat (buf
, ", pid");
3031 if (e_flags
& E_FLAG_RX_ABI
)
3032 strcat (buf
, ", RX ABI");
3036 if (e_flags
& EF_S390_HIGH_GPRS
)
3037 strcat (buf
, ", highgprs");
3041 if ((e_flags
& EF_C6000_REL
))
3042 strcat (buf
, ", relocatable module");
3046 strcat (buf
, _(": architecture variant: "));
3047 switch (e_flags
& EF_MSP430_MACH
)
3049 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3050 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3051 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3052 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3053 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3054 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3055 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3056 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3057 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3058 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3059 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3060 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3061 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3062 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3063 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3065 strcat (buf
, _(": unknown")); break;
3068 if (e_flags
& ~ EF_MSP430_MACH
)
3069 strcat (buf
, _(": unknown extra flag bits also present"));
3077 get_osabi_name (unsigned int osabi
)
3079 static char buff
[32];
3083 case ELFOSABI_NONE
: return "UNIX - System V";
3084 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3085 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3086 case ELFOSABI_GNU
: return "UNIX - GNU";
3087 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3088 case ELFOSABI_AIX
: return "UNIX - AIX";
3089 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3090 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3091 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3092 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3093 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3094 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3095 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3096 case ELFOSABI_AROS
: return "AROS";
3097 case ELFOSABI_FENIXOS
: return "FenixOS";
3100 switch (elf_header
.e_machine
)
3105 case ELFOSABI_ARM
: return "ARM";
3115 case ELFOSABI_STANDALONE
: return _("Standalone App");
3124 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3125 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3134 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3140 get_aarch64_segment_type (unsigned long type
)
3144 case PT_AARCH64_ARCHEXT
:
3145 return "AARCH64_ARCHEXT";
3154 get_arm_segment_type (unsigned long type
)
3168 get_mips_segment_type (unsigned long type
)
3172 case PT_MIPS_REGINFO
:
3174 case PT_MIPS_RTPROC
:
3176 case PT_MIPS_OPTIONS
:
3178 case PT_MIPS_ABIFLAGS
:
3188 get_parisc_segment_type (unsigned long type
)
3192 case PT_HP_TLS
: return "HP_TLS";
3193 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3194 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3195 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3196 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3197 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3198 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3199 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3200 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3201 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3202 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3203 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3204 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3205 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3206 case PT_HP_STACK
: return "HP_STACK";
3207 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3208 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3209 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3210 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3219 get_ia64_segment_type (unsigned long type
)
3223 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3224 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3225 case PT_HP_TLS
: return "HP_TLS";
3226 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3227 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3228 case PT_IA_64_HP_STACK
: return "HP_STACK";
3237 get_tic6x_segment_type (unsigned long type
)
3241 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3250 get_segment_type (unsigned long p_type
)
3252 static char buff
[32];
3256 case PT_NULL
: return "NULL";
3257 case PT_LOAD
: return "LOAD";
3258 case PT_DYNAMIC
: return "DYNAMIC";
3259 case PT_INTERP
: return "INTERP";
3260 case PT_NOTE
: return "NOTE";
3261 case PT_SHLIB
: return "SHLIB";
3262 case PT_PHDR
: return "PHDR";
3263 case PT_TLS
: return "TLS";
3265 case PT_GNU_EH_FRAME
:
3266 return "GNU_EH_FRAME";
3267 case PT_GNU_STACK
: return "GNU_STACK";
3268 case PT_GNU_RELRO
: return "GNU_RELRO";
3271 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3273 const char * result
;
3275 switch (elf_header
.e_machine
)
3278 result
= get_aarch64_segment_type (p_type
);
3281 result
= get_arm_segment_type (p_type
);
3284 case EM_MIPS_RS3_LE
:
3285 result
= get_mips_segment_type (p_type
);
3288 result
= get_parisc_segment_type (p_type
);
3291 result
= get_ia64_segment_type (p_type
);
3294 result
= get_tic6x_segment_type (p_type
);
3304 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3306 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3308 const char * result
;
3310 switch (elf_header
.e_machine
)
3313 result
= get_parisc_segment_type (p_type
);
3316 result
= get_ia64_segment_type (p_type
);
3326 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3329 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3336 get_mips_section_type_name (unsigned int sh_type
)
3340 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3341 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3342 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3343 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3344 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3345 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3346 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3347 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3348 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3349 case SHT_MIPS_RELD
: return "MIPS_RELD";
3350 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3351 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3352 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3353 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3354 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3355 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3356 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3357 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3358 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3359 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3360 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3361 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3362 case SHT_MIPS_LINE
: return "MIPS_LINE";
3363 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3364 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3365 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3366 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3367 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3368 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3369 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3370 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3371 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3372 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3373 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3374 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3375 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3376 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3377 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3378 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3379 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3387 get_parisc_section_type_name (unsigned int sh_type
)
3391 case SHT_PARISC_EXT
: return "PARISC_EXT";
3392 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3393 case SHT_PARISC_DOC
: return "PARISC_DOC";
3394 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3395 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3396 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3397 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3405 get_ia64_section_type_name (unsigned int sh_type
)
3407 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3408 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3409 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3413 case SHT_IA_64_EXT
: return "IA_64_EXT";
3414 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3415 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3416 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3417 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3418 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3419 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3420 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3421 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3422 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3430 get_x86_64_section_type_name (unsigned int sh_type
)
3434 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3442 get_aarch64_section_type_name (unsigned int sh_type
)
3446 case SHT_AARCH64_ATTRIBUTES
:
3447 return "AARCH64_ATTRIBUTES";
3455 get_arm_section_type_name (unsigned int sh_type
)
3459 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3460 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3461 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3462 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3463 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3471 get_tic6x_section_type_name (unsigned int sh_type
)
3475 case SHT_C6000_UNWIND
:
3476 return "C6000_UNWIND";
3477 case SHT_C6000_PREEMPTMAP
:
3478 return "C6000_PREEMPTMAP";
3479 case SHT_C6000_ATTRIBUTES
:
3480 return "C6000_ATTRIBUTES";
3485 case SHT_TI_HANDLER
:
3486 return "TI_HANDLER";
3487 case SHT_TI_INITINFO
:
3488 return "TI_INITINFO";
3489 case SHT_TI_PHATTRS
:
3490 return "TI_PHATTRS";
3498 get_msp430x_section_type_name (unsigned int sh_type
)
3502 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3503 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3504 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3505 default: return NULL
;
3510 get_section_type_name (unsigned int sh_type
)
3512 static char buff
[32];
3516 case SHT_NULL
: return "NULL";
3517 case SHT_PROGBITS
: return "PROGBITS";
3518 case SHT_SYMTAB
: return "SYMTAB";
3519 case SHT_STRTAB
: return "STRTAB";
3520 case SHT_RELA
: return "RELA";
3521 case SHT_HASH
: return "HASH";
3522 case SHT_DYNAMIC
: return "DYNAMIC";
3523 case SHT_NOTE
: return "NOTE";
3524 case SHT_NOBITS
: return "NOBITS";
3525 case SHT_REL
: return "REL";
3526 case SHT_SHLIB
: return "SHLIB";
3527 case SHT_DYNSYM
: return "DYNSYM";
3528 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3529 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3530 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3531 case SHT_GNU_HASH
: return "GNU_HASH";
3532 case SHT_GROUP
: return "GROUP";
3533 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3534 case SHT_GNU_verdef
: return "VERDEF";
3535 case SHT_GNU_verneed
: return "VERNEED";
3536 case SHT_GNU_versym
: return "VERSYM";
3537 case 0x6ffffff0: return "VERSYM";
3538 case 0x6ffffffc: return "VERDEF";
3539 case 0x7ffffffd: return "AUXILIARY";
3540 case 0x7fffffff: return "FILTER";
3541 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3544 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3546 const char * result
;
3548 switch (elf_header
.e_machine
)
3551 case EM_MIPS_RS3_LE
:
3552 result
= get_mips_section_type_name (sh_type
);
3555 result
= get_parisc_section_type_name (sh_type
);
3558 result
= get_ia64_section_type_name (sh_type
);
3563 result
= get_x86_64_section_type_name (sh_type
);
3566 result
= get_aarch64_section_type_name (sh_type
);
3569 result
= get_arm_section_type_name (sh_type
);
3572 result
= get_tic6x_section_type_name (sh_type
);
3575 result
= get_msp430x_section_type_name (sh_type
);
3585 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3587 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3589 const char * result
;
3591 switch (elf_header
.e_machine
)
3594 result
= get_ia64_section_type_name (sh_type
);
3604 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3606 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3607 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3609 /* This message is probably going to be displayed in a 15
3610 character wide field, so put the hex value first. */
3611 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3617 #define OPTION_DEBUG_DUMP 512
3618 #define OPTION_DYN_SYMS 513
3619 #define OPTION_DWARF_DEPTH 514
3620 #define OPTION_DWARF_START 515
3621 #define OPTION_DWARF_CHECK 516
3623 static struct option options
[] =
3625 {"all", no_argument
, 0, 'a'},
3626 {"file-header", no_argument
, 0, 'h'},
3627 {"program-headers", no_argument
, 0, 'l'},
3628 {"headers", no_argument
, 0, 'e'},
3629 {"histogram", no_argument
, 0, 'I'},
3630 {"segments", no_argument
, 0, 'l'},
3631 {"sections", no_argument
, 0, 'S'},
3632 {"section-headers", no_argument
, 0, 'S'},
3633 {"section-groups", no_argument
, 0, 'g'},
3634 {"section-details", no_argument
, 0, 't'},
3635 {"full-section-name",no_argument
, 0, 'N'},
3636 {"symbols", no_argument
, 0, 's'},
3637 {"syms", no_argument
, 0, 's'},
3638 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3639 {"relocs", no_argument
, 0, 'r'},
3640 {"notes", no_argument
, 0, 'n'},
3641 {"dynamic", no_argument
, 0, 'd'},
3642 {"arch-specific", no_argument
, 0, 'A'},
3643 {"version-info", no_argument
, 0, 'V'},
3644 {"use-dynamic", no_argument
, 0, 'D'},
3645 {"unwind", no_argument
, 0, 'u'},
3646 {"archive-index", no_argument
, 0, 'c'},
3647 {"hex-dump", required_argument
, 0, 'x'},
3648 {"relocated-dump", required_argument
, 0, 'R'},
3649 {"string-dump", required_argument
, 0, 'p'},
3650 #ifdef SUPPORT_DISASSEMBLY
3651 {"instruction-dump", required_argument
, 0, 'i'},
3653 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3655 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3656 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3657 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3659 {"version", no_argument
, 0, 'v'},
3660 {"wide", no_argument
, 0, 'W'},
3661 {"help", no_argument
, 0, 'H'},
3662 {0, no_argument
, 0, 0}
3666 usage (FILE * stream
)
3668 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3669 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3670 fprintf (stream
, _(" Options are:\n\
3671 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3672 -h --file-header Display the ELF file header\n\
3673 -l --program-headers Display the program headers\n\
3674 --segments An alias for --program-headers\n\
3675 -S --section-headers Display the sections' header\n\
3676 --sections An alias for --section-headers\n\
3677 -g --section-groups Display the section groups\n\
3678 -t --section-details Display the section details\n\
3679 -e --headers Equivalent to: -h -l -S\n\
3680 -s --syms Display the symbol table\n\
3681 --symbols An alias for --syms\n\
3682 --dyn-syms Display the dynamic symbol table\n\
3683 -n --notes Display the core notes (if present)\n\
3684 -r --relocs Display the relocations (if present)\n\
3685 -u --unwind Display the unwind info (if present)\n\
3686 -d --dynamic Display the dynamic section (if present)\n\
3687 -V --version-info Display the version sections (if present)\n\
3688 -A --arch-specific Display architecture specific information (if any)\n\
3689 -c --archive-index Display the symbol/file index in an archive\n\
3690 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3691 -x --hex-dump=<number|name>\n\
3692 Dump the contents of section <number|name> as bytes\n\
3693 -p --string-dump=<number|name>\n\
3694 Dump the contents of section <number|name> as strings\n\
3695 -R --relocated-dump=<number|name>\n\
3696 Dump the contents of section <number|name> as relocated bytes\n\
3697 -w[lLiaprmfFsoRt] or\n\
3698 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3699 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3700 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3702 Display the contents of DWARF2 debug sections\n"));
3703 fprintf (stream
, _("\
3704 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3705 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3707 #ifdef SUPPORT_DISASSEMBLY
3708 fprintf (stream
, _("\
3709 -i --instruction-dump=<number|name>\n\
3710 Disassemble the contents of section <number|name>\n"));
3712 fprintf (stream
, _("\
3713 -I --histogram Display histogram of bucket list lengths\n\
3714 -W --wide Allow output width to exceed 80 characters\n\
3715 @<file> Read options from <file>\n\
3716 -H --help Display this information\n\
3717 -v --version Display the version number of readelf\n"));
3719 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3720 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3722 exit (stream
== stdout
? 0 : 1);
3725 /* Record the fact that the user wants the contents of section number
3726 SECTION to be displayed using the method(s) encoded as flags bits
3727 in TYPE. Note, TYPE can be zero if we are creating the array for
3731 request_dump_bynumber (unsigned int section
, dump_type type
)
3733 if (section
>= num_dump_sects
)
3735 dump_type
* new_dump_sects
;
3737 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3738 sizeof (* dump_sects
));
3740 if (new_dump_sects
== NULL
)
3741 error (_("Out of memory allocating dump request table.\n"));
3744 /* Copy current flag settings. */
3745 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3749 dump_sects
= new_dump_sects
;
3750 num_dump_sects
= section
+ 1;
3755 dump_sects
[section
] |= type
;
3760 /* Request a dump by section name. */
3763 request_dump_byname (const char * section
, dump_type type
)
3765 struct dump_list_entry
* new_request
;
3767 new_request
= (struct dump_list_entry
*)
3768 malloc (sizeof (struct dump_list_entry
));
3770 error (_("Out of memory allocating dump request table.\n"));
3772 new_request
->name
= strdup (section
);
3773 if (!new_request
->name
)
3774 error (_("Out of memory allocating dump request table.\n"));
3776 new_request
->type
= type
;
3778 new_request
->next
= dump_sects_byname
;
3779 dump_sects_byname
= new_request
;
3783 request_dump (dump_type type
)
3789 section
= strtoul (optarg
, & cp
, 0);
3791 if (! *cp
&& section
>= 0)
3792 request_dump_bynumber (section
, type
);
3794 request_dump_byname (optarg
, type
);
3799 parse_args (int argc
, char ** argv
)
3806 while ((c
= getopt_long
3807 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3825 do_section_groups
++;
3833 do_section_groups
++;
3838 do_section_details
++;
3882 request_dump (HEX_DUMP
);
3885 request_dump (STRING_DUMP
);
3888 request_dump (RELOC_DUMP
);
3895 dwarf_select_sections_all ();
3900 dwarf_select_sections_by_letters (optarg
);
3903 case OPTION_DEBUG_DUMP
:
3910 dwarf_select_sections_by_names (optarg
);
3913 case OPTION_DWARF_DEPTH
:
3917 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3920 case OPTION_DWARF_START
:
3924 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3927 case OPTION_DWARF_CHECK
:
3930 case OPTION_DYN_SYMS
:
3933 #ifdef SUPPORT_DISASSEMBLY
3935 request_dump (DISASS_DUMP
);
3939 print_version (program_name
);
3948 /* xgettext:c-format */
3949 error (_("Invalid option '-%c'\n"), c
);
3956 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3957 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3958 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3959 && !do_section_groups
&& !do_archive_index
3964 warn (_("Nothing to do.\n"));
3970 get_elf_class (unsigned int elf_class
)
3972 static char buff
[32];
3976 case ELFCLASSNONE
: return _("none");
3977 case ELFCLASS32
: return "ELF32";
3978 case ELFCLASS64
: return "ELF64";
3980 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3986 get_data_encoding (unsigned int encoding
)
3988 static char buff
[32];
3992 case ELFDATANONE
: return _("none");
3993 case ELFDATA2LSB
: return _("2's complement, little endian");
3994 case ELFDATA2MSB
: return _("2's complement, big endian");
3996 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4001 /* Decode the data held in 'elf_header'. */
4004 process_file_header (void)
4006 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4007 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4008 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4009 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4012 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4016 init_dwarf_regnames (elf_header
.e_machine
);
4022 printf (_("ELF Header:\n"));
4023 printf (_(" Magic: "));
4024 for (i
= 0; i
< EI_NIDENT
; i
++)
4025 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4027 printf (_(" Class: %s\n"),
4028 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4029 printf (_(" Data: %s\n"),
4030 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4031 printf (_(" Version: %d %s\n"),
4032 elf_header
.e_ident
[EI_VERSION
],
4033 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4035 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4036 ? _("<unknown: %lx>")
4038 printf (_(" OS/ABI: %s\n"),
4039 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4040 printf (_(" ABI Version: %d\n"),
4041 elf_header
.e_ident
[EI_ABIVERSION
]);
4042 printf (_(" Type: %s\n"),
4043 get_file_type (elf_header
.e_type
));
4044 printf (_(" Machine: %s\n"),
4045 get_machine_name (elf_header
.e_machine
));
4046 printf (_(" Version: 0x%lx\n"),
4047 (unsigned long) elf_header
.e_version
);
4049 printf (_(" Entry point address: "));
4050 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4051 printf (_("\n Start of program headers: "));
4052 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4053 printf (_(" (bytes into file)\n Start of section headers: "));
4054 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4055 printf (_(" (bytes into file)\n"));
4057 printf (_(" Flags: 0x%lx%s\n"),
4058 (unsigned long) elf_header
.e_flags
,
4059 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4060 printf (_(" Size of this header: %ld (bytes)\n"),
4061 (long) elf_header
.e_ehsize
);
4062 printf (_(" Size of program headers: %ld (bytes)\n"),
4063 (long) elf_header
.e_phentsize
);
4064 printf (_(" Number of program headers: %ld"),
4065 (long) elf_header
.e_phnum
);
4066 if (section_headers
!= NULL
4067 && elf_header
.e_phnum
== PN_XNUM
4068 && section_headers
[0].sh_info
!= 0)
4069 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4070 putc ('\n', stdout
);
4071 printf (_(" Size of section headers: %ld (bytes)\n"),
4072 (long) elf_header
.e_shentsize
);
4073 printf (_(" Number of section headers: %ld"),
4074 (long) elf_header
.e_shnum
);
4075 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4076 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4077 putc ('\n', stdout
);
4078 printf (_(" Section header string table index: %ld"),
4079 (long) elf_header
.e_shstrndx
);
4080 if (section_headers
!= NULL
4081 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4082 printf (" (%u)", section_headers
[0].sh_link
);
4083 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4084 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4085 printf (_(" <corrupt: out of range>"));
4086 putc ('\n', stdout
);
4089 if (section_headers
!= NULL
)
4091 if (elf_header
.e_phnum
== PN_XNUM
4092 && section_headers
[0].sh_info
!= 0)
4093 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4094 if (elf_header
.e_shnum
== SHN_UNDEF
)
4095 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4096 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4097 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4098 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4099 elf_header
.e_shstrndx
= SHN_UNDEF
;
4100 free (section_headers
);
4101 section_headers
= NULL
;
4109 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4111 Elf32_External_Phdr
* phdrs
;
4112 Elf32_External_Phdr
* external
;
4113 Elf_Internal_Phdr
* internal
;
4116 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4117 elf_header
.e_phentsize
,
4119 _("program headers"));
4123 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4124 i
< elf_header
.e_phnum
;
4125 i
++, internal
++, external
++)
4127 internal
->p_type
= BYTE_GET (external
->p_type
);
4128 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4129 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4130 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4131 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4132 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4133 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4134 internal
->p_align
= BYTE_GET (external
->p_align
);
4143 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4145 Elf64_External_Phdr
* phdrs
;
4146 Elf64_External_Phdr
* external
;
4147 Elf_Internal_Phdr
* internal
;
4150 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4151 elf_header
.e_phentsize
,
4153 _("program headers"));
4157 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4158 i
< elf_header
.e_phnum
;
4159 i
++, internal
++, external
++)
4161 internal
->p_type
= BYTE_GET (external
->p_type
);
4162 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4163 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4164 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4165 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4166 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4167 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4168 internal
->p_align
= BYTE_GET (external
->p_align
);
4176 /* Returns 1 if the program headers were read into `program_headers'. */
4179 get_program_headers (FILE * file
)
4181 Elf_Internal_Phdr
* phdrs
;
4183 /* Check cache of prior read. */
4184 if (program_headers
!= NULL
)
4187 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4188 sizeof (Elf_Internal_Phdr
));
4192 error (_("Out of memory\n"));
4197 ? get_32bit_program_headers (file
, phdrs
)
4198 : get_64bit_program_headers (file
, phdrs
))
4200 program_headers
= phdrs
;
4208 /* Returns 1 if the program headers were loaded. */
4211 process_program_headers (FILE * file
)
4213 Elf_Internal_Phdr
* segment
;
4216 if (elf_header
.e_phnum
== 0)
4218 /* PR binutils/12467. */
4219 if (elf_header
.e_phoff
!= 0)
4220 warn (_("possibly corrupt ELF header - it has a non-zero program"
4221 " header offset, but no program headers"));
4222 else if (do_segments
)
4223 printf (_("\nThere are no program headers in this file.\n"));
4227 if (do_segments
&& !do_header
)
4229 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4230 printf (_("Entry point "));
4231 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4232 printf (_("\nThere are %d program headers, starting at offset "),
4233 elf_header
.e_phnum
);
4234 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4238 if (! get_program_headers (file
))
4243 if (elf_header
.e_phnum
> 1)
4244 printf (_("\nProgram Headers:\n"));
4246 printf (_("\nProgram Headers:\n"));
4250 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4253 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4257 (_(" Type Offset VirtAddr PhysAddr\n"));
4259 (_(" FileSiz MemSiz Flags Align\n"));
4266 for (i
= 0, segment
= program_headers
;
4267 i
< elf_header
.e_phnum
;
4272 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4276 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4277 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4278 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4279 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4280 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4282 (segment
->p_flags
& PF_R
? 'R' : ' '),
4283 (segment
->p_flags
& PF_W
? 'W' : ' '),
4284 (segment
->p_flags
& PF_X
? 'E' : ' '));
4285 printf ("%#lx", (unsigned long) segment
->p_align
);
4289 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4290 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4293 print_vma (segment
->p_offset
, FULL_HEX
);
4297 print_vma (segment
->p_vaddr
, FULL_HEX
);
4299 print_vma (segment
->p_paddr
, FULL_HEX
);
4302 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4303 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4306 print_vma (segment
->p_filesz
, FULL_HEX
);
4310 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4311 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4314 print_vma (segment
->p_memsz
, FULL_HEX
);
4318 (segment
->p_flags
& PF_R
? 'R' : ' '),
4319 (segment
->p_flags
& PF_W
? 'W' : ' '),
4320 (segment
->p_flags
& PF_X
? 'E' : ' '));
4322 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4323 printf ("%#lx", (unsigned long) segment
->p_align
);
4326 print_vma (segment
->p_align
, PREFIX_HEX
);
4331 print_vma (segment
->p_offset
, FULL_HEX
);
4333 print_vma (segment
->p_vaddr
, FULL_HEX
);
4335 print_vma (segment
->p_paddr
, FULL_HEX
);
4337 print_vma (segment
->p_filesz
, FULL_HEX
);
4339 print_vma (segment
->p_memsz
, FULL_HEX
);
4341 (segment
->p_flags
& PF_R
? 'R' : ' '),
4342 (segment
->p_flags
& PF_W
? 'W' : ' '),
4343 (segment
->p_flags
& PF_X
? 'E' : ' '));
4344 print_vma (segment
->p_align
, HEX
);
4349 putc ('\n', stdout
);
4351 switch (segment
->p_type
)
4355 error (_("more than one dynamic segment\n"));
4357 /* By default, assume that the .dynamic section is the first
4358 section in the DYNAMIC segment. */
4359 dynamic_addr
= segment
->p_offset
;
4360 dynamic_size
= segment
->p_filesz
;
4361 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4362 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4364 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4365 dynamic_addr
= dynamic_size
= 0;
4368 /* Try to locate the .dynamic section. If there is
4369 a section header table, we can easily locate it. */
4370 if (section_headers
!= NULL
)
4372 Elf_Internal_Shdr
* sec
;
4374 sec
= find_section (".dynamic");
4375 if (sec
== NULL
|| sec
->sh_size
== 0)
4377 /* A corresponding .dynamic section is expected, but on
4378 IA-64/OpenVMS it is OK for it to be missing. */
4379 if (!is_ia64_vms ())
4380 error (_("no .dynamic section in the dynamic segment\n"));
4384 if (sec
->sh_type
== SHT_NOBITS
)
4390 dynamic_addr
= sec
->sh_offset
;
4391 dynamic_size
= sec
->sh_size
;
4393 if (dynamic_addr
< segment
->p_offset
4394 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4395 warn (_("the .dynamic section is not contained"
4396 " within the dynamic segment\n"));
4397 else if (dynamic_addr
> segment
->p_offset
)
4398 warn (_("the .dynamic section is not the first section"
4399 " in the dynamic segment.\n"));
4404 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4406 error (_("Unable to find program interpreter name\n"));
4410 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4412 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4413 error (_("Internal error: failed to create format string to display program interpreter\n"));
4415 program_interpreter
[0] = 0;
4416 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4417 error (_("Unable to read program interpreter name\n"));
4420 printf (_(" [Requesting program interpreter: %s]\n"),
4421 program_interpreter
);
4427 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4429 printf (_("\n Section to Segment mapping:\n"));
4430 printf (_(" Segment Sections...\n"));
4432 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4435 Elf_Internal_Shdr
* section
;
4437 segment
= program_headers
+ i
;
4438 section
= section_headers
+ 1;
4440 printf (" %2.2d ", i
);
4442 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4444 if (!ELF_TBSS_SPECIAL (section
, segment
)
4445 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4446 printf ("%s ", SECTION_NAME (section
));
4457 /* Find the file offset corresponding to VMA by using the program headers. */
4460 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4462 Elf_Internal_Phdr
* seg
;
4464 if (! get_program_headers (file
))
4466 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4470 for (seg
= program_headers
;
4471 seg
< program_headers
+ elf_header
.e_phnum
;
4474 if (seg
->p_type
!= PT_LOAD
)
4477 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4478 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4479 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4482 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4483 (unsigned long) vma
);
4488 /* Allocate memory and load the sections headers into the global pointer
4489 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4490 generate any error messages if the load fails. */
4493 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4495 Elf32_External_Shdr
* shdrs
;
4496 Elf_Internal_Shdr
* internal
;
4498 unsigned int size
= elf_header
.e_shentsize
;
4499 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4501 /* PR binutils/17531: Cope with unexpected section header sizes. */
4502 if (size
== 0 || num
== 0)
4504 if (size
< sizeof * shdrs
)
4507 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4510 if (!probe
&& size
> sizeof * shdrs
)
4511 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4513 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4515 probe
? NULL
: _("section headers"));
4519 if (section_headers
!= NULL
)
4520 free (section_headers
);
4521 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4522 sizeof (Elf_Internal_Shdr
));
4523 if (section_headers
== NULL
)
4526 error (_("Out of memory\n"));
4530 for (i
= 0, internal
= section_headers
;
4534 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4535 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4536 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4537 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4538 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4539 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4540 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4541 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4542 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4543 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4551 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4553 Elf64_External_Shdr
* shdrs
;
4554 Elf_Internal_Shdr
* internal
;
4556 unsigned int size
= elf_header
.e_shentsize
;
4557 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4559 /* PR binutils/17531: Cope with unexpected section header sizes. */
4560 if (size
== 0 || num
== 0)
4562 if (size
< sizeof * shdrs
)
4565 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4568 if (! probe
&& size
> sizeof * shdrs
)
4569 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4571 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4573 probe
? NULL
: _("section headers"));
4577 if (section_headers
!= NULL
)
4578 free (section_headers
);
4579 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4580 sizeof (Elf_Internal_Shdr
));
4581 if (section_headers
== NULL
)
4584 error (_("Out of memory\n"));
4588 for (i
= 0, internal
= section_headers
;
4592 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4593 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4594 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4595 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4596 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4597 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4598 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4599 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4600 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4601 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4608 static Elf_Internal_Sym
*
4609 get_32bit_elf_symbols (FILE * file
,
4610 Elf_Internal_Shdr
* section
,
4611 unsigned long * num_syms_return
)
4613 unsigned long number
= 0;
4614 Elf32_External_Sym
* esyms
= NULL
;
4615 Elf_External_Sym_Shndx
* shndx
= NULL
;
4616 Elf_Internal_Sym
* isyms
= NULL
;
4617 Elf_Internal_Sym
* psym
;
4620 /* Run some sanity checks first. */
4621 if (section
->sh_entsize
== 0)
4623 error (_("sh_entsize is zero\n"));
4627 if (section
->sh_size
> current_file_size
)
4629 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4630 SECTION_NAME (section
), (unsigned long) section
->sh_size
);
4634 number
= section
->sh_size
/ section
->sh_entsize
;
4636 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4638 error (_("Invalid sh_entsize\n"));
4642 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4643 section
->sh_size
, _("symbols"));
4648 if (symtab_shndx_hdr
!= NULL
4649 && (symtab_shndx_hdr
->sh_link
4650 == (unsigned long) (section
- section_headers
)))
4652 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4653 symtab_shndx_hdr
->sh_offset
,
4654 1, symtab_shndx_hdr
->sh_size
,
4655 _("symbol table section indicies"));
4660 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4664 error (_("Out of memory\n"));
4668 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4670 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4671 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4672 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4673 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4674 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4676 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4677 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4678 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4679 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4680 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4689 if (num_syms_return
!= NULL
)
4690 * num_syms_return
= isyms
== NULL
? 0 : number
;
4695 static Elf_Internal_Sym
*
4696 get_64bit_elf_symbols (FILE * file
,
4697 Elf_Internal_Shdr
* section
,
4698 unsigned long * num_syms_return
)
4700 unsigned long number
= 0;
4701 Elf64_External_Sym
* esyms
= NULL
;
4702 Elf_External_Sym_Shndx
* shndx
= NULL
;
4703 Elf_Internal_Sym
* isyms
= NULL
;
4704 Elf_Internal_Sym
* psym
;
4707 /* Run some sanity checks first. */
4708 if (section
->sh_entsize
== 0)
4710 error (_("sh_entsize is zero\n"));
4714 if (section
->sh_size
> current_file_size
)
4716 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4717 SECTION_NAME (section
), (unsigned long) section
->sh_size
);
4721 number
= section
->sh_size
/ section
->sh_entsize
;
4723 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4725 error (_("Invalid sh_entsize\n"));
4729 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4730 section
->sh_size
, _("symbols"));
4734 if (symtab_shndx_hdr
!= NULL
4735 && (symtab_shndx_hdr
->sh_link
4736 == (unsigned long) (section
- section_headers
)))
4738 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4739 symtab_shndx_hdr
->sh_offset
,
4740 1, symtab_shndx_hdr
->sh_size
,
4741 _("symbol table section indicies"));
4746 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4750 error (_("Out of memory\n"));
4754 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4756 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4757 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4758 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4759 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4761 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4763 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4764 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4765 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4767 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4768 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4777 if (num_syms_return
!= NULL
)
4778 * num_syms_return
= isyms
== NULL
? 0 : number
;
4784 get_elf_section_flags (bfd_vma sh_flags
)
4786 static char buff
[1024];
4788 int field_size
= is_32bit_elf
? 8 : 16;
4790 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4791 bfd_vma os_flags
= 0;
4792 bfd_vma proc_flags
= 0;
4793 bfd_vma unknown_flags
= 0;
4801 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4802 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4803 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4804 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4805 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4806 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4807 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4808 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4809 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4810 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4811 /* IA-64 specific. */
4812 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4813 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4814 /* IA-64 OpenVMS specific. */
4815 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4816 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4817 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4818 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4819 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4820 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4822 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4823 /* SPARC specific. */
4824 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4827 if (do_section_details
)
4829 sprintf (buff
, "[%*.*lx]: ",
4830 field_size
, field_size
, (unsigned long) sh_flags
);
4831 p
+= field_size
+ 4;
4838 flag
= sh_flags
& - sh_flags
;
4841 if (do_section_details
)
4845 case SHF_WRITE
: sindex
= 0; break;
4846 case SHF_ALLOC
: sindex
= 1; break;
4847 case SHF_EXECINSTR
: sindex
= 2; break;
4848 case SHF_MERGE
: sindex
= 3; break;
4849 case SHF_STRINGS
: sindex
= 4; break;
4850 case SHF_INFO_LINK
: sindex
= 5; break;
4851 case SHF_LINK_ORDER
: sindex
= 6; break;
4852 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4853 case SHF_GROUP
: sindex
= 8; break;
4854 case SHF_TLS
: sindex
= 9; break;
4855 case SHF_EXCLUDE
: sindex
= 18; break;
4859 switch (elf_header
.e_machine
)
4862 if (flag
== SHF_IA_64_SHORT
)
4864 else if (flag
== SHF_IA_64_NORECOV
)
4867 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4870 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4871 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4872 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4873 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4874 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4875 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4886 case EM_OLD_SPARCV9
:
4887 case EM_SPARC32PLUS
:
4890 if (flag
== SHF_ORDERED
)
4900 if (p
!= buff
+ field_size
+ 4)
4902 if (size
< (10 + 2))
4909 size
-= flags
[sindex
].len
;
4910 p
= stpcpy (p
, flags
[sindex
].str
);
4912 else if (flag
& SHF_MASKOS
)
4914 else if (flag
& SHF_MASKPROC
)
4917 unknown_flags
|= flag
;
4923 case SHF_WRITE
: *p
= 'W'; break;
4924 case SHF_ALLOC
: *p
= 'A'; break;
4925 case SHF_EXECINSTR
: *p
= 'X'; break;
4926 case SHF_MERGE
: *p
= 'M'; break;
4927 case SHF_STRINGS
: *p
= 'S'; break;
4928 case SHF_INFO_LINK
: *p
= 'I'; break;
4929 case SHF_LINK_ORDER
: *p
= 'L'; break;
4930 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4931 case SHF_GROUP
: *p
= 'G'; break;
4932 case SHF_TLS
: *p
= 'T'; break;
4933 case SHF_EXCLUDE
: *p
= 'E'; break;
4936 if ((elf_header
.e_machine
== EM_X86_64
4937 || elf_header
.e_machine
== EM_L1OM
4938 || elf_header
.e_machine
== EM_K1OM
)
4939 && flag
== SHF_X86_64_LARGE
)
4941 else if (flag
& SHF_MASKOS
)
4944 sh_flags
&= ~ SHF_MASKOS
;
4946 else if (flag
& SHF_MASKPROC
)
4949 sh_flags
&= ~ SHF_MASKPROC
;
4959 if (do_section_details
)
4963 size
-= 5 + field_size
;
4964 if (p
!= buff
+ field_size
+ 4)
4972 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4973 (unsigned long) os_flags
);
4974 p
+= 5 + field_size
;
4978 size
-= 7 + field_size
;
4979 if (p
!= buff
+ field_size
+ 4)
4987 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4988 (unsigned long) proc_flags
);
4989 p
+= 7 + field_size
;
4993 size
-= 10 + field_size
;
4994 if (p
!= buff
+ field_size
+ 4)
5002 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5003 (unsigned long) unknown_flags
);
5004 p
+= 10 + field_size
;
5013 process_section_headers (FILE * file
)
5015 Elf_Internal_Shdr
* section
;
5018 section_headers
= NULL
;
5020 if (elf_header
.e_shnum
== 0)
5022 /* PR binutils/12467. */
5023 if (elf_header
.e_shoff
!= 0)
5024 warn (_("possibly corrupt ELF file header - it has a non-zero"
5025 " section header offset, but no section headers\n"));
5026 else if (do_sections
)
5027 printf (_("\nThere are no sections in this file.\n"));
5032 if (do_sections
&& !do_header
)
5033 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5034 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5038 if (! get_32bit_section_headers (file
, FALSE
))
5041 else if (! get_64bit_section_headers (file
, FALSE
))
5044 /* Read in the string table, so that we have names to display. */
5045 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5046 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5048 section
= section_headers
+ elf_header
.e_shstrndx
;
5050 if (section
->sh_size
!= 0)
5052 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5053 1, section
->sh_size
,
5056 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5060 /* Scan the sections for the dynamic symbol table
5061 and dynamic string table and debug sections. */
5062 dynamic_symbols
= NULL
;
5063 dynamic_strings
= NULL
;
5064 dynamic_syminfo
= NULL
;
5065 symtab_shndx_hdr
= NULL
;
5067 eh_addr_size
= is_32bit_elf
? 4 : 8;
5068 switch (elf_header
.e_machine
)
5071 case EM_MIPS_RS3_LE
:
5072 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5073 FDE addresses. However, the ABI also has a semi-official ILP32
5074 variant for which the normal FDE address size rules apply.
5076 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5077 section, where XX is the size of longs in bits. Unfortunately,
5078 earlier compilers provided no way of distinguishing ILP32 objects
5079 from LP64 objects, so if there's any doubt, we should assume that
5080 the official LP64 form is being used. */
5081 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5082 && find_section (".gcc_compiled_long32") == NULL
)
5088 switch (elf_header
.e_flags
& EF_H8_MACH
)
5090 case E_H8_MACH_H8300
:
5091 case E_H8_MACH_H8300HN
:
5092 case E_H8_MACH_H8300SN
:
5093 case E_H8_MACH_H8300SXN
:
5096 case E_H8_MACH_H8300H
:
5097 case E_H8_MACH_H8300S
:
5098 case E_H8_MACH_H8300SX
:
5106 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5108 case EF_M32C_CPU_M16C
:
5115 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5118 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5119 if (section->sh_entsize != expected_entsize) \
5122 sprintf_vma (buf, section->sh_entsize); \
5123 /* Note: coded this way so that there is a single string for \
5125 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5126 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5127 (unsigned) expected_entsize); \
5128 section->sh_entsize = expected_entsize; \
5133 #define CHECK_ENTSIZE(section, i, type) \
5134 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5135 sizeof (Elf64_External_##type))
5137 for (i
= 0, section
= section_headers
;
5138 i
< elf_header
.e_shnum
;
5141 char * name
= SECTION_NAME (section
);
5143 if (section
->sh_type
== SHT_DYNSYM
)
5145 if (dynamic_symbols
!= NULL
)
5147 error (_("File contains multiple dynamic symbol tables\n"));
5151 CHECK_ENTSIZE (section
, i
, Sym
);
5152 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5154 else if (section
->sh_type
== SHT_STRTAB
5155 && streq (name
, ".dynstr"))
5157 if (dynamic_strings
!= NULL
)
5159 error (_("File contains multiple dynamic string tables\n"));
5163 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5164 1, section
->sh_size
,
5165 _("dynamic strings"));
5166 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5168 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5170 if (symtab_shndx_hdr
!= NULL
)
5172 error (_("File contains multiple symtab shndx tables\n"));
5175 symtab_shndx_hdr
= section
;
5177 else if (section
->sh_type
== SHT_SYMTAB
)
5178 CHECK_ENTSIZE (section
, i
, Sym
);
5179 else if (section
->sh_type
== SHT_GROUP
)
5180 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5181 else if (section
->sh_type
== SHT_REL
)
5182 CHECK_ENTSIZE (section
, i
, Rel
);
5183 else if (section
->sh_type
== SHT_RELA
)
5184 CHECK_ENTSIZE (section
, i
, Rela
);
5185 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5186 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5187 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5188 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5189 || do_debug_addr
|| do_debug_cu_index
)
5190 && (const_strneq (name
, ".debug_")
5191 || const_strneq (name
, ".zdebug_")))
5194 name
+= sizeof (".zdebug_") - 1;
5196 name
+= sizeof (".debug_") - 1;
5199 || (do_debug_info
&& const_strneq (name
, "info"))
5200 || (do_debug_info
&& const_strneq (name
, "types"))
5201 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5202 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5203 || (do_debug_lines
&& const_strneq (name
, "line."))
5204 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5205 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5206 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5207 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5208 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5209 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5210 || (do_debug_frames
&& const_strneq (name
, "frame"))
5211 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5212 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5213 || (do_debug_str
&& const_strneq (name
, "str"))
5214 || (do_debug_loc
&& const_strneq (name
, "loc"))
5215 || (do_debug_addr
&& const_strneq (name
, "addr"))
5216 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5217 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5219 request_dump_bynumber (i
, DEBUG_DUMP
);
5221 /* Linkonce section to be combined with .debug_info at link time. */
5222 else if ((do_debugging
|| do_debug_info
)
5223 && const_strneq (name
, ".gnu.linkonce.wi."))
5224 request_dump_bynumber (i
, DEBUG_DUMP
);
5225 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5226 request_dump_bynumber (i
, DEBUG_DUMP
);
5227 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5228 request_dump_bynumber (i
, DEBUG_DUMP
);
5229 /* Trace sections for Itanium VMS. */
5230 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5231 || do_trace_aranges
)
5232 && const_strneq (name
, ".trace_"))
5234 name
+= sizeof (".trace_") - 1;
5237 || (do_trace_info
&& streq (name
, "info"))
5238 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5239 || (do_trace_aranges
&& streq (name
, "aranges"))
5241 request_dump_bynumber (i
, DEBUG_DUMP
);
5249 if (elf_header
.e_shnum
> 1)
5250 printf (_("\nSection Headers:\n"));
5252 printf (_("\nSection Header:\n"));
5256 if (do_section_details
)
5258 printf (_(" [Nr] Name\n"));
5259 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5263 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5267 if (do_section_details
)
5269 printf (_(" [Nr] Name\n"));
5270 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5274 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5278 if (do_section_details
)
5280 printf (_(" [Nr] Name\n"));
5281 printf (_(" Type Address Offset Link\n"));
5282 printf (_(" Size EntSize Info Align\n"));
5286 printf (_(" [Nr] Name Type Address Offset\n"));
5287 printf (_(" Size EntSize Flags Link Info Align\n"));
5291 if (do_section_details
)
5292 printf (_(" Flags\n"));
5294 for (i
= 0, section
= section_headers
;
5295 i
< elf_header
.e_shnum
;
5298 printf (" [%2u] ", i
);
5299 if (do_section_details
)
5301 print_symbol (INT_MAX
, SECTION_NAME (section
));
5306 print_symbol (-17, SECTION_NAME (section
));
5309 printf (do_wide
? " %-15s " : " %-15.15s ",
5310 get_section_type_name (section
->sh_type
));
5314 const char * link_too_big
= NULL
;
5316 print_vma (section
->sh_addr
, LONG_HEX
);
5318 printf ( " %6.6lx %6.6lx %2.2lx",
5319 (unsigned long) section
->sh_offset
,
5320 (unsigned long) section
->sh_size
,
5321 (unsigned long) section
->sh_entsize
);
5323 if (do_section_details
)
5324 fputs (" ", stdout
);
5326 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5328 if (section
->sh_link
>= elf_header
.e_shnum
)
5331 /* The sh_link value is out of range. Normally this indicates
5332 an error but it can have special values in Solaris binaries. */
5333 switch (elf_header
.e_machine
)
5340 case EM_OLD_SPARCV9
:
5341 case EM_SPARC32PLUS
:
5344 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5345 link_too_big
= "BEFORE";
5346 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5347 link_too_big
= "AFTER";
5354 if (do_section_details
)
5356 if (link_too_big
!= NULL
&& * link_too_big
)
5357 printf ("<%s> ", link_too_big
);
5359 printf ("%2u ", section
->sh_link
);
5360 printf ("%3u %2lu\n", section
->sh_info
,
5361 (unsigned long) section
->sh_addralign
);
5364 printf ("%2u %3u %2lu\n",
5367 (unsigned long) section
->sh_addralign
);
5369 if (link_too_big
&& ! * link_too_big
)
5370 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5371 i
, section
->sh_link
);
5375 print_vma (section
->sh_addr
, LONG_HEX
);
5377 if ((long) section
->sh_offset
== section
->sh_offset
)
5378 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5382 print_vma (section
->sh_offset
, LONG_HEX
);
5385 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5386 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5390 print_vma (section
->sh_size
, LONG_HEX
);
5393 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5394 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5398 print_vma (section
->sh_entsize
, LONG_HEX
);
5401 if (do_section_details
)
5402 fputs (" ", stdout
);
5404 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5406 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5408 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5409 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5412 print_vma (section
->sh_addralign
, DEC
);
5416 else if (do_section_details
)
5418 printf (" %-15.15s ",
5419 get_section_type_name (section
->sh_type
));
5420 print_vma (section
->sh_addr
, LONG_HEX
);
5421 if ((long) section
->sh_offset
== section
->sh_offset
)
5422 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5426 print_vma (section
->sh_offset
, LONG_HEX
);
5428 printf (" %u\n ", section
->sh_link
);
5429 print_vma (section
->sh_size
, LONG_HEX
);
5431 print_vma (section
->sh_entsize
, LONG_HEX
);
5433 printf (" %-16u %lu\n",
5435 (unsigned long) section
->sh_addralign
);
5440 print_vma (section
->sh_addr
, LONG_HEX
);
5441 if ((long) section
->sh_offset
== section
->sh_offset
)
5442 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5446 print_vma (section
->sh_offset
, LONG_HEX
);
5449 print_vma (section
->sh_size
, LONG_HEX
);
5451 print_vma (section
->sh_entsize
, LONG_HEX
);
5453 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5455 printf (" %2u %3u %lu\n",
5458 (unsigned long) section
->sh_addralign
);
5461 if (do_section_details
)
5462 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5465 if (!do_section_details
)
5467 if (elf_header
.e_machine
== EM_X86_64
5468 || elf_header
.e_machine
== EM_L1OM
5469 || elf_header
.e_machine
== EM_K1OM
)
5470 printf (_("Key to Flags:\n\
5471 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5472 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5473 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5475 printf (_("Key to Flags:\n\
5476 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5477 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5478 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5485 get_group_flags (unsigned int flags
)
5487 static char buff
[32];
5497 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5504 process_section_groups (FILE * file
)
5506 Elf_Internal_Shdr
* section
;
5508 struct group
* group
;
5509 Elf_Internal_Shdr
* symtab_sec
;
5510 Elf_Internal_Shdr
* strtab_sec
;
5511 Elf_Internal_Sym
* symtab
;
5512 unsigned long num_syms
;
5516 /* Don't process section groups unless needed. */
5517 if (!do_unwind
&& !do_section_groups
)
5520 if (elf_header
.e_shnum
== 0)
5522 if (do_section_groups
)
5523 printf (_("\nThere are no sections to group in this file.\n"));
5528 if (section_headers
== NULL
)
5530 error (_("Section headers are not available!\n"));
5531 /* PR 13622: This can happen with a corrupt ELF header. */
5535 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5536 sizeof (struct group
*));
5538 if (section_headers_groups
== NULL
)
5540 error (_("Out of memory\n"));
5544 /* Scan the sections for the group section. */
5546 for (i
= 0, section
= section_headers
;
5547 i
< elf_header
.e_shnum
;
5549 if (section
->sh_type
== SHT_GROUP
)
5552 if (group_count
== 0)
5554 if (do_section_groups
)
5555 printf (_("\nThere are no section groups in this file.\n"));
5560 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5562 if (section_groups
== NULL
)
5564 error (_("Out of memory\n"));
5574 for (i
= 0, section
= section_headers
, group
= section_groups
;
5575 i
< elf_header
.e_shnum
;
5578 if (section
->sh_type
== SHT_GROUP
)
5580 char * name
= SECTION_NAME (section
);
5582 unsigned char * start
;
5583 unsigned char * indices
;
5584 unsigned int entry
, j
, size
;
5585 Elf_Internal_Shdr
* sec
;
5586 Elf_Internal_Sym
* sym
;
5588 /* Get the symbol table. */
5589 if (section
->sh_link
>= elf_header
.e_shnum
5590 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5593 error (_("Bad sh_link in group section `%s'\n"), name
);
5597 if (symtab_sec
!= sec
)
5602 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5607 error (_("Corrupt header in group section `%s'\n"), name
);
5611 if (section
->sh_info
>= num_syms
)
5613 error (_("Bad sh_info in group section `%s'\n"), name
);
5617 sym
= symtab
+ section
->sh_info
;
5619 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5621 if (sym
->st_shndx
== 0
5622 || sym
->st_shndx
>= elf_header
.e_shnum
)
5624 error (_("Bad sh_info in group section `%s'\n"), name
);
5628 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5637 /* Get the string table. */
5638 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5647 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5652 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5653 1, strtab_sec
->sh_size
,
5655 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5657 group_name
= sym
->st_name
< strtab_size
5658 ? strtab
+ sym
->st_name
: _("<corrupt>");
5661 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5662 1, section
->sh_size
,
5668 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5669 entry
= byte_get (indices
, 4);
5672 if (do_section_groups
)
5674 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5675 get_group_flags (entry
), i
, name
, group_name
, size
);
5677 printf (_(" [Index] Name\n"));
5680 group
->group_index
= i
;
5682 for (j
= 0; j
< size
; j
++)
5684 struct group_list
* g
;
5686 entry
= byte_get (indices
, 4);
5689 if (entry
>= elf_header
.e_shnum
)
5691 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5692 entry
, i
, elf_header
.e_shnum
- 1);
5696 if (section_headers_groups
[entry
] != NULL
)
5700 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5702 section_headers_groups
[entry
]->group_index
);
5707 /* Intel C/C++ compiler may put section 0 in a
5708 section group. We just warn it the first time
5709 and ignore it afterwards. */
5710 static int warned
= 0;
5713 error (_("section 0 in group section [%5u]\n"),
5714 section_headers_groups
[entry
]->group_index
);
5720 section_headers_groups
[entry
] = group
;
5722 if (do_section_groups
)
5724 sec
= section_headers
+ entry
;
5725 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5728 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5729 g
->section_index
= entry
;
5730 g
->next
= group
->root
;
5748 /* Data used to display dynamic fixups. */
5750 struct ia64_vms_dynfixup
5752 bfd_vma needed_ident
; /* Library ident number. */
5753 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5754 bfd_vma fixup_needed
; /* Index of the library. */
5755 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5756 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5759 /* Data used to display dynamic relocations. */
5761 struct ia64_vms_dynimgrela
5763 bfd_vma img_rela_cnt
; /* Number of relocations. */
5764 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5767 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5771 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5772 const char *strtab
, unsigned int strtab_sz
)
5774 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5776 const char *lib_name
;
5778 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5779 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5780 _("dynamic section image fixups"));
5784 if (fixup
->needed
< strtab_sz
)
5785 lib_name
= strtab
+ fixup
->needed
;
5788 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5789 (unsigned long) fixup
->needed
);
5792 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5793 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5795 (_("Seg Offset Type SymVec DataType\n"));
5797 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5802 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5803 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5804 type
= BYTE_GET (imfs
[i
].type
);
5805 rtype
= elf_ia64_reloc_type (type
);
5807 printf (" 0x%08x ", type
);
5809 printf (" %-32s ", rtype
);
5810 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5811 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5817 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5820 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5822 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5825 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5826 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5827 _("dynamic section image relocations"));
5831 printf (_("\nImage relocs\n"));
5833 (_("Seg Offset Type Addend Seg Sym Off\n"));
5835 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5840 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5841 printf ("%08" BFD_VMA_FMT
"x ",
5842 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5843 type
= BYTE_GET (imrs
[i
].type
);
5844 rtype
= elf_ia64_reloc_type (type
);
5846 printf ("0x%08x ", type
);
5848 printf ("%-31s ", rtype
);
5849 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5850 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5851 printf ("%08" BFD_VMA_FMT
"x\n",
5852 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5858 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5861 process_ia64_vms_dynamic_relocs (FILE *file
)
5863 struct ia64_vms_dynfixup fixup
;
5864 struct ia64_vms_dynimgrela imgrela
;
5865 Elf_Internal_Dyn
*entry
;
5867 bfd_vma strtab_off
= 0;
5868 bfd_vma strtab_sz
= 0;
5869 char *strtab
= NULL
;
5871 memset (&fixup
, 0, sizeof (fixup
));
5872 memset (&imgrela
, 0, sizeof (imgrela
));
5874 /* Note: the order of the entries is specified by the OpenVMS specs. */
5875 for (entry
= dynamic_section
;
5876 entry
< dynamic_section
+ dynamic_nent
;
5879 switch (entry
->d_tag
)
5881 case DT_IA_64_VMS_STRTAB_OFFSET
:
5882 strtab_off
= entry
->d_un
.d_val
;
5885 strtab_sz
= entry
->d_un
.d_val
;
5887 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5888 1, strtab_sz
, _("dynamic string section"));
5891 case DT_IA_64_VMS_NEEDED_IDENT
:
5892 fixup
.needed_ident
= entry
->d_un
.d_val
;
5895 fixup
.needed
= entry
->d_un
.d_val
;
5897 case DT_IA_64_VMS_FIXUP_NEEDED
:
5898 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5900 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5901 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5903 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5904 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5906 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5909 case DT_IA_64_VMS_IMG_RELA_CNT
:
5910 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5912 case DT_IA_64_VMS_IMG_RELA_OFF
:
5913 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5915 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5935 } dynamic_relocations
[] =
5937 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5938 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5939 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5942 /* Process the reloc section. */
5945 process_relocs (FILE * file
)
5947 unsigned long rel_size
;
5948 unsigned long rel_offset
;
5954 if (do_using_dynamic
)
5958 int has_dynamic_reloc
;
5961 has_dynamic_reloc
= 0;
5963 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5965 is_rela
= dynamic_relocations
[i
].rela
;
5966 name
= dynamic_relocations
[i
].name
;
5967 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5968 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5970 has_dynamic_reloc
|= rel_size
;
5972 if (is_rela
== UNKNOWN
)
5974 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5975 switch (dynamic_info
[DT_PLTREL
])
5989 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5990 name
, rel_offset
, rel_size
);
5992 dump_relocations (file
,
5993 offset_from_vma (file
, rel_offset
, rel_size
),
5995 dynamic_symbols
, num_dynamic_syms
,
5996 dynamic_strings
, dynamic_strings_length
, is_rela
);
6001 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6003 if (! has_dynamic_reloc
)
6004 printf (_("\nThere are no dynamic relocations in this file.\n"));
6008 Elf_Internal_Shdr
* section
;
6012 for (i
= 0, section
= section_headers
;
6013 i
< elf_header
.e_shnum
;
6016 if ( section
->sh_type
!= SHT_RELA
6017 && section
->sh_type
!= SHT_REL
)
6020 rel_offset
= section
->sh_offset
;
6021 rel_size
= section
->sh_size
;
6025 Elf_Internal_Shdr
* strsec
;
6028 printf (_("\nRelocation section "));
6030 if (string_table
== NULL
)
6031 printf ("%d", section
->sh_name
);
6033 printf ("'%s'", SECTION_NAME (section
));
6035 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6036 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6038 is_rela
= section
->sh_type
== SHT_RELA
;
6040 if (section
->sh_link
!= 0
6041 && section
->sh_link
< elf_header
.e_shnum
)
6043 Elf_Internal_Shdr
* symsec
;
6044 Elf_Internal_Sym
* symtab
;
6045 unsigned long nsyms
;
6046 unsigned long strtablen
= 0;
6047 char * strtab
= NULL
;
6049 symsec
= section_headers
+ section
->sh_link
;
6050 if (symsec
->sh_type
!= SHT_SYMTAB
6051 && symsec
->sh_type
!= SHT_DYNSYM
)
6054 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6059 if (symsec
->sh_link
!= 0
6060 && symsec
->sh_link
< elf_header
.e_shnum
)
6062 strsec
= section_headers
+ symsec
->sh_link
;
6064 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6067 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6070 dump_relocations (file
, rel_offset
, rel_size
,
6071 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6077 dump_relocations (file
, rel_offset
, rel_size
,
6078 NULL
, 0, NULL
, 0, is_rela
);
6085 printf (_("\nThere are no relocations in this file.\n"));
6091 /* Process the unwind section. */
6093 #include "unwind-ia64.h"
6095 /* An absolute address consists of a section and an offset. If the
6096 section is NULL, the offset itself is the address, otherwise, the
6097 address equals to LOAD_ADDRESS(section) + offset. */
6101 unsigned short section
;
6105 #define ABSADDR(a) \
6107 ? section_headers [(a).section].sh_addr + (a).offset \
6110 struct ia64_unw_table_entry
6112 struct absaddr start
;
6114 struct absaddr info
;
6117 struct ia64_unw_aux_info
6120 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6121 unsigned long table_len
; /* Length of unwind table. */
6122 unsigned char * info
; /* Unwind info. */
6123 unsigned long info_size
; /* Size of unwind info. */
6124 bfd_vma info_addr
; /* starting address of unwind info. */
6125 bfd_vma seg_base
; /* Starting address of segment. */
6126 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6127 unsigned long nsyms
; /* Number of symbols. */
6128 char * strtab
; /* The string table. */
6129 unsigned long strtab_size
; /* Size of string table. */
6133 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6134 unsigned long nsyms
,
6135 const char * strtab
,
6136 unsigned long strtab_size
,
6137 struct absaddr addr
,
6138 const char ** symname
,
6141 bfd_vma dist
= 0x100000;
6142 Elf_Internal_Sym
* sym
;
6143 Elf_Internal_Sym
* best
= NULL
;
6146 REMOVE_ARCH_BITS (addr
.offset
);
6148 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6150 bfd_vma value
= sym
->st_value
;
6152 REMOVE_ARCH_BITS (value
);
6154 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6155 && sym
->st_name
!= 0
6156 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6157 && addr
.offset
>= value
6158 && addr
.offset
- value
< dist
)
6161 dist
= addr
.offset
- value
;
6169 *symname
= (best
->st_name
>= strtab_size
6170 ? _("<corrupt>") : strtab
+ best
->st_name
);
6176 *offset
= addr
.offset
;
6180 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6182 struct ia64_unw_table_entry
* tp
;
6185 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6189 const unsigned char * dp
;
6190 const unsigned char * head
;
6191 const char * procname
;
6193 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6194 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6196 fputs ("\n<", stdout
);
6200 fputs (procname
, stdout
);
6203 printf ("+%lx", (unsigned long) offset
);
6206 fputs (">: [", stdout
);
6207 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6208 fputc ('-', stdout
);
6209 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6210 printf ("], info at +0x%lx\n",
6211 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6213 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6214 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6216 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6217 (unsigned) UNW_VER (stamp
),
6218 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6219 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6220 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6221 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6223 if (UNW_VER (stamp
) != 1)
6225 printf (_("\tUnknown version.\n"));
6230 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6231 dp
= unw_decode (dp
, in_body
, & in_body
);
6236 slurp_ia64_unwind_table (FILE * file
,
6237 struct ia64_unw_aux_info
* aux
,
6238 Elf_Internal_Shdr
* sec
)
6240 unsigned long size
, nrelas
, i
;
6241 Elf_Internal_Phdr
* seg
;
6242 struct ia64_unw_table_entry
* tep
;
6243 Elf_Internal_Shdr
* relsec
;
6244 Elf_Internal_Rela
* rela
;
6245 Elf_Internal_Rela
* rp
;
6246 unsigned char * table
;
6248 Elf_Internal_Sym
* sym
;
6249 const char * relname
;
6251 /* First, find the starting address of the segment that includes
6254 if (elf_header
.e_phnum
)
6256 if (! get_program_headers (file
))
6259 for (seg
= program_headers
;
6260 seg
< program_headers
+ elf_header
.e_phnum
;
6263 if (seg
->p_type
!= PT_LOAD
)
6266 if (sec
->sh_addr
>= seg
->p_vaddr
6267 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6269 aux
->seg_base
= seg
->p_vaddr
;
6275 /* Second, build the unwind table from the contents of the unwind section: */
6276 size
= sec
->sh_size
;
6277 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6282 aux
->table
= (struct ia64_unw_table_entry
*)
6283 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6285 for (tp
= table
; tp
< table
+ size
; ++tep
)
6287 tep
->start
.section
= SHN_UNDEF
;
6288 tep
->end
.section
= SHN_UNDEF
;
6289 tep
->info
.section
= SHN_UNDEF
;
6290 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6291 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6292 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6293 tep
->start
.offset
+= aux
->seg_base
;
6294 tep
->end
.offset
+= aux
->seg_base
;
6295 tep
->info
.offset
+= aux
->seg_base
;
6299 /* Third, apply any relocations to the unwind table: */
6300 for (relsec
= section_headers
;
6301 relsec
< section_headers
+ elf_header
.e_shnum
;
6304 if (relsec
->sh_type
!= SHT_RELA
6305 || relsec
->sh_info
>= elf_header
.e_shnum
6306 || section_headers
+ relsec
->sh_info
!= sec
)
6309 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6313 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6315 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6316 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6318 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6320 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6324 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6326 switch (rp
->r_offset
/eh_addr_size
% 3)
6329 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6330 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6333 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6334 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6337 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6338 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6348 aux
->table_len
= size
/ (3 * eh_addr_size
);
6353 ia64_process_unwind (FILE * file
)
6355 Elf_Internal_Shdr
* sec
;
6356 Elf_Internal_Shdr
* unwsec
= NULL
;
6357 Elf_Internal_Shdr
* strsec
;
6358 unsigned long i
, unwcount
= 0, unwstart
= 0;
6359 struct ia64_unw_aux_info aux
;
6361 memset (& aux
, 0, sizeof (aux
));
6363 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6365 if (sec
->sh_type
== SHT_SYMTAB
6366 && sec
->sh_link
< elf_header
.e_shnum
)
6368 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6370 strsec
= section_headers
+ sec
->sh_link
;
6371 assert (aux
.strtab
== NULL
);
6372 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6375 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6377 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6382 printf (_("\nThere are no unwind sections in this file.\n"));
6384 while (unwcount
-- > 0)
6389 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6390 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6391 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6398 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6400 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6402 /* We need to find which section group it is in. */
6403 struct group_list
* g
= section_headers_groups
[i
]->root
;
6405 for (; g
!= NULL
; g
= g
->next
)
6407 sec
= section_headers
+ g
->section_index
;
6409 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6414 i
= elf_header
.e_shnum
;
6416 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6418 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6419 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6420 suffix
= SECTION_NAME (unwsec
) + len
;
6421 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6423 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6424 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6429 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6430 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6431 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6432 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6434 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6435 suffix
= SECTION_NAME (unwsec
) + len
;
6436 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6438 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6439 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6443 if (i
== elf_header
.e_shnum
)
6445 printf (_("\nCould not find unwind info section for "));
6447 if (string_table
== NULL
)
6448 printf ("%d", unwsec
->sh_name
);
6450 printf (_("'%s'"), SECTION_NAME (unwsec
));
6454 aux
.info_addr
= sec
->sh_addr
;
6455 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6458 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6460 printf (_("\nUnwind section "));
6462 if (string_table
== NULL
)
6463 printf ("%d", unwsec
->sh_name
);
6465 printf (_("'%s'"), SECTION_NAME (unwsec
));
6467 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6468 (unsigned long) unwsec
->sh_offset
,
6469 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6471 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6473 if (aux
.table_len
> 0)
6474 dump_ia64_unwind (& aux
);
6477 free ((char *) aux
.table
);
6479 free ((char *) aux
.info
);
6488 free ((char *) aux
.strtab
);
6491 struct hppa_unw_table_entry
6493 struct absaddr start
;
6495 unsigned int Cannot_unwind
:1; /* 0 */
6496 unsigned int Millicode
:1; /* 1 */
6497 unsigned int Millicode_save_sr0
:1; /* 2 */
6498 unsigned int Region_description
:2; /* 3..4 */
6499 unsigned int reserved1
:1; /* 5 */
6500 unsigned int Entry_SR
:1; /* 6 */
6501 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6502 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6503 unsigned int Args_stored
:1; /* 16 */
6504 unsigned int Variable_Frame
:1; /* 17 */
6505 unsigned int Separate_Package_Body
:1; /* 18 */
6506 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6507 unsigned int Stack_Overflow_Check
:1; /* 20 */
6508 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6509 unsigned int Ada_Region
:1; /* 22 */
6510 unsigned int cxx_info
:1; /* 23 */
6511 unsigned int cxx_try_catch
:1; /* 24 */
6512 unsigned int sched_entry_seq
:1; /* 25 */
6513 unsigned int reserved2
:1; /* 26 */
6514 unsigned int Save_SP
:1; /* 27 */
6515 unsigned int Save_RP
:1; /* 28 */
6516 unsigned int Save_MRP_in_frame
:1; /* 29 */
6517 unsigned int extn_ptr_defined
:1; /* 30 */
6518 unsigned int Cleanup_defined
:1; /* 31 */
6520 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6521 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6522 unsigned int Large_frame
:1; /* 2 */
6523 unsigned int Pseudo_SP_Set
:1; /* 3 */
6524 unsigned int reserved4
:1; /* 4 */
6525 unsigned int Total_frame_size
:27; /* 5..31 */
6528 struct hppa_unw_aux_info
6530 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6531 unsigned long table_len
; /* Length of unwind table. */
6532 bfd_vma seg_base
; /* Starting address of segment. */
6533 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6534 unsigned long nsyms
; /* Number of symbols. */
6535 char * strtab
; /* The string table. */
6536 unsigned long strtab_size
; /* Size of string table. */
6540 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6542 struct hppa_unw_table_entry
* tp
;
6544 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6547 const char * procname
;
6549 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6550 aux
->strtab_size
, tp
->start
, &procname
,
6553 fputs ("\n<", stdout
);
6557 fputs (procname
, stdout
);
6560 printf ("+%lx", (unsigned long) offset
);
6563 fputs (">: [", stdout
);
6564 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6565 fputc ('-', stdout
);
6566 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6569 #define PF(_m) if (tp->_m) printf (#_m " ");
6570 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6573 PF(Millicode_save_sr0
);
6574 /* PV(Region_description); */
6580 PF(Separate_Package_Body
);
6581 PF(Frame_Extension_Millicode
);
6582 PF(Stack_Overflow_Check
);
6583 PF(Two_Instruction_SP_Increment
);
6587 PF(sched_entry_seq
);
6590 PF(Save_MRP_in_frame
);
6591 PF(extn_ptr_defined
);
6592 PF(Cleanup_defined
);
6593 PF(MPE_XL_interrupt_marker
);
6594 PF(HP_UX_interrupt_marker
);
6597 PV(Total_frame_size
);
6606 slurp_hppa_unwind_table (FILE * file
,
6607 struct hppa_unw_aux_info
* aux
,
6608 Elf_Internal_Shdr
* sec
)
6610 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6611 Elf_Internal_Phdr
* seg
;
6612 struct hppa_unw_table_entry
* tep
;
6613 Elf_Internal_Shdr
* relsec
;
6614 Elf_Internal_Rela
* rela
;
6615 Elf_Internal_Rela
* rp
;
6616 unsigned char * table
;
6618 Elf_Internal_Sym
* sym
;
6619 const char * relname
;
6621 /* First, find the starting address of the segment that includes
6624 if (elf_header
.e_phnum
)
6626 if (! get_program_headers (file
))
6629 for (seg
= program_headers
;
6630 seg
< program_headers
+ elf_header
.e_phnum
;
6633 if (seg
->p_type
!= PT_LOAD
)
6636 if (sec
->sh_addr
>= seg
->p_vaddr
6637 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6639 aux
->seg_base
= seg
->p_vaddr
;
6645 /* Second, build the unwind table from the contents of the unwind
6647 size
= sec
->sh_size
;
6648 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6654 nentries
= size
/ unw_ent_size
;
6655 size
= unw_ent_size
* nentries
;
6657 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6658 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6660 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6662 unsigned int tmp1
, tmp2
;
6664 tep
->start
.section
= SHN_UNDEF
;
6665 tep
->end
.section
= SHN_UNDEF
;
6667 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6668 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6669 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6670 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6672 tep
->start
.offset
+= aux
->seg_base
;
6673 tep
->end
.offset
+= aux
->seg_base
;
6675 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6676 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6677 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6678 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6679 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6680 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6681 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6682 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6683 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6684 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6685 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6686 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6687 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6688 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6689 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6690 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6691 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6692 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6693 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6694 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6695 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6696 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6697 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6698 tep
->Cleanup_defined
= tmp1
& 0x1;
6700 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6701 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6702 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6703 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6704 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6705 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6709 /* Third, apply any relocations to the unwind table. */
6710 for (relsec
= section_headers
;
6711 relsec
< section_headers
+ elf_header
.e_shnum
;
6714 if (relsec
->sh_type
!= SHT_RELA
6715 || relsec
->sh_info
>= elf_header
.e_shnum
6716 || section_headers
+ relsec
->sh_info
!= sec
)
6719 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6723 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6725 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6726 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6728 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6729 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6731 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6735 i
= rp
->r_offset
/ unw_ent_size
;
6737 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6740 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6741 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6744 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6745 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6755 aux
->table_len
= nentries
;
6761 hppa_process_unwind (FILE * file
)
6763 struct hppa_unw_aux_info aux
;
6764 Elf_Internal_Shdr
* unwsec
= NULL
;
6765 Elf_Internal_Shdr
* strsec
;
6766 Elf_Internal_Shdr
* sec
;
6769 if (string_table
== NULL
)
6772 memset (& aux
, 0, sizeof (aux
));
6774 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6776 if (sec
->sh_type
== SHT_SYMTAB
6777 && sec
->sh_link
< elf_header
.e_shnum
)
6779 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6781 strsec
= section_headers
+ sec
->sh_link
;
6782 assert (aux
.strtab
== NULL
);
6783 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6786 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6788 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6793 printf (_("\nThere are no unwind sections in this file.\n"));
6795 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6797 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6799 printf (_("\nUnwind section "));
6800 printf (_("'%s'"), SECTION_NAME (sec
));
6802 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6803 (unsigned long) sec
->sh_offset
,
6804 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6806 slurp_hppa_unwind_table (file
, &aux
, sec
);
6807 if (aux
.table_len
> 0)
6808 dump_hppa_unwind (&aux
);
6811 free ((char *) aux
.table
);
6819 free ((char *) aux
.strtab
);
6824 unsigned char * data
; /* The unwind data. */
6825 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6826 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6827 unsigned long nrelas
; /* The number of relocations. */
6828 unsigned int rel_type
; /* REL or RELA ? */
6829 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6832 struct arm_unw_aux_info
6834 FILE * file
; /* The file containing the unwind sections. */
6835 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6836 unsigned long nsyms
; /* Number of symbols. */
6837 char * strtab
; /* The file's string table. */
6838 unsigned long strtab_size
; /* Size of string table. */
6842 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6843 bfd_vma fn
, struct absaddr addr
)
6845 const char *procname
;
6848 if (addr
.section
== SHN_UNDEF
)
6851 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6852 aux
->strtab_size
, addr
, &procname
,
6855 print_vma (fn
, PREFIX_HEX
);
6859 fputs (" <", stdout
);
6860 fputs (procname
, stdout
);
6863 printf ("+0x%lx", (unsigned long) sym_offset
);
6864 fputc ('>', stdout
);
6871 arm_free_section (struct arm_section
*arm_sec
)
6873 if (arm_sec
->data
!= NULL
)
6874 free (arm_sec
->data
);
6876 if (arm_sec
->rela
!= NULL
)
6877 free (arm_sec
->rela
);
6880 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6881 cached section and install SEC instead.
6882 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6883 and return its valued in * WORDP, relocating if necessary.
6884 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6885 relocation's offset in ADDR.
6886 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6887 into the string table of the symbol associated with the reloc. If no
6888 reloc was applied store -1 there.
6889 5) Return TRUE upon success, FALSE otherwise. */
6892 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6893 struct arm_section
* arm_sec
,
6894 Elf_Internal_Shdr
* sec
,
6895 bfd_vma word_offset
,
6896 unsigned int * wordp
,
6897 struct absaddr
* addr
,
6900 Elf_Internal_Rela
*rp
;
6901 Elf_Internal_Sym
*sym
;
6902 const char * relname
;
6904 bfd_boolean wrapped
;
6906 addr
->section
= SHN_UNDEF
;
6909 if (sym_name
!= NULL
)
6910 *sym_name
= (bfd_vma
) -1;
6912 /* If necessary, update the section cache. */
6913 if (sec
!= arm_sec
->sec
)
6915 Elf_Internal_Shdr
*relsec
;
6917 arm_free_section (arm_sec
);
6920 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6921 sec
->sh_size
, _("unwind data"));
6922 arm_sec
->rela
= NULL
;
6923 arm_sec
->nrelas
= 0;
6925 for (relsec
= section_headers
;
6926 relsec
< section_headers
+ elf_header
.e_shnum
;
6929 if (relsec
->sh_info
>= elf_header
.e_shnum
6930 || section_headers
+ relsec
->sh_info
!= sec
6931 /* PR 15745: Check the section type as well. */
6932 || (relsec
->sh_type
!= SHT_REL
6933 && relsec
->sh_type
!= SHT_RELA
))
6936 arm_sec
->rel_type
= relsec
->sh_type
;
6937 if (relsec
->sh_type
== SHT_REL
)
6939 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6941 & arm_sec
->rela
, & arm_sec
->nrelas
))
6944 else /* relsec->sh_type == SHT_RELA */
6946 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6948 & arm_sec
->rela
, & arm_sec
->nrelas
))
6954 arm_sec
->next_rela
= arm_sec
->rela
;
6957 /* If there is no unwind data we can do nothing. */
6958 if (arm_sec
->data
== NULL
)
6961 /* Get the word at the required offset. */
6962 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6964 /* Look through the relocs to find the one that applies to the provided offset. */
6966 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6968 bfd_vma prelval
, offset
;
6970 if (rp
->r_offset
> word_offset
&& !wrapped
)
6975 if (rp
->r_offset
> word_offset
)
6978 if (rp
->r_offset
& 3)
6980 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6981 (unsigned long) rp
->r_offset
);
6985 if (rp
->r_offset
< word_offset
)
6988 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6990 if (arm_sec
->rel_type
== SHT_REL
)
6992 offset
= word
& 0x7fffffff;
6993 if (offset
& 0x40000000)
6994 offset
|= ~ (bfd_vma
) 0x7fffffff;
6996 else if (arm_sec
->rel_type
== SHT_RELA
)
6997 offset
= rp
->r_addend
;
7001 offset
+= sym
->st_value
;
7002 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7004 /* Check that we are processing the expected reloc type. */
7005 if (elf_header
.e_machine
== EM_ARM
)
7007 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7009 if (streq (relname
, "R_ARM_NONE"))
7012 if (! streq (relname
, "R_ARM_PREL31"))
7014 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7018 else if (elf_header
.e_machine
== EM_TI_C6000
)
7020 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7022 if (streq (relname
, "R_C6000_NONE"))
7025 if (! streq (relname
, "R_C6000_PREL31"))
7027 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7034 /* This function currently only supports ARM and TI unwinders. */
7037 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7038 addr
->section
= sym
->st_shndx
;
7039 addr
->offset
= offset
;
7041 * sym_name
= sym
->st_name
;
7046 arm_sec
->next_rela
= rp
;
7051 static const char *tic6x_unwind_regnames
[16] =
7053 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7054 "A14", "A13", "A12", "A11", "A10",
7055 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7059 decode_tic6x_unwind_regmask (unsigned int mask
)
7063 for (i
= 12; mask
; mask
>>= 1, i
--)
7067 fputs (tic6x_unwind_regnames
[i
], stdout
);
7069 fputs (", ", stdout
);
7075 if (remaining == 0 && more_words) \
7078 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7079 data_offset, & word, & addr, NULL)) \
7085 #define GET_OP(OP) \
7090 (OP) = word >> 24; \
7095 printf (_("[Truncated opcode]\n")); \
7098 printf ("0x%02x ", OP)
7101 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7102 unsigned int word
, unsigned int remaining
,
7103 unsigned int more_words
,
7104 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7105 struct arm_section
*data_arm_sec
)
7107 struct absaddr addr
;
7109 /* Decode the unwinding instructions. */
7112 unsigned int op
, op2
;
7121 printf (" 0x%02x ", op
);
7123 if ((op
& 0xc0) == 0x00)
7125 int offset
= ((op
& 0x3f) << 2) + 4;
7127 printf (" vsp = vsp + %d", offset
);
7129 else if ((op
& 0xc0) == 0x40)
7131 int offset
= ((op
& 0x3f) << 2) + 4;
7133 printf (" vsp = vsp - %d", offset
);
7135 else if ((op
& 0xf0) == 0x80)
7138 if (op
== 0x80 && op2
== 0)
7139 printf (_("Refuse to unwind"));
7142 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7147 for (i
= 0; i
< 12; i
++)
7148 if (mask
& (1 << i
))
7154 printf ("r%d", 4 + i
);
7159 else if ((op
& 0xf0) == 0x90)
7161 if (op
== 0x9d || op
== 0x9f)
7162 printf (_(" [Reserved]"));
7164 printf (" vsp = r%d", op
& 0x0f);
7166 else if ((op
& 0xf0) == 0xa0)
7168 int end
= 4 + (op
& 0x07);
7173 for (i
= 4; i
<= end
; i
++)
7189 else if (op
== 0xb0)
7190 printf (_(" finish"));
7191 else if (op
== 0xb1)
7194 if (op2
== 0 || (op2
& 0xf0) != 0)
7195 printf (_("[Spare]"));
7198 unsigned int mask
= op2
& 0x0f;
7203 for (i
= 0; i
< 12; i
++)
7204 if (mask
& (1 << i
))
7215 else if (op
== 0xb2)
7217 unsigned char buf
[9];
7218 unsigned int i
, len
;
7219 unsigned long offset
;
7221 for (i
= 0; i
< sizeof (buf
); i
++)
7224 if ((buf
[i
] & 0x80) == 0)
7227 assert (i
< sizeof (buf
));
7228 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7229 assert (len
== i
+ 1);
7230 offset
= offset
* 4 + 0x204;
7231 printf ("vsp = vsp + %ld", offset
);
7233 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7235 unsigned int first
, last
;
7242 printf ("pop {D%d", first
);
7244 printf ("-D%d", first
+ last
);
7247 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7249 unsigned int count
= op
& 0x07;
7253 printf ("-D%d", 8 + count
);
7256 else if (op
>= 0xc0 && op
<= 0xc5)
7258 unsigned int count
= op
& 0x07;
7260 printf (" pop {wR10");
7262 printf ("-wR%d", 10 + count
);
7265 else if (op
== 0xc6)
7267 unsigned int first
, last
;
7272 printf ("pop {wR%d", first
);
7274 printf ("-wR%d", first
+ last
);
7277 else if (op
== 0xc7)
7280 if (op2
== 0 || (op2
& 0xf0) != 0)
7281 printf (_("[Spare]"));
7284 unsigned int mask
= op2
& 0x0f;
7289 for (i
= 0; i
< 4; i
++)
7290 if (mask
& (1 << i
))
7296 printf ("wCGR%d", i
);
7302 printf (_(" [unsupported opcode]"));
7308 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7309 unsigned int word
, unsigned int remaining
,
7310 unsigned int more_words
,
7311 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7312 struct arm_section
*data_arm_sec
)
7314 struct absaddr addr
;
7316 /* Decode the unwinding instructions. */
7319 unsigned int op
, op2
;
7328 printf (" 0x%02x ", op
);
7330 if ((op
& 0xc0) == 0x00)
7332 int offset
= ((op
& 0x3f) << 3) + 8;
7333 printf (" sp = sp + %d", offset
);
7335 else if ((op
& 0xc0) == 0x80)
7338 if (op
== 0x80 && op2
== 0)
7339 printf (_("Refuse to unwind"));
7342 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7344 printf ("pop compact {");
7348 decode_tic6x_unwind_regmask (mask
);
7352 else if ((op
& 0xf0) == 0xc0)
7360 unsigned int offset
;
7364 /* Scan entire instruction first so that GET_OP output is not
7365 interleaved with disassembly. */
7367 for (i
= 0; nregs
< (op
& 0xf); i
++)
7373 regpos
[nregs
].offset
= i
* 2;
7374 regpos
[nregs
].reg
= reg
;
7381 regpos
[nregs
].offset
= i
* 2 + 1;
7382 regpos
[nregs
].reg
= reg
;
7387 printf (_("pop frame {"));
7389 for (i
= i
* 2; i
> 0; i
--)
7391 if (regpos
[reg
].offset
== i
- 1)
7393 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7400 fputs (name
, stdout
);
7407 else if (op
== 0xd0)
7408 printf (" MOV FP, SP");
7409 else if (op
== 0xd1)
7410 printf (" __c6xabi_pop_rts");
7411 else if (op
== 0xd2)
7413 unsigned char buf
[9];
7414 unsigned int i
, len
;
7415 unsigned long offset
;
7417 for (i
= 0; i
< sizeof (buf
); i
++)
7420 if ((buf
[i
] & 0x80) == 0)
7423 assert (i
< sizeof (buf
));
7424 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7425 assert (len
== i
+ 1);
7426 offset
= offset
* 8 + 0x408;
7427 printf (_("sp = sp + %ld"), offset
);
7429 else if ((op
& 0xf0) == 0xe0)
7431 if ((op
& 0x0f) == 7)
7434 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7438 printf (_(" [unsupported opcode]"));
7445 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7449 offset
= word
& 0x7fffffff;
7450 if (offset
& 0x40000000)
7451 offset
|= ~ (bfd_vma
) 0x7fffffff;
7453 if (elf_header
.e_machine
== EM_TI_C6000
)
7456 return offset
+ where
;
7460 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7462 unsigned int remaining
,
7463 bfd_vma data_offset
,
7464 Elf_Internal_Shdr
* data_sec
,
7465 struct arm_section
* data_arm_sec
)
7468 unsigned int more_words
= 0;
7469 struct absaddr addr
;
7470 bfd_vma sym_name
= (bfd_vma
) -1;
7474 /* Fetch the first word.
7475 Note - when decoding an object file the address extracted
7476 here will always be 0. So we also pass in the sym_name
7477 parameter so that we can find the symbol associated with
7478 the personality routine. */
7479 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7480 & word
, & addr
, & sym_name
))
7486 if ((word
& 0x80000000) == 0)
7488 /* Expand prel31 for personality routine. */
7490 const char *procname
;
7492 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7493 printf (_(" Personality routine: "));
7495 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7496 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7498 procname
= aux
->strtab
+ sym_name
;
7499 print_vma (fn
, PREFIX_HEX
);
7502 fputs (" <", stdout
);
7503 fputs (procname
, stdout
);
7504 fputc ('>', stdout
);
7508 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7509 fputc ('\n', stdout
);
7511 /* The GCC personality routines use the standard compact
7512 encoding, starting with one byte giving the number of
7514 if (procname
!= NULL
7515 && (const_strneq (procname
, "__gcc_personality_v0")
7516 || const_strneq (procname
, "__gxx_personality_v0")
7517 || const_strneq (procname
, "__gcj_personality_v0")
7518 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7525 printf (_(" [Truncated data]\n"));
7528 more_words
= word
>> 24;
7538 /* ARM EHABI Section 6.3:
7540 An exception-handling table entry for the compact model looks like:
7544 1 0 index Data for personalityRoutine[index] */
7546 if (elf_header
.e_machine
== EM_ARM
7547 && (word
& 0x70000000))
7548 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7550 per_index
= (word
>> 24) & 0x7f;
7551 printf (_(" Compact model index: %d\n"), per_index
);
7558 else if (per_index
< 3)
7560 more_words
= (word
>> 16) & 0xff;
7566 switch (elf_header
.e_machine
)
7571 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7572 data_offset
, data_sec
, data_arm_sec
);
7576 warn (_("Unknown ARM compact model index encountered\n"));
7577 printf (_(" [reserved]\n"));
7584 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7585 data_offset
, data_sec
, data_arm_sec
);
7587 else if (per_index
< 5)
7589 if (((word
>> 17) & 0x7f) == 0x7f)
7590 printf (_(" Restore stack from frame pointer\n"));
7592 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7593 printf (_(" Registers restored: "));
7595 printf (" (compact) ");
7596 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7598 printf (_(" Return register: %s\n"),
7599 tic6x_unwind_regnames
[word
& 0xf]);
7602 printf (_(" [reserved (%d)]\n"), per_index
);
7606 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7607 elf_header
.e_machine
);
7610 /* Decode the descriptors. Not implemented. */
7614 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7616 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7617 unsigned int i
, exidx_len
;
7619 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7620 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7621 exidx_len
= exidx_sec
->sh_size
/ 8;
7623 for (i
= 0; i
< exidx_len
; i
++)
7625 unsigned int exidx_fn
, exidx_entry
;
7626 struct absaddr fn_addr
, entry_addr
;
7629 fputc ('\n', stdout
);
7631 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7632 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7633 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7634 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7636 arm_free_section (& exidx_arm_sec
);
7637 arm_free_section (& extab_arm_sec
);
7641 /* ARM EHABI, Section 5:
7642 An index table entry consists of 2 words.
7643 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7644 if (exidx_fn
& 0x80000000)
7645 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7647 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7649 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7650 fputs (": ", stdout
);
7652 if (exidx_entry
== 1)
7654 print_vma (exidx_entry
, PREFIX_HEX
);
7655 fputs (" [cantunwind]\n", stdout
);
7657 else if (exidx_entry
& 0x80000000)
7659 print_vma (exidx_entry
, PREFIX_HEX
);
7660 fputc ('\n', stdout
);
7661 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7665 bfd_vma table
, table_offset
= 0;
7666 Elf_Internal_Shdr
*table_sec
;
7668 fputs ("@", stdout
);
7669 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7670 print_vma (table
, PREFIX_HEX
);
7673 /* Locate the matching .ARM.extab. */
7674 if (entry_addr
.section
!= SHN_UNDEF
7675 && entry_addr
.section
< elf_header
.e_shnum
)
7677 table_sec
= section_headers
+ entry_addr
.section
;
7678 table_offset
= entry_addr
.offset
;
7682 table_sec
= find_section_by_address (table
);
7683 if (table_sec
!= NULL
)
7684 table_offset
= table
- table_sec
->sh_addr
;
7686 if (table_sec
== NULL
)
7688 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7689 (unsigned long) table
);
7692 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7699 arm_free_section (&exidx_arm_sec
);
7700 arm_free_section (&extab_arm_sec
);
7703 /* Used for both ARM and C6X unwinding tables. */
7706 arm_process_unwind (FILE *file
)
7708 struct arm_unw_aux_info aux
;
7709 Elf_Internal_Shdr
*unwsec
= NULL
;
7710 Elf_Internal_Shdr
*strsec
;
7711 Elf_Internal_Shdr
*sec
;
7713 unsigned int sec_type
;
7715 switch (elf_header
.e_machine
)
7718 sec_type
= SHT_ARM_EXIDX
;
7722 sec_type
= SHT_C6000_UNWIND
;
7726 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7727 elf_header
.e_machine
);
7731 if (string_table
== NULL
)
7734 memset (& aux
, 0, sizeof (aux
));
7737 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7739 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7741 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7743 strsec
= section_headers
+ sec
->sh_link
;
7744 assert (aux
.strtab
== NULL
);
7745 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7746 1, strsec
->sh_size
, _("string table"));
7747 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7749 else if (sec
->sh_type
== sec_type
)
7754 printf (_("\nThere are no unwind sections in this file.\n"));
7756 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7758 if (sec
->sh_type
== sec_type
)
7760 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7762 (unsigned long) sec
->sh_offset
,
7763 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7765 dump_arm_unwind (&aux
, sec
);
7772 free ((char *) aux
.strtab
);
7776 process_unwind (FILE * file
)
7778 struct unwind_handler
7781 void (* handler
)(FILE *);
7784 { EM_ARM
, arm_process_unwind
},
7785 { EM_IA_64
, ia64_process_unwind
},
7786 { EM_PARISC
, hppa_process_unwind
},
7787 { EM_TI_C6000
, arm_process_unwind
},
7795 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7796 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7798 handlers
[i
].handler (file
);
7802 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7803 get_machine_name (elf_header
.e_machine
));
7807 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7809 switch (entry
->d_tag
)
7812 if (entry
->d_un
.d_val
== 0)
7816 static const char * opts
[] =
7818 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7819 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7820 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7821 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7827 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7828 if (entry
->d_un
.d_val
& (1 << cnt
))
7830 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7836 case DT_MIPS_IVERSION
:
7837 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7838 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7842 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
7843 /* Note: coded this way so that there is a single string for translation. */
7844 printf (_("<corrupt: %s>"), buf
);
7848 case DT_MIPS_TIME_STAMP
:
7853 time_t atime
= entry
->d_un
.d_val
;
7854 tmp
= gmtime (&atime
);
7855 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7856 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7857 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7858 printf (_("Time Stamp: %s"), timebuf
);
7862 case DT_MIPS_RLD_VERSION
:
7863 case DT_MIPS_LOCAL_GOTNO
:
7864 case DT_MIPS_CONFLICTNO
:
7865 case DT_MIPS_LIBLISTNO
:
7866 case DT_MIPS_SYMTABNO
:
7867 case DT_MIPS_UNREFEXTNO
:
7868 case DT_MIPS_HIPAGENO
:
7869 case DT_MIPS_DELTA_CLASS_NO
:
7870 case DT_MIPS_DELTA_INSTANCE_NO
:
7871 case DT_MIPS_DELTA_RELOC_NO
:
7872 case DT_MIPS_DELTA_SYM_NO
:
7873 case DT_MIPS_DELTA_CLASSSYM_NO
:
7874 case DT_MIPS_COMPACT_SIZE
:
7875 print_vma (entry
->d_un
.d_ptr
, DEC
);
7879 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7885 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7887 switch (entry
->d_tag
)
7889 case DT_HP_DLD_FLAGS
:
7898 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7899 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7900 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7901 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7902 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7903 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7904 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7905 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7906 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7907 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7908 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7909 { DT_HP_GST
, "HP_GST" },
7910 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7911 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7912 { DT_HP_NODELETE
, "HP_NODELETE" },
7913 { DT_HP_GROUP
, "HP_GROUP" },
7914 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7918 bfd_vma val
= entry
->d_un
.d_val
;
7920 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7921 if (val
& flags
[cnt
].bit
)
7925 fputs (flags
[cnt
].str
, stdout
);
7927 val
^= flags
[cnt
].bit
;
7930 if (val
!= 0 || first
)
7934 print_vma (val
, HEX
);
7940 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7948 /* VMS vs Unix time offset and factor. */
7950 #define VMS_EPOCH_OFFSET 35067168000000000LL
7951 #define VMS_GRANULARITY_FACTOR 10000000
7953 /* Display a VMS time in a human readable format. */
7956 print_vms_time (bfd_int64_t vmstime
)
7961 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7962 tm
= gmtime (&unxtime
);
7963 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7964 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7965 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7970 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7972 switch (entry
->d_tag
)
7974 case DT_IA_64_PLT_RESERVE
:
7975 /* First 3 slots reserved. */
7976 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7978 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7981 case DT_IA_64_VMS_LINKTIME
:
7983 print_vms_time (entry
->d_un
.d_val
);
7987 case DT_IA_64_VMS_LNKFLAGS
:
7988 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7989 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7990 printf (" CALL_DEBUG");
7991 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7992 printf (" NOP0BUFS");
7993 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7994 printf (" P0IMAGE");
7995 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7996 printf (" MKTHREADS");
7997 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7998 printf (" UPCALLS");
7999 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8001 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8002 printf (" INITIALIZE");
8003 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8005 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8006 printf (" EXE_INIT");
8007 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8008 printf (" TBK_IN_IMG");
8009 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8010 printf (" DBG_IN_IMG");
8011 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8012 printf (" TBK_IN_DSF");
8013 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8014 printf (" DBG_IN_DSF");
8015 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8016 printf (" SIGNATURES");
8017 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8018 printf (" REL_SEG_OFF");
8022 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8029 get_32bit_dynamic_section (FILE * file
)
8031 Elf32_External_Dyn
* edyn
;
8032 Elf32_External_Dyn
* ext
;
8033 Elf_Internal_Dyn
* entry
;
8035 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8036 dynamic_size
, _("dynamic section"));
8040 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8041 might not have the luxury of section headers. Look for the DT_NULL
8042 terminator to determine the number of entries. */
8043 for (ext
= edyn
, dynamic_nent
= 0;
8044 (char *) ext
< (char *) edyn
+ dynamic_size
;
8048 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8052 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8054 if (dynamic_section
== NULL
)
8056 error (_("Out of memory\n"));
8061 for (ext
= edyn
, entry
= dynamic_section
;
8062 entry
< dynamic_section
+ dynamic_nent
;
8065 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8066 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8075 get_64bit_dynamic_section (FILE * file
)
8077 Elf64_External_Dyn
* edyn
;
8078 Elf64_External_Dyn
* ext
;
8079 Elf_Internal_Dyn
* entry
;
8081 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8082 dynamic_size
, _("dynamic section"));
8086 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8087 might not have the luxury of section headers. Look for the DT_NULL
8088 terminator to determine the number of entries. */
8089 for (ext
= edyn
, dynamic_nent
= 0;
8090 (char *) ext
< (char *) edyn
+ dynamic_size
;
8094 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8098 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8100 if (dynamic_section
== NULL
)
8102 error (_("Out of memory\n"));
8107 for (ext
= edyn
, entry
= dynamic_section
;
8108 entry
< dynamic_section
+ dynamic_nent
;
8111 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8112 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8121 print_dynamic_flags (bfd_vma flags
)
8129 flag
= flags
& - flags
;
8139 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8140 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8141 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8142 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8143 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8144 default: fputs (_("unknown"), stdout
); break;
8150 /* Parse and display the contents of the dynamic section. */
8153 process_dynamic_section (FILE * file
)
8155 Elf_Internal_Dyn
* entry
;
8157 if (dynamic_size
== 0)
8160 printf (_("\nThere is no dynamic section in this file.\n"));
8167 if (! get_32bit_dynamic_section (file
))
8170 else if (! get_64bit_dynamic_section (file
))
8173 /* Find the appropriate symbol table. */
8174 if (dynamic_symbols
== NULL
)
8176 for (entry
= dynamic_section
;
8177 entry
< dynamic_section
+ dynamic_nent
;
8180 Elf_Internal_Shdr section
;
8182 if (entry
->d_tag
!= DT_SYMTAB
)
8185 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8187 /* Since we do not know how big the symbol table is,
8188 we default to reading in the entire file (!) and
8189 processing that. This is overkill, I know, but it
8191 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8193 if (archive_file_offset
!= 0)
8194 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8197 if (fseek (file
, 0, SEEK_END
))
8198 error (_("Unable to seek to end of file!\n"));
8200 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8204 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8206 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8208 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8209 if (num_dynamic_syms
< 1)
8211 error (_("Unable to determine the number of symbols to load\n"));
8217 /* Similarly find a string table. */
8218 if (dynamic_strings
== NULL
)
8220 for (entry
= dynamic_section
;
8221 entry
< dynamic_section
+ dynamic_nent
;
8224 unsigned long offset
;
8227 if (entry
->d_tag
!= DT_STRTAB
)
8230 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8232 /* Since we do not know how big the string table is,
8233 we default to reading in the entire file (!) and
8234 processing that. This is overkill, I know, but it
8237 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8239 if (archive_file_offset
!= 0)
8240 str_tab_len
= archive_file_size
- offset
;
8243 if (fseek (file
, 0, SEEK_END
))
8244 error (_("Unable to seek to end of file\n"));
8245 str_tab_len
= ftell (file
) - offset
;
8248 if (str_tab_len
< 1)
8251 (_("Unable to determine the length of the dynamic string table\n"));
8255 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8257 _("dynamic string table"));
8258 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8263 /* And find the syminfo section if available. */
8264 if (dynamic_syminfo
== NULL
)
8266 unsigned long syminsz
= 0;
8268 for (entry
= dynamic_section
;
8269 entry
< dynamic_section
+ dynamic_nent
;
8272 if (entry
->d_tag
== DT_SYMINENT
)
8274 /* Note: these braces are necessary to avoid a syntax
8275 error from the SunOS4 C compiler. */
8276 /* PR binutils/17531: A corrupt file can trigger this test.
8277 So do not use an assert, instead generate an error message. */
8278 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8279 error (_("Bad value (%d) for SYMINENT entry"),
8280 (int) entry
->d_un
.d_val
);
8282 else if (entry
->d_tag
== DT_SYMINSZ
)
8283 syminsz
= entry
->d_un
.d_val
;
8284 else if (entry
->d_tag
== DT_SYMINFO
)
8285 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8289 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8291 Elf_External_Syminfo
* extsyminfo
;
8292 Elf_External_Syminfo
* extsym
;
8293 Elf_Internal_Syminfo
* syminfo
;
8295 /* There is a syminfo section. Read the data. */
8296 extsyminfo
= (Elf_External_Syminfo
*)
8297 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8298 _("symbol information"));
8302 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8303 if (dynamic_syminfo
== NULL
)
8305 error (_("Out of memory\n"));
8309 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8310 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8311 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8312 ++syminfo
, ++extsym
)
8314 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8315 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8322 if (do_dynamic
&& dynamic_addr
)
8323 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8324 dynamic_addr
, dynamic_nent
);
8326 printf (_(" Tag Type Name/Value\n"));
8328 for (entry
= dynamic_section
;
8329 entry
< dynamic_section
+ dynamic_nent
;
8337 print_vma (entry
->d_tag
, FULL_HEX
);
8338 dtype
= get_dynamic_type (entry
->d_tag
);
8339 printf (" (%s)%*s", dtype
,
8340 ((is_32bit_elf
? 27 : 19)
8341 - (int) strlen (dtype
)),
8345 switch (entry
->d_tag
)
8349 print_dynamic_flags (entry
->d_un
.d_val
);
8359 switch (entry
->d_tag
)
8362 printf (_("Auxiliary library"));
8366 printf (_("Filter library"));
8370 printf (_("Configuration file"));
8374 printf (_("Dependency audit library"));
8378 printf (_("Audit library"));
8382 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8383 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8387 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8396 printf (_("Flags:"));
8398 if (entry
->d_un
.d_val
== 0)
8399 printf (_(" None\n"));
8402 unsigned long int val
= entry
->d_un
.d_val
;
8404 if (val
& DTF_1_PARINIT
)
8406 printf (" PARINIT");
8407 val
^= DTF_1_PARINIT
;
8409 if (val
& DTF_1_CONFEXP
)
8411 printf (" CONFEXP");
8412 val
^= DTF_1_CONFEXP
;
8415 printf (" %lx", val
);
8424 printf (_("Flags:"));
8426 if (entry
->d_un
.d_val
== 0)
8427 printf (_(" None\n"));
8430 unsigned long int val
= entry
->d_un
.d_val
;
8432 if (val
& DF_P1_LAZYLOAD
)
8434 printf (" LAZYLOAD");
8435 val
^= DF_P1_LAZYLOAD
;
8437 if (val
& DF_P1_GROUPPERM
)
8439 printf (" GROUPPERM");
8440 val
^= DF_P1_GROUPPERM
;
8443 printf (" %lx", val
);
8452 printf (_("Flags:"));
8453 if (entry
->d_un
.d_val
== 0)
8454 printf (_(" None\n"));
8457 unsigned long int val
= entry
->d_un
.d_val
;
8464 if (val
& DF_1_GLOBAL
)
8469 if (val
& DF_1_GROUP
)
8474 if (val
& DF_1_NODELETE
)
8476 printf (" NODELETE");
8477 val
^= DF_1_NODELETE
;
8479 if (val
& DF_1_LOADFLTR
)
8481 printf (" LOADFLTR");
8482 val
^= DF_1_LOADFLTR
;
8484 if (val
& DF_1_INITFIRST
)
8486 printf (" INITFIRST");
8487 val
^= DF_1_INITFIRST
;
8489 if (val
& DF_1_NOOPEN
)
8494 if (val
& DF_1_ORIGIN
)
8499 if (val
& DF_1_DIRECT
)
8504 if (val
& DF_1_TRANS
)
8509 if (val
& DF_1_INTERPOSE
)
8511 printf (" INTERPOSE");
8512 val
^= DF_1_INTERPOSE
;
8514 if (val
& DF_1_NODEFLIB
)
8516 printf (" NODEFLIB");
8517 val
^= DF_1_NODEFLIB
;
8519 if (val
& DF_1_NODUMP
)
8524 if (val
& DF_1_CONFALT
)
8526 printf (" CONFALT");
8527 val
^= DF_1_CONFALT
;
8529 if (val
& DF_1_ENDFILTEE
)
8531 printf (" ENDFILTEE");
8532 val
^= DF_1_ENDFILTEE
;
8534 if (val
& DF_1_DISPRELDNE
)
8536 printf (" DISPRELDNE");
8537 val
^= DF_1_DISPRELDNE
;
8539 if (val
& DF_1_DISPRELPND
)
8541 printf (" DISPRELPND");
8542 val
^= DF_1_DISPRELPND
;
8544 if (val
& DF_1_NODIRECT
)
8546 printf (" NODIRECT");
8547 val
^= DF_1_NODIRECT
;
8549 if (val
& DF_1_IGNMULDEF
)
8551 printf (" IGNMULDEF");
8552 val
^= DF_1_IGNMULDEF
;
8554 if (val
& DF_1_NOKSYMS
)
8556 printf (" NOKSYMS");
8557 val
^= DF_1_NOKSYMS
;
8559 if (val
& DF_1_NOHDR
)
8564 if (val
& DF_1_EDITED
)
8569 if (val
& DF_1_NORELOC
)
8571 printf (" NORELOC");
8572 val
^= DF_1_NORELOC
;
8574 if (val
& DF_1_SYMINTPOSE
)
8576 printf (" SYMINTPOSE");
8577 val
^= DF_1_SYMINTPOSE
;
8579 if (val
& DF_1_GLOBAUDIT
)
8581 printf (" GLOBAUDIT");
8582 val
^= DF_1_GLOBAUDIT
;
8584 if (val
& DF_1_SINGLETON
)
8586 printf (" SINGLETON");
8587 val
^= DF_1_SINGLETON
;
8590 printf (" %lx", val
);
8597 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8599 puts (get_dynamic_type (entry
->d_un
.d_val
));
8619 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8625 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8626 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8632 switch (entry
->d_tag
)
8635 printf (_("Shared library: [%s]"), name
);
8637 if (streq (name
, program_interpreter
))
8638 printf (_(" program interpreter"));
8642 printf (_("Library soname: [%s]"), name
);
8646 printf (_("Library rpath: [%s]"), name
);
8650 printf (_("Library runpath: [%s]"), name
);
8654 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8659 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8672 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8676 case DT_INIT_ARRAYSZ
:
8677 case DT_FINI_ARRAYSZ
:
8678 case DT_GNU_CONFLICTSZ
:
8679 case DT_GNU_LIBLISTSZ
:
8682 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8683 printf (_(" (bytes)\n"));
8693 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8706 if (entry
->d_tag
== DT_USED
8707 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8709 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8713 printf (_("Not needed object: [%s]\n"), name
);
8718 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8724 /* The value of this entry is ignored. */
8729 case DT_GNU_PRELINKED
:
8733 time_t atime
= entry
->d_un
.d_val
;
8735 tmp
= gmtime (&atime
);
8736 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8737 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8738 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8744 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8747 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8753 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8754 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8759 switch (elf_header
.e_machine
)
8762 case EM_MIPS_RS3_LE
:
8763 dynamic_section_mips_val (entry
);
8766 dynamic_section_parisc_val (entry
);
8769 dynamic_section_ia64_val (entry
);
8772 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8784 get_ver_flags (unsigned int flags
)
8786 static char buff
[32];
8793 if (flags
& VER_FLG_BASE
)
8794 strcat (buff
, "BASE ");
8796 if (flags
& VER_FLG_WEAK
)
8798 if (flags
& VER_FLG_BASE
)
8799 strcat (buff
, "| ");
8801 strcat (buff
, "WEAK ");
8804 if (flags
& VER_FLG_INFO
)
8806 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8807 strcat (buff
, "| ");
8809 strcat (buff
, "INFO ");
8812 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8813 strcat (buff
, _("| <unknown>"));
8818 /* Display the contents of the version sections. */
8821 process_version_sections (FILE * file
)
8823 Elf_Internal_Shdr
* section
;
8830 for (i
= 0, section
= section_headers
;
8831 i
< elf_header
.e_shnum
;
8834 switch (section
->sh_type
)
8836 case SHT_GNU_verdef
:
8838 Elf_External_Verdef
* edefs
;
8846 (_("\nVersion definition section '%s' contains %u entries:\n"),
8847 SECTION_NAME (section
), section
->sh_info
);
8849 printf (_(" Addr: 0x"));
8850 printf_vma (section
->sh_addr
);
8851 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8852 (unsigned long) section
->sh_offset
, section
->sh_link
,
8853 section
->sh_link
< elf_header
.e_shnum
8854 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8857 edefs
= (Elf_External_Verdef
*)
8858 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8859 _("version definition section"));
8862 endbuf
= (char *) edefs
+ section
->sh_size
;
8864 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8867 Elf_External_Verdef
* edef
;
8868 Elf_Internal_Verdef ent
;
8869 Elf_External_Verdaux
* eaux
;
8870 Elf_Internal_Verdaux aux
;
8874 /* Check for very large indicies. */
8875 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8878 vstart
= ((char *) edefs
) + idx
;
8879 if (vstart
+ sizeof (*edef
) > endbuf
)
8882 edef
= (Elf_External_Verdef
*) vstart
;
8884 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8885 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8886 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8887 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8888 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8889 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8890 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8892 printf (_(" %#06x: Rev: %d Flags: %s"),
8893 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8895 printf (_(" Index: %d Cnt: %d "),
8896 ent
.vd_ndx
, ent
.vd_cnt
);
8898 /* Check for overflow. */
8899 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8902 vstart
+= ent
.vd_aux
;
8904 eaux
= (Elf_External_Verdaux
*) vstart
;
8906 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8907 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8909 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8910 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8912 printf (_("Name index: %ld\n"), aux
.vda_name
);
8914 isum
= idx
+ ent
.vd_aux
;
8916 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8918 /* Check for overflow. */
8919 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8922 isum
+= aux
.vda_next
;
8923 vstart
+= aux
.vda_next
;
8925 eaux
= (Elf_External_Verdaux
*) vstart
;
8926 if (vstart
+ sizeof (*eaux
) > endbuf
)
8929 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8930 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8932 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8933 printf (_(" %#06x: Parent %d: %s\n"),
8934 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8936 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8937 isum
, j
, aux
.vda_name
);
8941 printf (_(" Version def aux past end of section\n"));
8946 if (cnt
< section
->sh_info
)
8947 printf (_(" Version definition past end of section\n"));
8953 case SHT_GNU_verneed
:
8955 Elf_External_Verneed
* eneed
;
8962 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8963 SECTION_NAME (section
), section
->sh_info
);
8965 printf (_(" Addr: 0x"));
8966 printf_vma (section
->sh_addr
);
8967 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8968 (unsigned long) section
->sh_offset
, section
->sh_link
,
8969 section
->sh_link
< elf_header
.e_shnum
8970 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8973 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8974 section
->sh_offset
, 1,
8976 _("Version Needs section"));
8979 endbuf
= (char *) eneed
+ section
->sh_size
;
8981 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8983 Elf_External_Verneed
* entry
;
8984 Elf_Internal_Verneed ent
;
8989 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8992 vstart
= ((char *) eneed
) + idx
;
8993 if (vstart
+ sizeof (*entry
) > endbuf
)
8996 entry
= (Elf_External_Verneed
*) vstart
;
8998 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8999 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9000 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9001 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9002 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9004 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9006 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9007 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9009 printf (_(" File: %lx"), ent
.vn_file
);
9011 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9013 /* Check for overflow. */
9014 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9017 vstart
+= ent
.vn_aux
;
9019 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9021 Elf_External_Vernaux
* eaux
;
9022 Elf_Internal_Vernaux aux
;
9024 if (vstart
+ sizeof (*eaux
) > endbuf
)
9026 eaux
= (Elf_External_Vernaux
*) vstart
;
9028 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9029 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9030 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9031 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9032 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9034 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9035 printf (_(" %#06x: Name: %s"),
9036 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9038 printf (_(" %#06x: Name index: %lx"),
9039 isum
, aux
.vna_name
);
9041 printf (_(" Flags: %s Version: %d\n"),
9042 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9044 /* Check for overflow. */
9045 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9048 isum
+= aux
.vna_next
;
9049 vstart
+= aux
.vna_next
;
9053 warn (_("Missing Version Needs auxillary information\n"));
9055 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9057 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9058 cnt
= section
->sh_info
;
9064 if (cnt
< section
->sh_info
)
9065 warn (_("Missing Version Needs information\n"));
9071 case SHT_GNU_versym
:
9073 Elf_Internal_Shdr
* link_section
;
9076 unsigned char * edata
;
9077 unsigned short * data
;
9079 Elf_Internal_Sym
* symbols
;
9080 Elf_Internal_Shdr
* string_sec
;
9081 unsigned long num_syms
;
9084 if (section
->sh_link
>= elf_header
.e_shnum
)
9087 link_section
= section_headers
+ section
->sh_link
;
9088 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9090 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9095 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9096 if (symbols
== NULL
)
9099 string_sec
= section_headers
+ link_section
->sh_link
;
9101 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9102 string_sec
->sh_size
,
9103 _("version string table"));
9110 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9111 SECTION_NAME (section
), total
);
9113 printf (_(" Addr: "));
9114 printf_vma (section
->sh_addr
);
9115 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9116 (unsigned long) section
->sh_offset
, section
->sh_link
,
9117 SECTION_NAME (link_section
));
9119 off
= offset_from_vma (file
,
9120 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9121 total
* sizeof (short));
9122 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9124 _("version symbol data"));
9132 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9134 for (cnt
= total
; cnt
--;)
9135 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9140 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9143 int check_def
, check_need
;
9146 printf (" %03x:", cnt
);
9148 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9149 switch (data
[cnt
+ j
])
9152 fputs (_(" 0 (*local*) "), stdout
);
9156 fputs (_(" 1 (*global*) "), stdout
);
9160 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9161 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9163 /* If this index value is greater than the size of the symbols
9164 array, break to avoid an out-of-bounds read. */
9165 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9167 warn (_("invalid index into symbol array\n"));
9173 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9174 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9177 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9184 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9186 Elf_Internal_Verneed ivn
;
9187 unsigned long offset
;
9189 offset
= offset_from_vma
9190 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9191 sizeof (Elf_External_Verneed
));
9195 Elf_Internal_Vernaux ivna
;
9196 Elf_External_Verneed evn
;
9197 Elf_External_Vernaux evna
;
9198 unsigned long a_off
;
9200 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9201 _("version need")) == NULL
)
9204 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9205 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9207 a_off
= offset
+ ivn
.vn_aux
;
9211 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9212 1, _("version need aux (2)")) == NULL
)
9219 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9220 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9223 a_off
+= ivna
.vna_next
;
9225 while (ivna
.vna_other
!= data
[cnt
+ j
]
9226 && ivna
.vna_next
!= 0);
9228 if (ivna
.vna_other
== data
[cnt
+ j
])
9230 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9232 if (ivna
.vna_name
>= string_sec
->sh_size
)
9233 name
= _("*invalid*");
9235 name
= strtab
+ ivna
.vna_name
;
9236 nn
+= printf ("(%s%-*s",
9238 12 - (int) strlen (name
),
9244 offset
+= ivn
.vn_next
;
9246 while (ivn
.vn_next
);
9249 if (check_def
&& data
[cnt
+ j
] != 0x8001
9250 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9252 Elf_Internal_Verdef ivd
;
9253 Elf_External_Verdef evd
;
9254 unsigned long offset
;
9256 offset
= offset_from_vma
9257 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9262 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9263 _("version def")) == NULL
)
9270 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9271 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9274 offset
+= ivd
.vd_next
;
9276 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9277 && ivd
.vd_next
!= 0);
9279 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9281 Elf_External_Verdaux evda
;
9282 Elf_Internal_Verdaux ivda
;
9284 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9286 if (get_data (&evda
, file
,
9287 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9289 _("version def aux")) == NULL
)
9292 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9294 if (ivda
.vda_name
>= string_sec
->sh_size
)
9295 name
= _("*invalid*");
9297 name
= strtab
+ ivda
.vda_name
;
9298 nn
+= printf ("(%s%-*s",
9300 12 - (int) strlen (name
),
9306 printf ("%*c", 18 - nn
, ' ');
9324 printf (_("\nNo version information found in this file.\n"));
9330 get_symbol_binding (unsigned int binding
)
9332 static char buff
[32];
9336 case STB_LOCAL
: return "LOCAL";
9337 case STB_GLOBAL
: return "GLOBAL";
9338 case STB_WEAK
: return "WEAK";
9340 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9341 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9343 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9345 if (binding
== STB_GNU_UNIQUE
9346 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9347 /* GNU is still using the default value 0. */
9348 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9350 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9353 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9359 get_symbol_type (unsigned int type
)
9361 static char buff
[32];
9365 case STT_NOTYPE
: return "NOTYPE";
9366 case STT_OBJECT
: return "OBJECT";
9367 case STT_FUNC
: return "FUNC";
9368 case STT_SECTION
: return "SECTION";
9369 case STT_FILE
: return "FILE";
9370 case STT_COMMON
: return "COMMON";
9371 case STT_TLS
: return "TLS";
9372 case STT_RELC
: return "RELC";
9373 case STT_SRELC
: return "SRELC";
9375 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9377 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9378 return "THUMB_FUNC";
9380 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9383 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9384 return "PARISC_MILLI";
9386 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9388 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9390 if (elf_header
.e_machine
== EM_PARISC
)
9392 if (type
== STT_HP_OPAQUE
)
9394 if (type
== STT_HP_STUB
)
9398 if (type
== STT_GNU_IFUNC
9399 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9400 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9401 /* GNU is still using the default value 0. */
9402 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9405 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9408 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9414 get_symbol_visibility (unsigned int visibility
)
9418 case STV_DEFAULT
: return "DEFAULT";
9419 case STV_INTERNAL
: return "INTERNAL";
9420 case STV_HIDDEN
: return "HIDDEN";
9421 case STV_PROTECTED
: return "PROTECTED";
9427 get_mips_symbol_other (unsigned int other
)
9439 case STO_MICROMIPS
| STO_MIPS_PIC
:
9440 return "MICROMIPS, MIPS PIC";
9449 get_ia64_symbol_other (unsigned int other
)
9453 static char res
[32];
9457 /* Function types is for images and .STB files only. */
9458 switch (elf_header
.e_type
)
9462 switch (VMS_ST_FUNC_TYPE (other
))
9464 case VMS_SFT_CODE_ADDR
:
9465 strcat (res
, " CA");
9467 case VMS_SFT_SYMV_IDX
:
9468 strcat (res
, " VEC");
9471 strcat (res
, " FD");
9473 case VMS_SFT_RESERVE
:
9474 strcat (res
, " RSV");
9483 switch (VMS_ST_LINKAGE (other
))
9485 case VMS_STL_IGNORE
:
9486 strcat (res
, " IGN");
9488 case VMS_STL_RESERVE
:
9489 strcat (res
, " RSV");
9492 strcat (res
, " STD");
9495 strcat (res
, " LNK");
9510 get_ppc64_symbol_other (unsigned int other
)
9512 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9514 static char buf
[32];
9515 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9516 PPC64_LOCAL_ENTRY_OFFSET (other
));
9523 get_symbol_other (unsigned int other
)
9525 const char * result
= NULL
;
9526 static char buff
[32];
9531 switch (elf_header
.e_machine
)
9534 result
= get_mips_symbol_other (other
);
9537 result
= get_ia64_symbol_other (other
);
9540 result
= get_ppc64_symbol_other (other
);
9549 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9554 get_symbol_index_type (unsigned int type
)
9556 static char buff
[32];
9560 case SHN_UNDEF
: return "UND";
9561 case SHN_ABS
: return "ABS";
9562 case SHN_COMMON
: return "COM";
9564 if (type
== SHN_IA_64_ANSI_COMMON
9565 && elf_header
.e_machine
== EM_IA_64
9566 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9568 else if ((elf_header
.e_machine
== EM_X86_64
9569 || elf_header
.e_machine
== EM_L1OM
9570 || elf_header
.e_machine
== EM_K1OM
)
9571 && type
== SHN_X86_64_LCOMMON
)
9573 else if ((type
== SHN_MIPS_SCOMMON
9574 && elf_header
.e_machine
== EM_MIPS
)
9575 || (type
== SHN_TIC6X_SCOMMON
9576 && elf_header
.e_machine
== EM_TI_C6000
))
9578 else if (type
== SHN_MIPS_SUNDEFINED
9579 && elf_header
.e_machine
== EM_MIPS
)
9581 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9582 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9583 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9584 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9585 else if (type
>= SHN_LORESERVE
)
9586 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9587 else if (type
>= elf_header
.e_shnum
)
9588 sprintf (buff
, "bad section index[%3d]", type
);
9590 sprintf (buff
, "%3d", type
);
9598 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9600 unsigned char * e_data
;
9603 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9607 error (_("Out of memory\n"));
9611 if (fread (e_data
, ent_size
, number
, file
) != number
)
9613 error (_("Unable to read in dynamic data\n"));
9617 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9621 error (_("Out of memory\n"));
9627 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9635 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9637 Elf_Internal_Sym
* psym
;
9640 psym
= dynamic_symbols
+ si
;
9642 n
= print_vma (si
, DEC_5
);
9644 fputs (&" "[n
], stdout
);
9645 printf (" %3lu: ", hn
);
9646 print_vma (psym
->st_value
, LONG_HEX
);
9648 print_vma (psym
->st_size
, DEC_5
);
9650 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9651 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9652 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9653 /* Check to see if any other bits in the st_other field are set.
9654 Note - displaying this information disrupts the layout of the
9655 table being generated, but for the moment this case is very
9657 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9658 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9659 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9660 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9661 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9663 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9667 /* Dump the symbol table. */
9669 process_symbol_table (FILE * file
)
9671 Elf_Internal_Shdr
* section
;
9672 bfd_vma nbuckets
= 0;
9673 bfd_vma nchains
= 0;
9674 bfd_vma
* buckets
= NULL
;
9675 bfd_vma
* chains
= NULL
;
9676 bfd_vma ngnubuckets
= 0;
9677 bfd_vma
* gnubuckets
= NULL
;
9678 bfd_vma
* gnuchains
= NULL
;
9679 bfd_vma gnusymidx
= 0;
9681 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9684 if (dynamic_info
[DT_HASH
]
9686 || (do_using_dynamic
9688 && dynamic_strings
!= NULL
)))
9690 unsigned char nb
[8];
9691 unsigned char nc
[8];
9692 int hash_ent_size
= 4;
9694 if ((elf_header
.e_machine
== EM_ALPHA
9695 || elf_header
.e_machine
== EM_S390
9696 || elf_header
.e_machine
== EM_S390_OLD
)
9697 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9701 (archive_file_offset
9702 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9703 sizeof nb
+ sizeof nc
)),
9706 error (_("Unable to seek to start of dynamic information\n"));
9710 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9712 error (_("Failed to read in number of buckets\n"));
9716 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9718 error (_("Failed to read in number of chains\n"));
9722 nbuckets
= byte_get (nb
, hash_ent_size
);
9723 nchains
= byte_get (nc
, hash_ent_size
);
9725 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9726 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9729 if (buckets
== NULL
|| chains
== NULL
)
9731 if (do_using_dynamic
)
9742 if (dynamic_info_DT_GNU_HASH
9744 || (do_using_dynamic
9746 && dynamic_strings
!= NULL
)))
9748 unsigned char nb
[16];
9749 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9750 bfd_vma buckets_vma
;
9753 (archive_file_offset
9754 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9758 error (_("Unable to seek to start of dynamic information\n"));
9762 if (fread (nb
, 16, 1, file
) != 1)
9764 error (_("Failed to read in number of buckets\n"));
9768 ngnubuckets
= byte_get (nb
, 4);
9769 gnusymidx
= byte_get (nb
+ 4, 4);
9770 bitmaskwords
= byte_get (nb
+ 8, 4);
9771 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9773 buckets_vma
+= bitmaskwords
* 4;
9775 buckets_vma
+= bitmaskwords
* 8;
9778 (archive_file_offset
9779 + offset_from_vma (file
, buckets_vma
, 4)),
9782 error (_("Unable to seek to start of dynamic information\n"));
9786 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9788 if (gnubuckets
== NULL
)
9791 for (i
= 0; i
< ngnubuckets
; i
++)
9792 if (gnubuckets
[i
] != 0)
9794 if (gnubuckets
[i
] < gnusymidx
)
9797 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9798 maxchain
= gnubuckets
[i
];
9801 if (maxchain
== 0xffffffff)
9804 maxchain
-= gnusymidx
;
9807 (archive_file_offset
9808 + offset_from_vma (file
, buckets_vma
9809 + 4 * (ngnubuckets
+ maxchain
), 4)),
9812 error (_("Unable to seek to start of dynamic information\n"));
9818 if (fread (nb
, 4, 1, file
) != 1)
9820 error (_("Failed to determine last chain length\n"));
9824 if (maxchain
+ 1 == 0)
9829 while ((byte_get (nb
, 4) & 1) == 0);
9832 (archive_file_offset
9833 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9836 error (_("Unable to seek to start of dynamic information\n"));
9840 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9843 if (gnuchains
== NULL
)
9848 if (do_using_dynamic
)
9853 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9856 && dynamic_strings
!= NULL
)
9860 if (dynamic_info
[DT_HASH
])
9864 printf (_("\nSymbol table for image:\n"));
9866 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9868 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9870 for (hn
= 0; hn
< nbuckets
; hn
++)
9875 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9876 print_dynamic_symbol (si
, hn
);
9880 if (dynamic_info_DT_GNU_HASH
)
9882 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9884 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9886 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9888 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9889 if (gnubuckets
[hn
] != 0)
9891 bfd_vma si
= gnubuckets
[hn
];
9892 bfd_vma off
= si
- gnusymidx
;
9896 print_dynamic_symbol (si
, hn
);
9899 while ((gnuchains
[off
++] & 1) == 0);
9903 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9907 for (i
= 0, section
= section_headers
;
9908 i
< elf_header
.e_shnum
;
9912 char * strtab
= NULL
;
9913 unsigned long int strtab_size
= 0;
9914 Elf_Internal_Sym
* symtab
;
9915 Elf_Internal_Sym
* psym
;
9916 unsigned long num_syms
;
9918 if ((section
->sh_type
!= SHT_SYMTAB
9919 && section
->sh_type
!= SHT_DYNSYM
)
9921 && section
->sh_type
== SHT_SYMTAB
))
9924 if (section
->sh_entsize
== 0)
9926 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9927 SECTION_NAME (section
));
9931 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9932 SECTION_NAME (section
),
9933 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9936 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9938 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9940 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9944 if (section
->sh_link
== elf_header
.e_shstrndx
)
9946 strtab
= string_table
;
9947 strtab_size
= string_table_length
;
9949 else if (section
->sh_link
< elf_header
.e_shnum
)
9951 Elf_Internal_Shdr
* string_sec
;
9953 string_sec
= section_headers
+ section
->sh_link
;
9955 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9956 1, string_sec
->sh_size
,
9958 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9961 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9963 printf ("%6d: ", si
);
9964 print_vma (psym
->st_value
, LONG_HEX
);
9966 print_vma (psym
->st_size
, DEC_5
);
9967 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9968 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9969 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9970 /* Check to see if any other bits in the st_other field are set.
9971 Note - displaying this information disrupts the layout of the
9972 table being generated, but for the moment this case is very rare. */
9973 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9974 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9975 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9976 print_symbol (25, psym
->st_name
< strtab_size
9977 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9979 if (section
->sh_type
== SHT_DYNSYM
9980 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9982 unsigned char data
[2];
9983 unsigned short vers_data
;
9984 unsigned long offset
;
9988 offset
= offset_from_vma
9989 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9990 sizeof data
+ si
* sizeof (vers_data
));
9992 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9993 sizeof (data
), 1, _("version data")) == NULL
)
9996 vers_data
= byte_get (data
, 2);
9998 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9999 && section_headers
[psym
->st_shndx
].sh_type
10002 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10004 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10006 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10007 && (is_nobits
|| ! check_def
))
10009 Elf_External_Verneed evn
;
10010 Elf_Internal_Verneed ivn
;
10011 Elf_Internal_Vernaux ivna
;
10013 /* We must test both. */
10014 offset
= offset_from_vma
10015 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10020 unsigned long vna_off
;
10022 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10023 _("version need")) == NULL
)
10026 ivna
.vna_other
= 0;
10031 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10032 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10034 vna_off
= offset
+ ivn
.vn_aux
;
10038 Elf_External_Vernaux evna
;
10040 if (get_data (&evna
, file
, vna_off
,
10042 _("version need aux (3)")) == NULL
)
10045 ivna
.vna_other
= 0;
10050 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10051 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10052 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10055 vna_off
+= ivna
.vna_next
;
10057 while (ivna
.vna_other
!= vers_data
10058 && ivna
.vna_next
!= 0);
10060 if (ivna
.vna_other
== vers_data
)
10063 offset
+= ivn
.vn_next
;
10065 while (ivn
.vn_next
!= 0);
10067 if (ivna
.vna_other
== vers_data
)
10069 printf ("@%s (%d)",
10070 ivna
.vna_name
< strtab_size
10071 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10075 else if (! is_nobits
)
10076 error (_("bad dynamic symbol\n"));
10083 if (vers_data
!= 0x8001
10084 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10086 Elf_Internal_Verdef ivd
;
10087 Elf_Internal_Verdaux ivda
;
10088 Elf_External_Verdaux evda
;
10091 off
= offset_from_vma
10093 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10094 sizeof (Elf_External_Verdef
));
10098 Elf_External_Verdef evd
;
10100 if (get_data (&evd
, file
, off
, sizeof (evd
),
10101 1, _("version def")) == NULL
)
10109 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10110 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10111 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10114 off
+= ivd
.vd_next
;
10116 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10117 && ivd
.vd_next
!= 0);
10119 off
-= ivd
.vd_next
;
10122 if (get_data (&evda
, file
, off
, sizeof (evda
),
10123 1, _("version def aux")) == NULL
)
10126 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10128 if (psym
->st_name
!= ivda
.vda_name
)
10129 printf ((vers_data
& VERSYM_HIDDEN
)
10131 ivda
.vda_name
< strtab_size
10132 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10142 if (strtab
!= string_table
)
10148 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10150 if (do_histogram
&& buckets
!= NULL
)
10152 unsigned long * lengths
;
10153 unsigned long * counts
;
10156 unsigned long maxlength
= 0;
10157 unsigned long nzero_counts
= 0;
10158 unsigned long nsyms
= 0;
10160 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10161 (unsigned long) nbuckets
);
10162 printf (_(" Length Number %% of total Coverage\n"));
10164 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10165 if (lengths
== NULL
)
10167 error (_("Out of memory\n"));
10170 for (hn
= 0; hn
< nbuckets
; ++hn
)
10172 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10175 if (maxlength
< ++lengths
[hn
])
10178 /* PR binutils/17531: A corrupt binary could contain broken
10179 histogram data. Do not go into an infinite loop trying
10181 if (chains
[si
] == si
)
10183 error (_("histogram chain links to itself\n"));
10189 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10190 if (counts
== NULL
)
10193 error (_("Out of memory\n"));
10197 for (hn
= 0; hn
< nbuckets
; ++hn
)
10198 ++counts
[lengths
[hn
]];
10203 printf (" 0 %-10lu (%5.1f%%)\n",
10204 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10205 for (i
= 1; i
<= maxlength
; ++i
)
10207 nzero_counts
+= counts
[i
] * i
;
10208 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10209 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10210 (nzero_counts
* 100.0) / nsyms
);
10218 if (buckets
!= NULL
)
10224 if (do_histogram
&& gnubuckets
!= NULL
)
10226 unsigned long * lengths
;
10227 unsigned long * counts
;
10229 unsigned long maxlength
= 0;
10230 unsigned long nzero_counts
= 0;
10231 unsigned long nsyms
= 0;
10233 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10234 if (lengths
== NULL
)
10236 error (_("Out of memory\n"));
10240 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10241 (unsigned long) ngnubuckets
);
10242 printf (_(" Length Number %% of total Coverage\n"));
10244 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10245 if (gnubuckets
[hn
] != 0)
10247 bfd_vma off
, length
= 1;
10249 for (off
= gnubuckets
[hn
] - gnusymidx
;
10250 (gnuchains
[off
] & 1) == 0; ++off
)
10252 lengths
[hn
] = length
;
10253 if (length
> maxlength
)
10254 maxlength
= length
;
10258 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10259 if (counts
== NULL
)
10262 error (_("Out of memory\n"));
10266 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10267 ++counts
[lengths
[hn
]];
10269 if (ngnubuckets
> 0)
10272 printf (" 0 %-10lu (%5.1f%%)\n",
10273 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10274 for (j
= 1; j
<= maxlength
; ++j
)
10276 nzero_counts
+= counts
[j
] * j
;
10277 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10278 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10279 (nzero_counts
* 100.0) / nsyms
);
10293 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10297 if (dynamic_syminfo
== NULL
10299 /* No syminfo, this is ok. */
10302 /* There better should be a dynamic symbol section. */
10303 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10307 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10308 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10310 printf (_(" Num: Name BoundTo Flags\n"));
10311 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10313 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10315 printf ("%4d: ", i
);
10316 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10317 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10319 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10322 switch (dynamic_syminfo
[i
].si_boundto
)
10324 case SYMINFO_BT_SELF
:
10325 fputs ("SELF ", stdout
);
10327 case SYMINFO_BT_PARENT
:
10328 fputs ("PARENT ", stdout
);
10331 if (dynamic_syminfo
[i
].si_boundto
> 0
10332 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10333 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10335 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10339 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10343 if (flags
& SYMINFO_FLG_DIRECT
)
10344 printf (" DIRECT");
10345 if (flags
& SYMINFO_FLG_PASSTHRU
)
10346 printf (" PASSTHRU");
10347 if (flags
& SYMINFO_FLG_COPY
)
10349 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10350 printf (" LAZYLOAD");
10358 /* Check to see if the given reloc needs to be handled in a target specific
10359 manner. If so then process the reloc and return TRUE otherwise return
10363 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10364 unsigned char * start
,
10365 Elf_Internal_Sym
* symtab
)
10367 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10369 switch (elf_header
.e_machine
)
10372 case EM_MSP430_OLD
:
10374 static Elf_Internal_Sym
* saved_sym
= NULL
;
10376 switch (reloc_type
)
10378 case 10: /* R_MSP430_SYM_DIFF */
10379 if (uses_msp430x_relocs ())
10381 case 21: /* R_MSP430X_SYM_DIFF */
10382 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10385 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10386 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10387 goto handle_sym_diff
;
10389 case 5: /* R_MSP430_16_BYTE */
10390 case 9: /* R_MSP430_8 */
10391 if (uses_msp430x_relocs ())
10393 goto handle_sym_diff
;
10395 case 2: /* R_MSP430_ABS16 */
10396 case 15: /* R_MSP430X_ABS16 */
10397 if (! uses_msp430x_relocs ())
10399 goto handle_sym_diff
;
10402 if (saved_sym
!= NULL
)
10406 value
= reloc
->r_addend
10407 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10408 - saved_sym
->st_value
);
10410 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10418 if (saved_sym
!= NULL
)
10419 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10426 case EM_CYGNUS_MN10300
:
10428 static Elf_Internal_Sym
* saved_sym
= NULL
;
10430 switch (reloc_type
)
10432 case 34: /* R_MN10300_ALIGN */
10434 case 33: /* R_MN10300_SYM_DIFF */
10435 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10437 case 1: /* R_MN10300_32 */
10438 case 2: /* R_MN10300_16 */
10439 if (saved_sym
!= NULL
)
10443 value
= reloc
->r_addend
10444 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10445 - saved_sym
->st_value
);
10447 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10454 if (saved_sym
!= NULL
)
10455 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10465 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10466 DWARF debug sections. This is a target specific test. Note - we do not
10467 go through the whole including-target-headers-multiple-times route, (as
10468 we have already done with <elf/h8.h>) because this would become very
10469 messy and even then this function would have to contain target specific
10470 information (the names of the relocs instead of their numeric values).
10471 FIXME: This is not the correct way to solve this problem. The proper way
10472 is to have target specific reloc sizing and typing functions created by
10473 the reloc-macros.h header, in the same way that it already creates the
10474 reloc naming functions. */
10477 is_32bit_abs_reloc (unsigned int reloc_type
)
10479 switch (elf_header
.e_machine
)
10483 return reloc_type
== 1; /* R_386_32. */
10485 return reloc_type
== 1; /* R_68K_32. */
10487 return reloc_type
== 1; /* R_860_32. */
10489 return reloc_type
== 2; /* R_960_32. */
10491 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10493 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10495 return reloc_type
== 1; /* R_ARC_32. */
10497 return reloc_type
== 2; /* R_ARM_ABS32 */
10500 return reloc_type
== 1;
10501 case EM_ADAPTEVA_EPIPHANY
:
10502 return reloc_type
== 3;
10504 return reloc_type
== 0x12; /* R_byte4_data. */
10506 return reloc_type
== 3; /* R_CRIS_32. */
10508 return reloc_type
== 3; /* R_CR16_NUM32. */
10510 return reloc_type
== 15; /* R_CRX_NUM32. */
10511 case EM_CYGNUS_FRV
:
10512 return reloc_type
== 1;
10513 case EM_CYGNUS_D10V
:
10515 return reloc_type
== 6; /* R_D10V_32. */
10516 case EM_CYGNUS_D30V
:
10518 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10520 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10521 case EM_CYGNUS_FR30
:
10523 return reloc_type
== 3; /* R_FR30_32. */
10527 return reloc_type
== 1; /* R_H8_DIR32. */
10529 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10532 return reloc_type
== 2; /* R_IP2K_32. */
10534 return reloc_type
== 2; /* R_IQ2000_32. */
10535 case EM_LATTICEMICO32
:
10536 return reloc_type
== 3; /* R_LM32_32. */
10539 return reloc_type
== 3; /* R_M32C_32. */
10541 return reloc_type
== 34; /* R_M32R_32_RELA. */
10543 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10544 case EM_CYGNUS_MEP
:
10545 return reloc_type
== 4; /* R_MEP_32. */
10547 return reloc_type
== 2; /* R_METAG_ADDR32. */
10548 case EM_MICROBLAZE
:
10549 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10551 return reloc_type
== 2; /* R_MIPS_32. */
10553 return reloc_type
== 4; /* R_MMIX_32. */
10554 case EM_CYGNUS_MN10200
:
10556 return reloc_type
== 1; /* R_MN10200_32. */
10557 case EM_CYGNUS_MN10300
:
10559 return reloc_type
== 1; /* R_MN10300_32. */
10561 return reloc_type
== 1; /* R_MOXIE_32. */
10562 case EM_MSP430_OLD
:
10564 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10566 return reloc_type
== 2; /* R_MT_32. */
10568 return reloc_type
== 20; /* R_NDS32_RELA. */
10569 case EM_ALTERA_NIOS2
:
10570 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10572 return reloc_type
== 1; /* R_NIOS_32. */
10574 return reloc_type
== 1; /* R_OR1K_32. */
10576 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10577 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10580 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10582 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10584 return reloc_type
== 1; /* R_PPC_ADDR32. */
10586 return reloc_type
== 1; /* R_RL78_DIR32. */
10588 return reloc_type
== 1; /* R_RX_DIR32. */
10590 return reloc_type
== 1; /* R_I370_ADDR31. */
10593 return reloc_type
== 4; /* R_S390_32. */
10595 return reloc_type
== 8; /* R_SCORE_ABS32. */
10597 return reloc_type
== 1; /* R_SH_DIR32. */
10598 case EM_SPARC32PLUS
:
10601 return reloc_type
== 3 /* R_SPARC_32. */
10602 || reloc_type
== 23; /* R_SPARC_UA32. */
10604 return reloc_type
== 6; /* R_SPU_ADDR32 */
10606 return reloc_type
== 1; /* R_C6000_ABS32. */
10608 return reloc_type
== 2; /* R_TILEGX_32. */
10610 return reloc_type
== 1; /* R_TILEPRO_32. */
10611 case EM_CYGNUS_V850
:
10613 return reloc_type
== 6; /* R_V850_ABS32. */
10615 return reloc_type
== 0x33; /* R_V810_WORD. */
10617 return reloc_type
== 1; /* R_VAX_32. */
10621 return reloc_type
== 10; /* R_X86_64_32. */
10624 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10626 return reloc_type
== 4; /* R_XGATE_32. */
10628 return reloc_type
== 1; /* R_XSTROMY16_32. */
10629 case EM_XTENSA_OLD
:
10631 return reloc_type
== 1; /* R_XTENSA_32. */
10633 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10634 elf_header
.e_machine
);
10639 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10640 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10643 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10645 switch (elf_header
.e_machine
)
10649 return reloc_type
== 2; /* R_386_PC32. */
10651 return reloc_type
== 4; /* R_68K_PC32. */
10653 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10654 case EM_ADAPTEVA_EPIPHANY
:
10655 return reloc_type
== 6;
10657 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10659 return reloc_type
== 3; /* R_ARM_REL32 */
10660 case EM_MICROBLAZE
:
10661 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10663 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10665 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10667 return reloc_type
== 26; /* R_PPC_REL32. */
10669 return reloc_type
== 26; /* R_PPC64_REL32. */
10672 return reloc_type
== 5; /* R_390_PC32. */
10674 return reloc_type
== 2; /* R_SH_REL32. */
10675 case EM_SPARC32PLUS
:
10678 return reloc_type
== 6; /* R_SPARC_DISP32. */
10680 return reloc_type
== 13; /* R_SPU_REL32. */
10682 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10684 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10688 return reloc_type
== 2; /* R_X86_64_PC32. */
10689 case EM_XTENSA_OLD
:
10691 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10693 /* Do not abort or issue an error message here. Not all targets use
10694 pc-relative 32-bit relocs in their DWARF debug information and we
10695 have already tested for target coverage in is_32bit_abs_reloc. A
10696 more helpful warning message will be generated by apply_relocations
10697 anyway, so just return. */
10702 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10703 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10706 is_64bit_abs_reloc (unsigned int reloc_type
)
10708 switch (elf_header
.e_machine
)
10711 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10713 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10715 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10717 return reloc_type
== 80; /* R_PARISC_DIR64. */
10719 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10720 case EM_SPARC32PLUS
:
10723 return reloc_type
== 54; /* R_SPARC_UA64. */
10727 return reloc_type
== 1; /* R_X86_64_64. */
10730 return reloc_type
== 22; /* R_S390_64. */
10732 return reloc_type
== 1; /* R_TILEGX_64. */
10734 return reloc_type
== 18; /* R_MIPS_64. */
10740 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10741 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10744 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10746 switch (elf_header
.e_machine
)
10749 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10751 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10753 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10755 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10757 return reloc_type
== 44; /* R_PPC64_REL64. */
10758 case EM_SPARC32PLUS
:
10761 return reloc_type
== 46; /* R_SPARC_DISP64. */
10765 return reloc_type
== 24; /* R_X86_64_PC64. */
10768 return reloc_type
== 23; /* R_S390_PC64. */
10770 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10777 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10780 is_24bit_abs_reloc (unsigned int reloc_type
)
10782 switch (elf_header
.e_machine
)
10784 case EM_CYGNUS_MN10200
:
10786 return reloc_type
== 4; /* R_MN10200_24. */
10792 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10793 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10796 is_16bit_abs_reloc (unsigned int reloc_type
)
10798 switch (elf_header
.e_machine
)
10802 return reloc_type
== 4; /* R_AVR_16. */
10803 case EM_ADAPTEVA_EPIPHANY
:
10804 return reloc_type
== 5;
10805 case EM_CYGNUS_D10V
:
10807 return reloc_type
== 3; /* R_D10V_16. */
10811 return reloc_type
== R_H8_DIR16
;
10814 return reloc_type
== 1; /* R_IP2K_16. */
10817 return reloc_type
== 1; /* R_M32C_16 */
10819 if (uses_msp430x_relocs ())
10820 return reloc_type
== 2; /* R_MSP430_ABS16. */
10821 case EM_MSP430_OLD
:
10822 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10824 return reloc_type
== 19; /* R_NDS32_RELA. */
10825 case EM_ALTERA_NIOS2
:
10826 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10828 return reloc_type
== 9; /* R_NIOS_16. */
10830 return reloc_type
== 2; /* R_OR1K_16. */
10832 return reloc_type
== 2; /* R_C6000_ABS16. */
10835 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10836 case EM_CYGNUS_MN10200
:
10838 return reloc_type
== 2; /* R_MN10200_16. */
10839 case EM_CYGNUS_MN10300
:
10841 return reloc_type
== 2; /* R_MN10300_16. */
10843 return reloc_type
== 3; /* R_XGATE_16. */
10849 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10850 relocation entries (possibly formerly used for SHT_GROUP sections). */
10853 is_none_reloc (unsigned int reloc_type
)
10855 switch (elf_header
.e_machine
)
10857 case EM_68K
: /* R_68K_NONE. */
10858 case EM_386
: /* R_386_NONE. */
10859 case EM_SPARC32PLUS
:
10861 case EM_SPARC
: /* R_SPARC_NONE. */
10862 case EM_MIPS
: /* R_MIPS_NONE. */
10863 case EM_PARISC
: /* R_PARISC_NONE. */
10864 case EM_ALPHA
: /* R_ALPHA_NONE. */
10865 case EM_ADAPTEVA_EPIPHANY
:
10866 case EM_PPC
: /* R_PPC_NONE. */
10867 case EM_PPC64
: /* R_PPC64_NONE. */
10868 case EM_ARM
: /* R_ARM_NONE. */
10869 case EM_IA_64
: /* R_IA64_NONE. */
10870 case EM_SH
: /* R_SH_NONE. */
10872 case EM_S390
: /* R_390_NONE. */
10873 case EM_CRIS
: /* R_CRIS_NONE. */
10874 case EM_X86_64
: /* R_X86_64_NONE. */
10875 case EM_L1OM
: /* R_X86_64_NONE. */
10876 case EM_K1OM
: /* R_X86_64_NONE. */
10877 case EM_MN10300
: /* R_MN10300_NONE. */
10878 case EM_MOXIE
: /* R_MOXIE_NONE. */
10879 case EM_M32R
: /* R_M32R_NONE. */
10880 case EM_TI_C6000
:/* R_C6000_NONE. */
10881 case EM_TILEGX
: /* R_TILEGX_NONE. */
10882 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10884 case EM_C166
: /* R_XC16X_NONE. */
10885 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10886 case EM_NIOS32
: /* R_NIOS_NONE. */
10887 case EM_OR1K
: /* R_OR1K_NONE. */
10888 return reloc_type
== 0;
10890 return reloc_type
== 0 || reloc_type
== 256;
10892 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10893 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10894 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10895 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10896 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10897 case EM_XTENSA_OLD
:
10899 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10900 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10901 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10902 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10904 return reloc_type
== 3; /* R_METAG_NONE. */
10909 /* Apply relocations to a section.
10910 Note: So far support has been added only for those relocations
10911 which can be found in debug sections.
10912 FIXME: Add support for more relocations ? */
10915 apply_relocations (void * file
,
10916 Elf_Internal_Shdr
* section
,
10917 unsigned char * start
)
10919 Elf_Internal_Shdr
* relsec
;
10920 unsigned char * end
= start
+ section
->sh_size
;
10922 if (elf_header
.e_type
!= ET_REL
)
10925 /* Find the reloc section associated with the section. */
10926 for (relsec
= section_headers
;
10927 relsec
< section_headers
+ elf_header
.e_shnum
;
10930 bfd_boolean is_rela
;
10931 unsigned long num_relocs
;
10932 Elf_Internal_Rela
* relocs
;
10933 Elf_Internal_Rela
* rp
;
10934 Elf_Internal_Shdr
* symsec
;
10935 Elf_Internal_Sym
* symtab
;
10936 unsigned long num_syms
;
10937 Elf_Internal_Sym
* sym
;
10939 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10940 || relsec
->sh_info
>= elf_header
.e_shnum
10941 || section_headers
+ relsec
->sh_info
!= section
10942 || relsec
->sh_size
== 0
10943 || relsec
->sh_link
>= elf_header
.e_shnum
)
10946 is_rela
= relsec
->sh_type
== SHT_RELA
;
10950 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10951 relsec
->sh_size
, & relocs
, & num_relocs
))
10956 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10957 relsec
->sh_size
, & relocs
, & num_relocs
))
10961 /* SH uses RELA but uses in place value instead of the addend field. */
10962 if (elf_header
.e_machine
== EM_SH
)
10965 symsec
= section_headers
+ relsec
->sh_link
;
10966 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10968 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10971 unsigned int reloc_type
;
10972 unsigned int reloc_size
;
10973 unsigned char * rloc
;
10974 unsigned long sym_index
;
10976 reloc_type
= get_reloc_type (rp
->r_info
);
10978 if (target_specific_reloc_handling (rp
, start
, symtab
))
10980 else if (is_none_reloc (reloc_type
))
10982 else if (is_32bit_abs_reloc (reloc_type
)
10983 || is_32bit_pcrel_reloc (reloc_type
))
10985 else if (is_64bit_abs_reloc (reloc_type
)
10986 || is_64bit_pcrel_reloc (reloc_type
))
10988 else if (is_24bit_abs_reloc (reloc_type
))
10990 else if (is_16bit_abs_reloc (reloc_type
))
10994 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10995 reloc_type
, SECTION_NAME (section
));
10999 rloc
= start
+ rp
->r_offset
;
11000 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11002 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11003 (unsigned long) rp
->r_offset
,
11004 SECTION_NAME (section
));
11008 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11009 if (sym_index
>= num_syms
)
11011 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11012 sym_index
, SECTION_NAME (section
));
11015 sym
= symtab
+ sym_index
;
11017 /* If the reloc has a symbol associated with it,
11018 make sure that it is of an appropriate type.
11020 Relocations against symbols without type can happen.
11021 Gcc -feliminate-dwarf2-dups may generate symbols
11022 without type for debug info.
11024 Icc generates relocations against function symbols
11025 instead of local labels.
11027 Relocations against object symbols can happen, eg when
11028 referencing a global array. For an example of this see
11029 the _clz.o binary in libgcc.a. */
11031 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11033 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11034 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11035 (long int)(rp
- relocs
),
11036 SECTION_NAME (relsec
));
11042 addend
+= rp
->r_addend
;
11043 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11044 partial_inplace. */
11046 || (elf_header
.e_machine
== EM_XTENSA
11047 && reloc_type
== 1)
11048 || ((elf_header
.e_machine
== EM_PJ
11049 || elf_header
.e_machine
== EM_PJ_OLD
)
11050 && reloc_type
== 1)
11051 || ((elf_header
.e_machine
== EM_D30V
11052 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11053 && reloc_type
== 12))
11054 addend
+= byte_get (rloc
, reloc_size
);
11056 if (is_32bit_pcrel_reloc (reloc_type
)
11057 || is_64bit_pcrel_reloc (reloc_type
))
11059 /* On HPPA, all pc-relative relocations are biased by 8. */
11060 if (elf_header
.e_machine
== EM_PARISC
)
11062 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11066 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11075 #ifdef SUPPORT_DISASSEMBLY
11077 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11079 printf (_("\nAssembly dump of section %s\n"),
11080 SECTION_NAME (section
));
11082 /* XXX -- to be done --- XXX */
11088 /* Reads in the contents of SECTION from FILE, returning a pointer
11089 to a malloc'ed buffer or NULL if something went wrong. */
11092 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11094 bfd_size_type num_bytes
;
11096 num_bytes
= section
->sh_size
;
11098 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11100 printf (_("\nSection '%s' has no data to dump.\n"),
11101 SECTION_NAME (section
));
11105 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11106 _("section contents"));
11111 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11113 Elf_Internal_Shdr
* relsec
;
11114 bfd_size_type num_bytes
;
11118 char * name
= SECTION_NAME (section
);
11119 bfd_boolean some_strings_shown
;
11121 start
= get_section_contents (section
, file
);
11125 printf (_("\nString dump of section '%s':\n"), name
);
11127 /* If the section being dumped has relocations against it the user might
11128 be expecting these relocations to have been applied. Check for this
11129 case and issue a warning message in order to avoid confusion.
11130 FIXME: Maybe we ought to have an option that dumps a section with
11131 relocs applied ? */
11132 for (relsec
= section_headers
;
11133 relsec
< section_headers
+ elf_header
.e_shnum
;
11136 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11137 || relsec
->sh_info
>= elf_header
.e_shnum
11138 || section_headers
+ relsec
->sh_info
!= section
11139 || relsec
->sh_size
== 0
11140 || relsec
->sh_link
>= elf_header
.e_shnum
)
11143 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11147 num_bytes
= section
->sh_size
;
11149 end
= start
+ num_bytes
;
11150 some_strings_shown
= FALSE
;
11154 while (!ISPRINT (* data
))
11155 if (++ data
>= end
)
11161 /* PR 11128: Use two separate invocations in order to work
11162 around bugs in the Solaris 8 implementation of printf. */
11163 printf (" [%6tx] ", data
- start
);
11164 printf ("%s\n", data
);
11166 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11168 data
+= strlen (data
);
11169 some_strings_shown
= TRUE
;
11173 if (! some_strings_shown
)
11174 printf (_(" No strings found in this section."));
11182 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11184 bfd_boolean relocate
)
11186 Elf_Internal_Shdr
* relsec
;
11187 bfd_size_type bytes
;
11189 unsigned char * data
;
11190 unsigned char * start
;
11192 start
= (unsigned char *) get_section_contents (section
, file
);
11196 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
11200 apply_relocations (file
, section
, start
);
11204 /* If the section being dumped has relocations against it the user might
11205 be expecting these relocations to have been applied. Check for this
11206 case and issue a warning message in order to avoid confusion.
11207 FIXME: Maybe we ought to have an option that dumps a section with
11208 relocs applied ? */
11209 for (relsec
= section_headers
;
11210 relsec
< section_headers
+ elf_header
.e_shnum
;
11213 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11214 || relsec
->sh_info
>= elf_header
.e_shnum
11215 || section_headers
+ relsec
->sh_info
!= section
11216 || relsec
->sh_size
== 0
11217 || relsec
->sh_link
>= elf_header
.e_shnum
)
11220 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11225 addr
= section
->sh_addr
;
11226 bytes
= section
->sh_size
;
11235 lbytes
= (bytes
> 16 ? 16 : bytes
);
11237 printf (" 0x%8.8lx ", (unsigned long) addr
);
11239 for (j
= 0; j
< 16; j
++)
11242 printf ("%2.2x", data
[j
]);
11250 for (j
= 0; j
< lbytes
; j
++)
11253 if (k
>= ' ' && k
< 0x7f)
11271 /* Uncompresses a section that was compressed using zlib, in place. */
11274 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11275 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11277 #ifndef HAVE_ZLIB_H
11280 dwarf_size_type compressed_size
= *size
;
11281 unsigned char * compressed_buffer
= *buffer
;
11282 dwarf_size_type uncompressed_size
;
11283 unsigned char * uncompressed_buffer
;
11286 dwarf_size_type header_size
= 12;
11288 /* Read the zlib header. In this case, it should be "ZLIB" followed
11289 by the uncompressed section size, 8 bytes in big-endian order. */
11290 if (compressed_size
< header_size
11291 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11294 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11295 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11296 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11297 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11298 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11299 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11300 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11301 uncompressed_size
+= compressed_buffer
[11];
11303 /* It is possible the section consists of several compressed
11304 buffers concatenated together, so we uncompress in a loop. */
11305 strm
.zalloc
= NULL
;
11307 strm
.opaque
= NULL
;
11308 strm
.avail_in
= compressed_size
- header_size
;
11309 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11310 strm
.avail_out
= uncompressed_size
;
11311 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11313 rc
= inflateInit (& strm
);
11314 while (strm
.avail_in
> 0)
11318 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11319 + (uncompressed_size
- strm
.avail_out
));
11320 rc
= inflate (&strm
, Z_FINISH
);
11321 if (rc
!= Z_STREAM_END
)
11323 rc
= inflateReset (& strm
);
11325 rc
= inflateEnd (& strm
);
11327 || strm
.avail_out
!= 0)
11330 free (compressed_buffer
);
11331 *buffer
= uncompressed_buffer
;
11332 *size
= uncompressed_size
;
11336 free (uncompressed_buffer
);
11337 /* Indicate decompression failure. */
11340 #endif /* HAVE_ZLIB_H */
11344 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11345 Elf_Internal_Shdr
* sec
, void * file
)
11347 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11350 /* If it is already loaded, do nothing. */
11351 if (section
->start
!= NULL
)
11354 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11355 section
->address
= sec
->sh_addr
;
11356 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11358 sec
->sh_size
, buf
);
11359 if (section
->start
== NULL
)
11363 section
->size
= sec
->sh_size
;
11364 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11365 sec
->sh_size
= section
->size
;
11368 if (section
->start
== NULL
)
11371 if (debug_displays
[debug
].relocate
)
11372 apply_relocations ((FILE *) file
, sec
, section
->start
);
11377 /* If this is not NULL, load_debug_section will only look for sections
11378 within the list of sections given here. */
11379 unsigned int *section_subset
= NULL
;
11382 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11384 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11385 Elf_Internal_Shdr
* sec
;
11387 /* Locate the debug section. */
11388 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11390 section
->name
= section
->uncompressed_name
;
11393 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11395 section
->name
= section
->compressed_name
;
11400 /* If we're loading from a subset of sections, and we've loaded
11401 a section matching this name before, it's likely that it's a
11403 if (section_subset
!= NULL
)
11404 free_debug_section (debug
);
11406 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11410 free_debug_section (enum dwarf_section_display_enum debug
)
11412 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11414 if (section
->start
== NULL
)
11417 free ((char *) section
->start
);
11418 section
->start
= NULL
;
11419 section
->address
= 0;
11424 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11426 char * name
= SECTION_NAME (section
);
11427 bfd_size_type length
;
11431 length
= section
->sh_size
;
11434 printf (_("\nSection '%s' has no debugging data.\n"), name
);
11437 if (section
->sh_type
== SHT_NOBITS
)
11439 /* There is no point in dumping the contents of a debugging section
11440 which has the NOBITS type - the bits in the file will be random.
11441 This can happen when a file containing a .eh_frame section is
11442 stripped with the --only-keep-debug command line option. */
11443 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
11447 if (const_strneq (name
, ".gnu.linkonce.wi."))
11448 name
= ".debug_info";
11450 /* See if we know how to display the contents of this section. */
11451 for (i
= 0; i
< max
; i
++)
11452 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11453 || (i
== line
&& const_strneq (name
, ".debug_line."))
11454 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11456 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11457 int secondary
= (section
!= find_section (name
));
11460 free_debug_section ((enum dwarf_section_display_enum
) i
);
11462 if (i
== line
&& const_strneq (name
, ".debug_line."))
11464 else if (streq (sec
->uncompressed_name
, name
))
11465 sec
->name
= sec
->uncompressed_name
;
11467 sec
->name
= sec
->compressed_name
;
11468 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11471 /* If this debug section is part of a CU/TU set in a .dwp file,
11472 restrict load_debug_section to the sections in that set. */
11473 section_subset
= find_cu_tu_set (file
, shndx
);
11475 result
&= debug_displays
[i
].display (sec
, file
);
11477 section_subset
= NULL
;
11479 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11480 free_debug_section ((enum dwarf_section_display_enum
) i
);
11488 printf (_("Unrecognized debug section: %s\n"), name
);
11495 /* Set DUMP_SECTS for all sections where dumps were requested
11496 based on section name. */
11499 initialise_dumps_byname (void)
11501 struct dump_list_entry
* cur
;
11503 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11508 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11509 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11511 request_dump_bynumber (i
, cur
->type
);
11516 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11522 process_section_contents (FILE * file
)
11524 Elf_Internal_Shdr
* section
;
11530 initialise_dumps_byname ();
11532 for (i
= 0, section
= section_headers
;
11533 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11536 #ifdef SUPPORT_DISASSEMBLY
11537 if (dump_sects
[i
] & DISASS_DUMP
)
11538 disassemble_section (section
, file
);
11540 if (dump_sects
[i
] & HEX_DUMP
)
11541 dump_section_as_bytes (section
, file
, FALSE
);
11543 if (dump_sects
[i
] & RELOC_DUMP
)
11544 dump_section_as_bytes (section
, file
, TRUE
);
11546 if (dump_sects
[i
] & STRING_DUMP
)
11547 dump_section_as_strings (section
, file
);
11549 if (dump_sects
[i
] & DEBUG_DUMP
)
11550 display_debug_section (i
, section
, file
);
11553 /* Check to see if the user requested a
11554 dump of a section that does not exist. */
11555 while (i
++ < num_dump_sects
)
11557 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11561 process_mips_fpe_exception (int mask
)
11566 if (mask
& OEX_FPU_INEX
)
11567 fputs ("INEX", stdout
), first
= 0;
11568 if (mask
& OEX_FPU_UFLO
)
11569 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11570 if (mask
& OEX_FPU_OFLO
)
11571 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11572 if (mask
& OEX_FPU_DIV0
)
11573 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11574 if (mask
& OEX_FPU_INVAL
)
11575 printf ("%sINVAL", first
? "" : "|");
11578 fputs ("0", stdout
);
11581 /* Display's the value of TAG at location P. If TAG is
11582 greater than 0 it is assumed to be an unknown tag, and
11583 a message is printed to this effect. Otherwise it is
11584 assumed that a message has already been printed.
11586 If the bottom bit of TAG is set it assumed to have a
11587 string value, otherwise it is assumed to have an integer
11590 Returns an updated P pointing to the first unread byte
11591 beyond the end of TAG's value.
11593 Reads at or beyond END will not be made. */
11595 static unsigned char *
11596 display_tag_value (int tag
,
11598 const unsigned char * const end
)
11603 printf (" Tag_unknown_%d: ", tag
);
11607 warn (_("corrupt tag\n"));
11611 /* FIXME: we could read beyond END here. */
11612 printf ("\"%s\"\n", p
);
11613 p
+= strlen ((char *) p
) + 1;
11619 val
= read_uleb128 (p
, &len
, end
);
11621 printf ("%ld (0x%lx)\n", val
, val
);
11627 /* ARM EABI attributes section. */
11632 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11634 const char ** table
;
11635 } arm_attr_public_tag
;
11637 static const char * arm_attr_tag_CPU_arch
[] =
11638 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11639 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11640 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11641 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11642 {"No", "Thumb-1", "Thumb-2"};
11643 static const char * arm_attr_tag_FP_arch
[] =
11644 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11646 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11647 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11648 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11649 static const char * arm_attr_tag_PCS_config
[] =
11650 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11651 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11652 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11653 {"V6", "SB", "TLS", "Unused"};
11654 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11655 {"Absolute", "PC-relative", "SB-relative", "None"};
11656 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11657 {"Absolute", "PC-relative", "None"};
11658 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11659 {"None", "direct", "GOT-indirect"};
11660 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11661 {"None", "??? 1", "2", "??? 3", "4"};
11662 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11663 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11664 {"Unused", "Needed", "Sign only"};
11665 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11666 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11667 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11668 {"Unused", "Finite", "RTABI", "IEEE 754"};
11669 static const char * arm_attr_tag_ABI_enum_size
[] =
11670 {"Unused", "small", "int", "forced to int"};
11671 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11672 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11673 static const char * arm_attr_tag_ABI_VFP_args
[] =
11674 {"AAPCS", "VFP registers", "custom"};
11675 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11676 {"AAPCS", "WMMX registers", "custom"};
11677 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11678 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11679 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11680 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11681 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11682 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11683 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11684 static const char * arm_attr_tag_FP_HP_extension
[] =
11685 {"Not Allowed", "Allowed"};
11686 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11687 {"None", "IEEE 754", "Alternative Format"};
11688 static const char * arm_attr_tag_MPextension_use
[] =
11689 {"Not Allowed", "Allowed"};
11690 static const char * arm_attr_tag_DIV_use
[] =
11691 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11692 "Allowed in v7-A with integer division extension"};
11693 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11694 static const char * arm_attr_tag_Virtualization_use
[] =
11695 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11696 "TrustZone and Virtualization Extensions"};
11697 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11698 {"Not Allowed", "Allowed"};
11700 #define LOOKUP(id, name) \
11701 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11702 static arm_attr_public_tag arm_attr_public_tags
[] =
11704 {4, "CPU_raw_name", 1, NULL
},
11705 {5, "CPU_name", 1, NULL
},
11706 LOOKUP(6, CPU_arch
),
11707 {7, "CPU_arch_profile", 0, NULL
},
11708 LOOKUP(8, ARM_ISA_use
),
11709 LOOKUP(9, THUMB_ISA_use
),
11710 LOOKUP(10, FP_arch
),
11711 LOOKUP(11, WMMX_arch
),
11712 LOOKUP(12, Advanced_SIMD_arch
),
11713 LOOKUP(13, PCS_config
),
11714 LOOKUP(14, ABI_PCS_R9_use
),
11715 LOOKUP(15, ABI_PCS_RW_data
),
11716 LOOKUP(16, ABI_PCS_RO_data
),
11717 LOOKUP(17, ABI_PCS_GOT_use
),
11718 LOOKUP(18, ABI_PCS_wchar_t
),
11719 LOOKUP(19, ABI_FP_rounding
),
11720 LOOKUP(20, ABI_FP_denormal
),
11721 LOOKUP(21, ABI_FP_exceptions
),
11722 LOOKUP(22, ABI_FP_user_exceptions
),
11723 LOOKUP(23, ABI_FP_number_model
),
11724 {24, "ABI_align_needed", 0, NULL
},
11725 {25, "ABI_align_preserved", 0, NULL
},
11726 LOOKUP(26, ABI_enum_size
),
11727 LOOKUP(27, ABI_HardFP_use
),
11728 LOOKUP(28, ABI_VFP_args
),
11729 LOOKUP(29, ABI_WMMX_args
),
11730 LOOKUP(30, ABI_optimization_goals
),
11731 LOOKUP(31, ABI_FP_optimization_goals
),
11732 {32, "compatibility", 0, NULL
},
11733 LOOKUP(34, CPU_unaligned_access
),
11734 LOOKUP(36, FP_HP_extension
),
11735 LOOKUP(38, ABI_FP_16bit_format
),
11736 LOOKUP(42, MPextension_use
),
11737 LOOKUP(44, DIV_use
),
11738 {64, "nodefaults", 0, NULL
},
11739 {65, "also_compatible_with", 0, NULL
},
11740 LOOKUP(66, T2EE_use
),
11741 {67, "conformance", 1, NULL
},
11742 LOOKUP(68, Virtualization_use
),
11743 LOOKUP(70, MPextension_use_legacy
)
11747 static unsigned char *
11748 display_arm_attribute (unsigned char * p
,
11749 const unsigned char * const end
)
11754 arm_attr_public_tag
* attr
;
11758 tag
= read_uleb128 (p
, &len
, end
);
11761 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11763 if (arm_attr_public_tags
[i
].tag
== tag
)
11765 attr
= &arm_attr_public_tags
[i
];
11772 printf (" Tag_%s: ", attr
->name
);
11773 switch (attr
->type
)
11778 case 7: /* Tag_CPU_arch_profile. */
11779 val
= read_uleb128 (p
, &len
, end
);
11783 case 0: printf (_("None\n")); break;
11784 case 'A': printf (_("Application\n")); break;
11785 case 'R': printf (_("Realtime\n")); break;
11786 case 'M': printf (_("Microcontroller\n")); break;
11787 case 'S': printf (_("Application or Realtime\n")); break;
11788 default: printf ("??? (%d)\n", val
); break;
11792 case 24: /* Tag_align_needed. */
11793 val
= read_uleb128 (p
, &len
, end
);
11797 case 0: printf (_("None\n")); break;
11798 case 1: printf (_("8-byte\n")); break;
11799 case 2: printf (_("4-byte\n")); break;
11800 case 3: printf ("??? 3\n"); break;
11803 printf (_("8-byte and up to %d-byte extended\n"),
11806 printf ("??? (%d)\n", val
);
11811 case 25: /* Tag_align_preserved. */
11812 val
= read_uleb128 (p
, &len
, end
);
11816 case 0: printf (_("None\n")); break;
11817 case 1: printf (_("8-byte, except leaf SP\n")); break;
11818 case 2: printf (_("8-byte\n")); break;
11819 case 3: printf ("??? 3\n"); break;
11822 printf (_("8-byte and up to %d-byte extended\n"),
11825 printf ("??? (%d)\n", val
);
11830 case 32: /* Tag_compatibility. */
11831 val
= read_uleb128 (p
, &len
, end
);
11833 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11834 p
+= strlen ((char *) p
) + 1;
11837 case 64: /* Tag_nodefaults. */
11839 printf (_("True\n"));
11842 case 65: /* Tag_also_compatible_with. */
11843 val
= read_uleb128 (p
, &len
, end
);
11845 if (val
== 6 /* Tag_CPU_arch. */)
11847 val
= read_uleb128 (p
, &len
, end
);
11849 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11850 printf ("??? (%d)\n", val
);
11852 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11856 while (*(p
++) != '\0' /* NUL terminator. */);
11865 return display_tag_value (-1, p
, end
);
11867 return display_tag_value (0, p
, end
);
11870 assert (attr
->type
& 0x80);
11871 val
= read_uleb128 (p
, &len
, end
);
11873 type
= attr
->type
& 0x7f;
11875 printf ("??? (%d)\n", val
);
11877 printf ("%s\n", attr
->table
[val
]);
11882 return display_tag_value (tag
, p
, end
);
11885 static unsigned char *
11886 display_gnu_attribute (unsigned char * p
,
11887 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11888 const unsigned char * const end
)
11894 tag
= read_uleb128 (p
, &len
, end
);
11897 /* Tag_compatibility is the only generic GNU attribute defined at
11901 val
= read_uleb128 (p
, &len
, end
);
11905 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
11906 warn (_("corrupt vendor attribute\n"));
11910 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11911 p
+= strlen ((char *) p
) + 1;
11916 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11917 return display_proc_gnu_attribute (p
, tag
, end
);
11919 return display_tag_value (tag
, p
, end
);
11922 static unsigned char *
11923 display_power_gnu_attribute (unsigned char * p
,
11925 const unsigned char * const end
)
11930 if (tag
== Tag_GNU_Power_ABI_FP
)
11932 val
= read_uleb128 (p
, &len
, end
);
11934 printf (" Tag_GNU_Power_ABI_FP: ");
11939 printf (_("Hard or soft float\n"));
11942 printf (_("Hard float\n"));
11945 printf (_("Soft float\n"));
11948 printf (_("Single-precision hard float\n"));
11951 printf ("??? (%d)\n", val
);
11957 if (tag
== Tag_GNU_Power_ABI_Vector
)
11959 val
= read_uleb128 (p
, &len
, end
);
11961 printf (" Tag_GNU_Power_ABI_Vector: ");
11965 printf (_("Any\n"));
11968 printf (_("Generic\n"));
11971 printf ("AltiVec\n");
11977 printf ("??? (%d)\n", val
);
11983 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11987 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11991 val
= read_uleb128 (p
, &len
, end
);
11993 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11997 printf (_("Any\n"));
12000 printf ("r3/r4\n");
12003 printf (_("Memory\n"));
12006 printf ("??? (%d)\n", val
);
12012 return display_tag_value (tag
& 1, p
, end
);
12016 display_sparc_hwcaps (int mask
)
12021 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12022 fputs ("mul32", stdout
), first
= 0;
12023 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12024 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12025 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12026 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12027 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12028 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12029 if (mask
& ELF_SPARC_HWCAP_POPC
)
12030 printf ("%spopc", first
? "" : "|"), first
= 0;
12031 if (mask
& ELF_SPARC_HWCAP_VIS
)
12032 printf ("%svis", first
? "" : "|"), first
= 0;
12033 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12034 printf ("%svis2", first
? "" : "|"), first
= 0;
12035 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12036 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12037 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12038 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12039 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12040 printf ("%svis3", first
? "" : "|"), first
= 0;
12041 if (mask
& ELF_SPARC_HWCAP_HPC
)
12042 printf ("%shpc", first
? "" : "|"), first
= 0;
12043 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12044 printf ("%srandom", first
? "" : "|"), first
= 0;
12045 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12046 printf ("%strans", first
? "" : "|"), first
= 0;
12047 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12048 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12049 if (mask
& ELF_SPARC_HWCAP_IMA
)
12050 printf ("%sima", first
? "" : "|"), first
= 0;
12051 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12052 printf ("%scspare", first
? "" : "|"), first
= 0;
12055 fputc('0', stdout
);
12056 fputc('\n', stdout
);
12060 display_sparc_hwcaps2 (int mask
)
12065 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12066 fputs ("fjathplus", stdout
), first
= 0;
12067 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12068 printf ("%svis3b", first
? "" : "|"), first
= 0;
12069 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12070 printf ("%sadp", first
? "" : "|"), first
= 0;
12071 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12072 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12073 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12074 printf ("%smwait", first
? "" : "|"), first
= 0;
12075 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12076 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12077 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12078 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12079 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12080 printf ("%snsec", first
? "" : "|"), first
= 0;
12081 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12082 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12083 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12084 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12085 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12086 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12089 fputc('0', stdout
);
12090 fputc('\n', stdout
);
12093 static unsigned char *
12094 display_sparc_gnu_attribute (unsigned char * p
,
12096 const unsigned char * const end
)
12101 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12103 val
= read_uleb128 (p
, &len
, end
);
12105 printf (" Tag_GNU_Sparc_HWCAPS: ");
12106 display_sparc_hwcaps (val
);
12109 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12111 val
= read_uleb128 (p
, &len
, end
);
12113 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12114 display_sparc_hwcaps2 (val
);
12118 return display_tag_value (tag
, p
, end
);
12122 print_mips_fp_abi_value (int val
)
12126 case Val_GNU_MIPS_ABI_FP_ANY
:
12127 printf (_("Hard or soft float\n"));
12129 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12130 printf (_("Hard float (double precision)\n"));
12132 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12133 printf (_("Hard float (single precision)\n"));
12135 case Val_GNU_MIPS_ABI_FP_SOFT
:
12136 printf (_("Soft float\n"));
12138 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12139 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12141 case Val_GNU_MIPS_ABI_FP_XX
:
12142 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12144 case Val_GNU_MIPS_ABI_FP_64
:
12145 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12147 case Val_GNU_MIPS_ABI_FP_64A
:
12148 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12151 printf ("??? (%d)\n", val
);
12156 static unsigned char *
12157 display_mips_gnu_attribute (unsigned char * p
,
12159 const unsigned char * const end
)
12161 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12166 val
= read_uleb128 (p
, &len
, end
);
12168 printf (" Tag_GNU_MIPS_ABI_FP: ");
12170 print_mips_fp_abi_value (val
);
12175 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12180 val
= read_uleb128 (p
, &len
, end
);
12182 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12186 case Val_GNU_MIPS_ABI_MSA_ANY
:
12187 printf (_("Any MSA or not\n"));
12189 case Val_GNU_MIPS_ABI_MSA_128
:
12190 printf (_("128-bit MSA\n"));
12193 printf ("??? (%d)\n", val
);
12199 return display_tag_value (tag
& 1, p
, end
);
12202 static unsigned char *
12203 display_tic6x_attribute (unsigned char * p
,
12204 const unsigned char * const end
)
12210 tag
= read_uleb128 (p
, &len
, end
);
12216 val
= read_uleb128 (p
, &len
, end
);
12218 printf (" Tag_ISA: ");
12222 case C6XABI_Tag_ISA_none
:
12223 printf (_("None\n"));
12225 case C6XABI_Tag_ISA_C62X
:
12228 case C6XABI_Tag_ISA_C67X
:
12231 case C6XABI_Tag_ISA_C67XP
:
12232 printf ("C67x+\n");
12234 case C6XABI_Tag_ISA_C64X
:
12237 case C6XABI_Tag_ISA_C64XP
:
12238 printf ("C64x+\n");
12240 case C6XABI_Tag_ISA_C674X
:
12241 printf ("C674x\n");
12244 printf ("??? (%d)\n", val
);
12249 case Tag_ABI_wchar_t
:
12250 val
= read_uleb128 (p
, &len
, end
);
12252 printf (" Tag_ABI_wchar_t: ");
12256 printf (_("Not used\n"));
12259 printf (_("2 bytes\n"));
12262 printf (_("4 bytes\n"));
12265 printf ("??? (%d)\n", val
);
12270 case Tag_ABI_stack_align_needed
:
12271 val
= read_uleb128 (p
, &len
, end
);
12273 printf (" Tag_ABI_stack_align_needed: ");
12277 printf (_("8-byte\n"));
12280 printf (_("16-byte\n"));
12283 printf ("??? (%d)\n", val
);
12288 case Tag_ABI_stack_align_preserved
:
12289 val
= read_uleb128 (p
, &len
, end
);
12291 printf (" Tag_ABI_stack_align_preserved: ");
12295 printf (_("8-byte\n"));
12298 printf (_("16-byte\n"));
12301 printf ("??? (%d)\n", val
);
12307 val
= read_uleb128 (p
, &len
, end
);
12309 printf (" Tag_ABI_DSBT: ");
12313 printf (_("DSBT addressing not used\n"));
12316 printf (_("DSBT addressing used\n"));
12319 printf ("??? (%d)\n", val
);
12325 val
= read_uleb128 (p
, &len
, end
);
12327 printf (" Tag_ABI_PID: ");
12331 printf (_("Data addressing position-dependent\n"));
12334 printf (_("Data addressing position-independent, GOT near DP\n"));
12337 printf (_("Data addressing position-independent, GOT far from DP\n"));
12340 printf ("??? (%d)\n", val
);
12346 val
= read_uleb128 (p
, &len
, end
);
12348 printf (" Tag_ABI_PIC: ");
12352 printf (_("Code addressing position-dependent\n"));
12355 printf (_("Code addressing position-independent\n"));
12358 printf ("??? (%d)\n", val
);
12363 case Tag_ABI_array_object_alignment
:
12364 val
= read_uleb128 (p
, &len
, end
);
12366 printf (" Tag_ABI_array_object_alignment: ");
12370 printf (_("8-byte\n"));
12373 printf (_("4-byte\n"));
12376 printf (_("16-byte\n"));
12379 printf ("??? (%d)\n", val
);
12384 case Tag_ABI_array_object_align_expected
:
12385 val
= read_uleb128 (p
, &len
, end
);
12387 printf (" Tag_ABI_array_object_align_expected: ");
12391 printf (_("8-byte\n"));
12394 printf (_("4-byte\n"));
12397 printf (_("16-byte\n"));
12400 printf ("??? (%d)\n", val
);
12405 case Tag_ABI_compatibility
:
12406 val
= read_uleb128 (p
, &len
, end
);
12408 printf (" Tag_ABI_compatibility: ");
12409 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12410 p
+= strlen ((char *) p
) + 1;
12413 case Tag_ABI_conformance
:
12414 printf (" Tag_ABI_conformance: ");
12415 printf ("\"%s\"\n", p
);
12416 p
+= strlen ((char *) p
) + 1;
12420 return display_tag_value (tag
, p
, end
);
12424 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12426 unsigned long addr
= 0;
12427 size_t bytes
= end
- p
;
12433 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12435 printf (" 0x%8.8lx ", addr
);
12437 for (j
= 0; j
< 16; j
++)
12440 printf ("%2.2x", p
[j
]);
12448 for (j
= 0; j
< lbytes
; j
++)
12451 if (k
>= ' ' && k
< 0x7f)
12467 static unsigned char *
12468 display_msp430x_attribute (unsigned char * p
,
12469 const unsigned char * const end
)
12475 tag
= read_uleb128 (p
, & len
, end
);
12480 case OFBA_MSPABI_Tag_ISA
:
12481 val
= read_uleb128 (p
, &len
, end
);
12483 printf (" Tag_ISA: ");
12486 case 0: printf (_("None\n")); break;
12487 case 1: printf (_("MSP430\n")); break;
12488 case 2: printf (_("MSP430X\n")); break;
12489 default: printf ("??? (%d)\n", val
); break;
12493 case OFBA_MSPABI_Tag_Code_Model
:
12494 val
= read_uleb128 (p
, &len
, end
);
12496 printf (" Tag_Code_Model: ");
12499 case 0: printf (_("None\n")); break;
12500 case 1: printf (_("Small\n")); break;
12501 case 2: printf (_("Large\n")); break;
12502 default: printf ("??? (%d)\n", val
); break;
12506 case OFBA_MSPABI_Tag_Data_Model
:
12507 val
= read_uleb128 (p
, &len
, end
);
12509 printf (" Tag_Data_Model: ");
12512 case 0: printf (_("None\n")); break;
12513 case 1: printf (_("Small\n")); break;
12514 case 2: printf (_("Large\n")); break;
12515 case 3: printf (_("Restricted Large\n")); break;
12516 default: printf ("??? (%d)\n", val
); break;
12521 printf (_(" <unknown tag %d>: "), tag
);
12525 printf ("\"%s\"\n", p
);
12526 p
+= strlen ((char *) p
) + 1;
12530 val
= read_uleb128 (p
, &len
, end
);
12532 printf ("%d (0x%x)\n", val
, val
);
12541 process_attributes (FILE * file
,
12542 const char * public_name
,
12543 unsigned int proc_type
,
12544 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12545 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12547 Elf_Internal_Shdr
* sect
;
12548 unsigned char * contents
;
12550 unsigned char * end
;
12551 bfd_vma section_len
;
12555 /* Find the section header so that we get the size. */
12556 for (i
= 0, sect
= section_headers
;
12557 i
< elf_header
.e_shnum
;
12560 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12563 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12564 sect
->sh_size
, _("attributes"));
12565 if (contents
== NULL
)
12571 len
= sect
->sh_size
- 1;
12576 unsigned int namelen
;
12577 bfd_boolean public_section
;
12578 bfd_boolean gnu_section
;
12580 section_len
= byte_get (p
, 4);
12583 if (section_len
> len
)
12585 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12586 (unsigned) section_len
, (unsigned) len
);
12590 len
-= section_len
;
12593 namelen
= strnlen ((char *) p
, section_len
) + 1;
12594 if (namelen
== 0 || namelen
>= section_len
)
12596 error (_("Corrupt attribute section name\n"));
12600 printf (_("Attribute Section: %s\n"), p
);
12602 if (public_name
&& streq ((char *) p
, public_name
))
12603 public_section
= TRUE
;
12605 public_section
= FALSE
;
12607 if (streq ((char *) p
, "gnu"))
12608 gnu_section
= TRUE
;
12610 gnu_section
= FALSE
;
12613 section_len
-= namelen
;
12614 while (section_len
> 0)
12620 size
= byte_get (p
, 4);
12621 if (size
> section_len
)
12623 error (_("Bad subsection length (%u > %u)\n"),
12624 (unsigned) size
, (unsigned) section_len
);
12625 size
= section_len
;
12628 section_len
-= size
;
12629 end
= p
+ size
- 1;
12635 printf (_("File Attributes\n"));
12638 printf (_("Section Attributes:"));
12641 printf (_("Symbol Attributes:"));
12647 val
= read_uleb128 (p
, &j
, end
);
12651 printf (" %d", val
);
12656 printf (_("Unknown tag: %d\n"), tag
);
12657 public_section
= FALSE
;
12661 if (public_section
)
12664 p
= display_pub_attribute (p
, end
);
12666 else if (gnu_section
)
12669 p
= display_gnu_attribute (p
,
12670 display_proc_gnu_attribute
,
12675 printf (_(" Unknown section contexts\n"));
12676 display_raw_attribute (p
, end
);
12683 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12691 process_arm_specific (FILE * file
)
12693 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12694 display_arm_attribute
, NULL
);
12698 process_power_specific (FILE * file
)
12700 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12701 display_power_gnu_attribute
);
12705 process_sparc_specific (FILE * file
)
12707 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12708 display_sparc_gnu_attribute
);
12712 process_tic6x_specific (FILE * file
)
12714 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12715 display_tic6x_attribute
, NULL
);
12719 process_msp430x_specific (FILE * file
)
12721 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12722 display_msp430x_attribute
, NULL
);
12725 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12726 Print the Address, Access and Initial fields of an entry at VMA ADDR
12727 and return the VMA of the next entry. */
12730 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12733 print_vma (addr
, LONG_HEX
);
12735 if (addr
< pltgot
+ 0xfff0)
12736 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12738 printf ("%10s", "");
12741 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12746 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12747 print_vma (entry
, LONG_HEX
);
12749 return addr
+ (is_32bit_elf
? 4 : 8);
12752 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12753 PLTGOT. Print the Address and Initial fields of an entry at VMA
12754 ADDR and return the VMA of the next entry. */
12757 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12760 print_vma (addr
, LONG_HEX
);
12763 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12768 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12769 print_vma (entry
, LONG_HEX
);
12771 return addr
+ (is_32bit_elf
? 4 : 8);
12775 print_mips_ases (unsigned int mask
)
12777 if (mask
& AFL_ASE_DSP
)
12778 fputs ("\n\tDSP ASE", stdout
);
12779 if (mask
& AFL_ASE_DSPR2
)
12780 fputs ("\n\tDSP R2 ASE", stdout
);
12781 if (mask
& AFL_ASE_EVA
)
12782 fputs ("\n\tEnhanced VA Scheme", stdout
);
12783 if (mask
& AFL_ASE_MCU
)
12784 fputs ("\n\tMCU (MicroController) ASE", stdout
);
12785 if (mask
& AFL_ASE_MDMX
)
12786 fputs ("\n\tMDMX ASE", stdout
);
12787 if (mask
& AFL_ASE_MIPS3D
)
12788 fputs ("\n\tMIPS-3D ASE", stdout
);
12789 if (mask
& AFL_ASE_MT
)
12790 fputs ("\n\tMT ASE", stdout
);
12791 if (mask
& AFL_ASE_SMARTMIPS
)
12792 fputs ("\n\tSmartMIPS ASE", stdout
);
12793 if (mask
& AFL_ASE_VIRT
)
12794 fputs ("\n\tVZ ASE", stdout
);
12795 if (mask
& AFL_ASE_MSA
)
12796 fputs ("\n\tMSA ASE", stdout
);
12797 if (mask
& AFL_ASE_MIPS16
)
12798 fputs ("\n\tMIPS16 ASE", stdout
);
12799 if (mask
& AFL_ASE_MICROMIPS
)
12800 fputs ("\n\tMICROMIPS ASE", stdout
);
12801 if (mask
& AFL_ASE_XPA
)
12802 fputs ("\n\tXPA ASE", stdout
);
12804 fprintf (stdout
, "\n\t%s", _("None"));
12805 else if ((mask
& ~AFL_ASE_MASK
) != 0)
12806 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
12810 print_mips_isa_ext (unsigned int isa_ext
)
12815 fputs (_("None"), stdout
);
12818 fputs ("RMI XLR", stdout
);
12820 case AFL_EXT_OCTEON3
:
12821 fputs ("Cavium Networks Octeon3", stdout
);
12823 case AFL_EXT_OCTEON2
:
12824 fputs ("Cavium Networks Octeon2", stdout
);
12826 case AFL_EXT_OCTEONP
:
12827 fputs ("Cavium Networks OcteonP", stdout
);
12829 case AFL_EXT_LOONGSON_3A
:
12830 fputs ("Loongson 3A", stdout
);
12832 case AFL_EXT_OCTEON
:
12833 fputs ("Cavium Networks Octeon", stdout
);
12836 fputs ("Toshiba R5900", stdout
);
12839 fputs ("MIPS R4650", stdout
);
12842 fputs ("LSI R4010", stdout
);
12845 fputs ("NEC VR4100", stdout
);
12848 fputs ("Toshiba R3900", stdout
);
12850 case AFL_EXT_10000
:
12851 fputs ("MIPS R10000", stdout
);
12854 fputs ("Broadcom SB-1", stdout
);
12857 fputs ("NEC VR4111/VR4181", stdout
);
12860 fputs ("NEC VR4120", stdout
);
12863 fputs ("NEC VR5400", stdout
);
12866 fputs ("NEC VR5500", stdout
);
12868 case AFL_EXT_LOONGSON_2E
:
12869 fputs ("ST Microelectronics Loongson 2E", stdout
);
12871 case AFL_EXT_LOONGSON_2F
:
12872 fputs ("ST Microelectronics Loongson 2F", stdout
);
12875 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
12880 get_mips_reg_size (int reg_size
)
12882 return (reg_size
== AFL_REG_NONE
) ? 0
12883 : (reg_size
== AFL_REG_32
) ? 32
12884 : (reg_size
== AFL_REG_64
) ? 64
12885 : (reg_size
== AFL_REG_128
) ? 128
12890 process_mips_specific (FILE * file
)
12892 Elf_Internal_Dyn
* entry
;
12893 Elf_Internal_Shdr
*sect
= NULL
;
12894 size_t liblist_offset
= 0;
12895 size_t liblistno
= 0;
12896 size_t conflictsno
= 0;
12897 size_t options_offset
= 0;
12898 size_t conflicts_offset
= 0;
12899 size_t pltrelsz
= 0;
12901 bfd_vma pltgot
= 0;
12902 bfd_vma mips_pltgot
= 0;
12903 bfd_vma jmprel
= 0;
12904 bfd_vma local_gotno
= 0;
12905 bfd_vma gotsym
= 0;
12906 bfd_vma symtabno
= 0;
12908 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12909 display_mips_gnu_attribute
);
12911 sect
= find_section (".MIPS.abiflags");
12915 Elf_External_ABIFlags_v0
*abiflags_ext
;
12916 Elf_Internal_ABIFlags_v0 abiflags_in
;
12918 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
12919 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
12922 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
12923 sect
->sh_size
, _("MIPS ABI Flags section"));
12926 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
12927 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
12928 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
12929 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
12930 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
12931 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
12932 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
12933 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
12934 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
12935 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
12936 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
12938 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
12939 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
12940 if (abiflags_in
.isa_rev
> 1)
12941 printf ("r%d", abiflags_in
.isa_rev
);
12942 printf ("\nGPR size: %d",
12943 get_mips_reg_size (abiflags_in
.gpr_size
));
12944 printf ("\nCPR1 size: %d",
12945 get_mips_reg_size (abiflags_in
.cpr1_size
));
12946 printf ("\nCPR2 size: %d",
12947 get_mips_reg_size (abiflags_in
.cpr2_size
));
12948 fputs ("\nFP ABI: ", stdout
);
12949 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
12950 fputs ("ISA Extension: ", stdout
);
12951 print_mips_isa_ext (abiflags_in
.isa_ext
);
12952 fputs ("\nASEs:", stdout
);
12953 print_mips_ases (abiflags_in
.ases
);
12954 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
12955 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
12956 fputc ('\n', stdout
);
12957 free (abiflags_ext
);
12962 /* We have a lot of special sections. Thanks SGI! */
12963 if (dynamic_section
== NULL
)
12964 /* No information available. */
12967 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12968 switch (entry
->d_tag
)
12970 case DT_MIPS_LIBLIST
:
12972 = offset_from_vma (file
, entry
->d_un
.d_val
,
12973 liblistno
* sizeof (Elf32_External_Lib
));
12975 case DT_MIPS_LIBLISTNO
:
12976 liblistno
= entry
->d_un
.d_val
;
12978 case DT_MIPS_OPTIONS
:
12979 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12981 case DT_MIPS_CONFLICT
:
12983 = offset_from_vma (file
, entry
->d_un
.d_val
,
12984 conflictsno
* sizeof (Elf32_External_Conflict
));
12986 case DT_MIPS_CONFLICTNO
:
12987 conflictsno
= entry
->d_un
.d_val
;
12990 pltgot
= entry
->d_un
.d_ptr
;
12992 case DT_MIPS_LOCAL_GOTNO
:
12993 local_gotno
= entry
->d_un
.d_val
;
12995 case DT_MIPS_GOTSYM
:
12996 gotsym
= entry
->d_un
.d_val
;
12998 case DT_MIPS_SYMTABNO
:
12999 symtabno
= entry
->d_un
.d_val
;
13001 case DT_MIPS_PLTGOT
:
13002 mips_pltgot
= entry
->d_un
.d_ptr
;
13005 pltrel
= entry
->d_un
.d_val
;
13008 pltrelsz
= entry
->d_un
.d_val
;
13011 jmprel
= entry
->d_un
.d_ptr
;
13017 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13019 Elf32_External_Lib
* elib
;
13022 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13024 sizeof (Elf32_External_Lib
),
13025 _("liblist section data"));
13028 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13029 (unsigned long) liblistno
);
13030 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13033 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13040 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13041 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13042 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13043 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13044 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13046 tmp
= gmtime (&atime
);
13047 snprintf (timebuf
, sizeof (timebuf
),
13048 "%04u-%02u-%02uT%02u:%02u:%02u",
13049 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13050 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13052 printf ("%3lu: ", (unsigned long) cnt
);
13053 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13054 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13056 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13057 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13058 liblist
.l_version
);
13060 if (liblist
.l_flags
== 0)
13064 static const struct
13071 { " EXACT_MATCH", LL_EXACT_MATCH
},
13072 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13073 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13074 { " EXPORTS", LL_EXPORTS
},
13075 { " DELAY_LOAD", LL_DELAY_LOAD
},
13076 { " DELTA", LL_DELTA
}
13078 int flags
= liblist
.l_flags
;
13081 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13082 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13084 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13085 flags
^= l_flags_vals
[fcnt
].bit
;
13088 printf (" %#x", (unsigned int) flags
);
13098 if (options_offset
!= 0)
13100 Elf_External_Options
* eopt
;
13101 Elf_Internal_Options
* iopt
;
13102 Elf_Internal_Options
* option
;
13105 sect
= section_headers
;
13107 /* Find the section header so that we get the size. */
13108 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
13111 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13112 sect
->sh_size
, _("options"));
13115 iopt
= (Elf_Internal_Options
*)
13116 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13119 error (_("Out of memory\n"));
13126 while (offset
< sect
->sh_size
)
13128 Elf_External_Options
* eoption
;
13130 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13132 option
->kind
= BYTE_GET (eoption
->kind
);
13133 option
->size
= BYTE_GET (eoption
->size
);
13134 option
->section
= BYTE_GET (eoption
->section
);
13135 option
->info
= BYTE_GET (eoption
->info
);
13137 offset
+= option
->size
;
13143 printf (_("\nSection '%s' contains %d entries:\n"),
13144 SECTION_NAME (sect
), cnt
);
13152 switch (option
->kind
)
13155 /* This shouldn't happen. */
13156 printf (" NULL %d %lx", option
->section
, option
->info
);
13159 printf (" REGINFO ");
13160 if (elf_header
.e_machine
== EM_MIPS
)
13163 Elf32_External_RegInfo
* ereg
;
13164 Elf32_RegInfo reginfo
;
13166 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13167 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13168 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13169 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13170 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13171 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13172 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13174 printf ("GPR %08lx GP 0x%lx\n",
13175 reginfo
.ri_gprmask
,
13176 (unsigned long) reginfo
.ri_gp_value
);
13177 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13178 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13179 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13184 Elf64_External_RegInfo
* ereg
;
13185 Elf64_Internal_RegInfo reginfo
;
13187 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13188 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13189 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13190 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13191 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13192 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13193 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13195 printf ("GPR %08lx GP 0x",
13196 reginfo
.ri_gprmask
);
13197 printf_vma (reginfo
.ri_gp_value
);
13200 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13201 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13202 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13206 case ODK_EXCEPTIONS
:
13207 fputs (" EXCEPTIONS fpe_min(", stdout
);
13208 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13209 fputs (") fpe_max(", stdout
);
13210 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13211 fputs (")", stdout
);
13213 if (option
->info
& OEX_PAGE0
)
13214 fputs (" PAGE0", stdout
);
13215 if (option
->info
& OEX_SMM
)
13216 fputs (" SMM", stdout
);
13217 if (option
->info
& OEX_FPDBUG
)
13218 fputs (" FPDBUG", stdout
);
13219 if (option
->info
& OEX_DISMISS
)
13220 fputs (" DISMISS", stdout
);
13223 fputs (" PAD ", stdout
);
13224 if (option
->info
& OPAD_PREFIX
)
13225 fputs (" PREFIX", stdout
);
13226 if (option
->info
& OPAD_POSTFIX
)
13227 fputs (" POSTFIX", stdout
);
13228 if (option
->info
& OPAD_SYMBOL
)
13229 fputs (" SYMBOL", stdout
);
13232 fputs (" HWPATCH ", stdout
);
13233 if (option
->info
& OHW_R4KEOP
)
13234 fputs (" R4KEOP", stdout
);
13235 if (option
->info
& OHW_R8KPFETCH
)
13236 fputs (" R8KPFETCH", stdout
);
13237 if (option
->info
& OHW_R5KEOP
)
13238 fputs (" R5KEOP", stdout
);
13239 if (option
->info
& OHW_R5KCVTL
)
13240 fputs (" R5KCVTL", stdout
);
13243 fputs (" FILL ", stdout
);
13244 /* XXX Print content of info word? */
13247 fputs (" TAGS ", stdout
);
13248 /* XXX Print content of info word? */
13251 fputs (" HWAND ", stdout
);
13252 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13253 fputs (" R4KEOP_CHECKED", stdout
);
13254 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13255 fputs (" R4KEOP_CLEAN", stdout
);
13258 fputs (" HWOR ", stdout
);
13259 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13260 fputs (" R4KEOP_CHECKED", stdout
);
13261 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13262 fputs (" R4KEOP_CLEAN", stdout
);
13265 printf (" GP_GROUP %#06lx self-contained %#06lx",
13266 option
->info
& OGP_GROUP
,
13267 (option
->info
& OGP_SELF
) >> 16);
13270 printf (" IDENT %#06lx self-contained %#06lx",
13271 option
->info
& OGP_GROUP
,
13272 (option
->info
& OGP_SELF
) >> 16);
13275 /* This shouldn't happen. */
13276 printf (" %3d ??? %d %lx",
13277 option
->kind
, option
->section
, option
->info
);
13281 len
= sizeof (* eopt
);
13282 while (len
< option
->size
)
13283 if (((char *) option
)[len
] >= ' '
13284 && ((char *) option
)[len
] < 0x7f)
13285 printf ("%c", ((char *) option
)[len
++]);
13287 printf ("\\%03o", ((char *) option
)[len
++]);
13289 fputs ("\n", stdout
);
13297 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13299 Elf32_Conflict
* iconf
;
13302 if (dynamic_symbols
== NULL
)
13304 error (_("conflict list found without a dynamic symbol table\n"));
13308 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13311 error (_("Out of memory\n"));
13317 Elf32_External_Conflict
* econf32
;
13319 econf32
= (Elf32_External_Conflict
*)
13320 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13321 sizeof (* econf32
), _("conflict"));
13325 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13326 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13332 Elf64_External_Conflict
* econf64
;
13334 econf64
= (Elf64_External_Conflict
*)
13335 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13336 sizeof (* econf64
), _("conflict"));
13340 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13341 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13346 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13347 (unsigned long) conflictsno
);
13348 puts (_(" Num: Index Value Name"));
13350 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13352 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
13354 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13355 print_vma (psym
->st_value
, FULL_HEX
);
13357 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13358 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13360 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13367 if (pltgot
!= 0 && local_gotno
!= 0)
13369 bfd_vma ent
, local_end
, global_end
;
13371 unsigned char * data
;
13375 addr_size
= (is_32bit_elf
? 4 : 8);
13376 local_end
= pltgot
+ local_gotno
* addr_size
;
13377 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13379 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13380 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13381 global_end
- pltgot
, 1,
13382 _("Global Offset Table data"));
13386 printf (_("\nPrimary GOT:\n"));
13387 printf (_(" Canonical gp value: "));
13388 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13391 printf (_(" Reserved entries:\n"));
13392 printf (_(" %*s %10s %*s Purpose\n"),
13393 addr_size
* 2, _("Address"), _("Access"),
13394 addr_size
* 2, _("Initial"));
13395 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13396 printf (_(" Lazy resolver\n"));
13398 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13399 >> (addr_size
* 8 - 1)) != 0)
13401 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13402 printf (_(" Module pointer (GNU extension)\n"));
13406 if (ent
< local_end
)
13408 printf (_(" Local entries:\n"));
13409 printf (" %*s %10s %*s\n",
13410 addr_size
* 2, _("Address"), _("Access"),
13411 addr_size
* 2, _("Initial"));
13412 while (ent
< local_end
)
13414 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13420 if (gotsym
< symtabno
)
13424 printf (_(" Global entries:\n"));
13425 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13426 addr_size
* 2, _("Address"),
13428 addr_size
* 2, _("Initial"),
13429 addr_size
* 2, _("Sym.Val."),
13431 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13432 _("Ndx"), _("Name"));
13434 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13435 for (i
= gotsym
; i
< symtabno
; i
++)
13437 Elf_Internal_Sym
* psym
;
13439 psym
= dynamic_symbols
+ i
;
13440 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13442 print_vma (psym
->st_value
, LONG_HEX
);
13443 printf (" %-7s %3s ",
13444 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13445 get_symbol_index_type (psym
->st_shndx
));
13446 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13447 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13449 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13459 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13462 size_t offset
, rel_offset
;
13463 unsigned long count
, i
;
13464 unsigned char * data
;
13465 int addr_size
, sym_width
;
13466 Elf_Internal_Rela
* rels
;
13468 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13469 if (pltrel
== DT_RELA
)
13471 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13476 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13481 addr_size
= (is_32bit_elf
? 4 : 8);
13482 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13484 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13485 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13486 1, _("Procedure Linkage Table data"));
13490 printf ("\nPLT GOT:\n\n");
13491 printf (_(" Reserved entries:\n"));
13492 printf (_(" %*s %*s Purpose\n"),
13493 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13494 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13495 printf (_(" PLT lazy resolver\n"));
13496 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13497 printf (_(" Module pointer\n"));
13500 printf (_(" Entries:\n"));
13501 printf (" %*s %*s %*s %-7s %3s %s\n",
13502 addr_size
* 2, _("Address"),
13503 addr_size
* 2, _("Initial"),
13504 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13505 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13506 for (i
= 0; i
< count
; i
++)
13508 Elf_Internal_Sym
* psym
;
13510 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
13511 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13513 print_vma (psym
->st_value
, LONG_HEX
);
13514 printf (" %-7s %3s ",
13515 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13516 get_symbol_index_type (psym
->st_shndx
));
13517 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13518 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13520 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13534 process_nds32_specific (FILE * file
)
13536 Elf_Internal_Shdr
*sect
= NULL
;
13538 sect
= find_section (".nds32_e_flags");
13541 unsigned int *flag
;
13543 printf ("\nNDS32 elf flags section:\n");
13544 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13545 sect
->sh_size
, _("NDS32 elf flags section"));
13547 switch ((*flag
) & 0x3)
13550 printf ("(VEC_SIZE):\tNo entry.\n");
13553 printf ("(VEC_SIZE):\t4 bytes\n");
13556 printf ("(VEC_SIZE):\t16 bytes\n");
13559 printf ("(VEC_SIZE):\treserved\n");
13568 process_gnu_liblist (FILE * file
)
13570 Elf_Internal_Shdr
* section
;
13571 Elf_Internal_Shdr
* string_sec
;
13572 Elf32_External_Lib
* elib
;
13574 size_t strtab_size
;
13581 for (i
= 0, section
= section_headers
;
13582 i
< elf_header
.e_shnum
;
13585 switch (section
->sh_type
)
13587 case SHT_GNU_LIBLIST
:
13588 if (section
->sh_link
>= elf_header
.e_shnum
)
13591 elib
= (Elf32_External_Lib
*)
13592 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13593 _("liblist section data"));
13597 string_sec
= section_headers
+ section
->sh_link
;
13599 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13600 string_sec
->sh_size
,
13601 _("liblist string table"));
13603 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13609 strtab_size
= string_sec
->sh_size
;
13611 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13612 SECTION_NAME (section
),
13613 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13615 puts (_(" Library Time Stamp Checksum Version Flags"));
13617 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13625 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13626 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13627 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13628 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13629 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13631 tmp
= gmtime (&atime
);
13632 snprintf (timebuf
, sizeof (timebuf
),
13633 "%04u-%02u-%02uT%02u:%02u:%02u",
13634 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13635 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13637 printf ("%3lu: ", (unsigned long) cnt
);
13639 printf ("%-20s", liblist
.l_name
< strtab_size
13640 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13642 printf ("%-20.20s", liblist
.l_name
< strtab_size
13643 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13644 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13645 liblist
.l_version
, liblist
.l_flags
);
13656 static const char *
13657 get_note_type (unsigned e_type
)
13659 static char buff
[64];
13661 if (elf_header
.e_type
== ET_CORE
)
13665 return _("NT_AUXV (auxiliary vector)");
13667 return _("NT_PRSTATUS (prstatus structure)");
13669 return _("NT_FPREGSET (floating point registers)");
13671 return _("NT_PRPSINFO (prpsinfo structure)");
13672 case NT_TASKSTRUCT
:
13673 return _("NT_TASKSTRUCT (task structure)");
13675 return _("NT_PRXFPREG (user_xfpregs structure)");
13677 return _("NT_PPC_VMX (ppc Altivec registers)");
13679 return _("NT_PPC_VSX (ppc VSX registers)");
13681 return _("NT_386_TLS (x86 TLS information)");
13682 case NT_386_IOPERM
:
13683 return _("NT_386_IOPERM (x86 I/O permissions)");
13684 case NT_X86_XSTATE
:
13685 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13686 case NT_S390_HIGH_GPRS
:
13687 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13688 case NT_S390_TIMER
:
13689 return _("NT_S390_TIMER (s390 timer register)");
13690 case NT_S390_TODCMP
:
13691 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13692 case NT_S390_TODPREG
:
13693 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13695 return _("NT_S390_CTRS (s390 control registers)");
13696 case NT_S390_PREFIX
:
13697 return _("NT_S390_PREFIX (s390 prefix register)");
13698 case NT_S390_LAST_BREAK
:
13699 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13700 case NT_S390_SYSTEM_CALL
:
13701 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13703 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13705 return _("NT_ARM_VFP (arm VFP registers)");
13707 return _("NT_ARM_TLS (AArch TLS registers)");
13708 case NT_ARM_HW_BREAK
:
13709 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13710 case NT_ARM_HW_WATCH
:
13711 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13713 return _("NT_PSTATUS (pstatus structure)");
13715 return _("NT_FPREGS (floating point registers)");
13717 return _("NT_PSINFO (psinfo structure)");
13719 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13721 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13722 case NT_WIN32PSTATUS
:
13723 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13725 return _("NT_SIGINFO (siginfo_t data)");
13727 return _("NT_FILE (mapped files)");
13735 return _("NT_VERSION (version)");
13737 return _("NT_ARCH (architecture)");
13742 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13747 print_core_note (Elf_Internal_Note
*pnote
)
13749 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13750 bfd_vma count
, page_size
;
13751 unsigned char *descdata
, *filenames
, *descend
;
13753 if (pnote
->type
!= NT_FILE
)
13759 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13760 /* Still "successful". */
13765 if (pnote
->descsz
< 2 * addr_size
)
13767 printf (_(" Malformed note - too short for header\n"));
13771 descdata
= (unsigned char *) pnote
->descdata
;
13772 descend
= descdata
+ pnote
->descsz
;
13774 if (descdata
[pnote
->descsz
- 1] != '\0')
13776 printf (_(" Malformed note - does not end with \\0\n"));
13780 count
= byte_get (descdata
, addr_size
);
13781 descdata
+= addr_size
;
13783 page_size
= byte_get (descdata
, addr_size
);
13784 descdata
+= addr_size
;
13786 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13788 printf (_(" Malformed note - too short for supplied file count\n"));
13792 printf (_(" Page size: "));
13793 print_vma (page_size
, DEC
);
13796 printf (_(" %*s%*s%*s\n"),
13797 (int) (2 + 2 * addr_size
), _("Start"),
13798 (int) (4 + 2 * addr_size
), _("End"),
13799 (int) (4 + 2 * addr_size
), _("Page Offset"));
13800 filenames
= descdata
+ count
* 3 * addr_size
;
13801 while (--count
> 0)
13803 bfd_vma start
, end
, file_ofs
;
13805 if (filenames
== descend
)
13807 printf (_(" Malformed note - filenames end too early\n"));
13811 start
= byte_get (descdata
, addr_size
);
13812 descdata
+= addr_size
;
13813 end
= byte_get (descdata
, addr_size
);
13814 descdata
+= addr_size
;
13815 file_ofs
= byte_get (descdata
, addr_size
);
13816 descdata
+= addr_size
;
13819 print_vma (start
, FULL_HEX
);
13821 print_vma (end
, FULL_HEX
);
13823 print_vma (file_ofs
, FULL_HEX
);
13824 printf ("\n %s\n", filenames
);
13826 filenames
+= 1 + strlen ((char *) filenames
);
13832 static const char *
13833 get_gnu_elf_note_type (unsigned e_type
)
13835 static char buff
[64];
13839 case NT_GNU_ABI_TAG
:
13840 return _("NT_GNU_ABI_TAG (ABI version tag)");
13842 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13843 case NT_GNU_BUILD_ID
:
13844 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13845 case NT_GNU_GOLD_VERSION
:
13846 return _("NT_GNU_GOLD_VERSION (gold version)");
13851 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13856 print_gnu_note (Elf_Internal_Note
*pnote
)
13858 switch (pnote
->type
)
13860 case NT_GNU_BUILD_ID
:
13864 printf (_(" Build ID: "));
13865 for (i
= 0; i
< pnote
->descsz
; ++i
)
13866 printf ("%02x", pnote
->descdata
[i
] & 0xff);
13871 case NT_GNU_ABI_TAG
:
13873 unsigned long os
, major
, minor
, subminor
;
13874 const char *osname
;
13876 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
13877 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
13878 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
13879 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13883 case GNU_ABI_TAG_LINUX
:
13886 case GNU_ABI_TAG_HURD
:
13889 case GNU_ABI_TAG_SOLARIS
:
13890 osname
= "Solaris";
13892 case GNU_ABI_TAG_FREEBSD
:
13893 osname
= "FreeBSD";
13895 case GNU_ABI_TAG_NETBSD
:
13899 osname
= "Unknown";
13903 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13904 major
, minor
, subminor
);
13908 case NT_GNU_GOLD_VERSION
:
13912 printf (_(" Version: "));
13913 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
13914 printf ("%c", pnote
->descdata
[i
]);
13923 static const char *
13924 get_netbsd_elfcore_note_type (unsigned e_type
)
13926 static char buff
[64];
13928 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13930 /* NetBSD core "procinfo" structure. */
13931 return _("NetBSD procinfo structure");
13934 /* As of Jan 2002 there are no other machine-independent notes
13935 defined for NetBSD core files. If the note type is less
13936 than the start of the machine-dependent note types, we don't
13939 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13941 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13945 switch (elf_header
.e_machine
)
13947 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13948 and PT_GETFPREGS == mach+2. */
13953 case EM_SPARC32PLUS
:
13957 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13958 return _("PT_GETREGS (reg structure)");
13959 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13960 return _("PT_GETFPREGS (fpreg structure)");
13966 /* On all other arch's, PT_GETREGS == mach+1 and
13967 PT_GETFPREGS == mach+3. */
13971 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13972 return _("PT_GETREGS (reg structure)");
13973 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13974 return _("PT_GETFPREGS (fpreg structure)");
13980 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13981 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13985 static const char *
13986 get_stapsdt_note_type (unsigned e_type
)
13988 static char buff
[64];
13993 return _("NT_STAPSDT (SystemTap probe descriptors)");
13999 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14004 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14006 int addr_size
= is_32bit_elf
? 4 : 8;
14007 char *data
= pnote
->descdata
;
14008 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14009 bfd_vma pc
, base_addr
, semaphore
;
14010 char *provider
, *probe
, *arg_fmt
;
14012 pc
= byte_get ((unsigned char *) data
, addr_size
);
14014 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14016 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14020 data
+= strlen (data
) + 1;
14022 data
+= strlen (data
) + 1;
14024 data
+= strlen (data
) + 1;
14026 printf (_(" Provider: %s\n"), provider
);
14027 printf (_(" Name: %s\n"), probe
);
14028 printf (_(" Location: "));
14029 print_vma (pc
, FULL_HEX
);
14030 printf (_(", Base: "));
14031 print_vma (base_addr
, FULL_HEX
);
14032 printf (_(", Semaphore: "));
14033 print_vma (semaphore
, FULL_HEX
);
14035 printf (_(" Arguments: %s\n"), arg_fmt
);
14037 return data
== data_end
;
14040 static const char *
14041 get_ia64_vms_note_type (unsigned e_type
)
14043 static char buff
[64];
14048 return _("NT_VMS_MHD (module header)");
14050 return _("NT_VMS_LNM (language name)");
14052 return _("NT_VMS_SRC (source files)");
14054 return "NT_VMS_TITLE";
14056 return _("NT_VMS_EIDC (consistency check)");
14057 case NT_VMS_FPMODE
:
14058 return _("NT_VMS_FPMODE (FP mode)");
14059 case NT_VMS_LINKTIME
:
14060 return "NT_VMS_LINKTIME";
14061 case NT_VMS_IMGNAM
:
14062 return _("NT_VMS_IMGNAM (image name)");
14064 return _("NT_VMS_IMGID (image id)");
14065 case NT_VMS_LINKID
:
14066 return _("NT_VMS_LINKID (link id)");
14067 case NT_VMS_IMGBID
:
14068 return _("NT_VMS_IMGBID (build id)");
14069 case NT_VMS_GSTNAM
:
14070 return _("NT_VMS_GSTNAM (sym table name)");
14071 case NT_VMS_ORIG_DYN
:
14072 return "NT_VMS_ORIG_DYN";
14073 case NT_VMS_PATCHTIME
:
14074 return "NT_VMS_PATCHTIME";
14076 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14082 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14084 switch (pnote
->type
)
14087 if (pnote
->descsz
> 36)
14089 size_t l
= strlen (pnote
->descdata
+ 34);
14090 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14091 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14092 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14093 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14096 printf (_(" Invalid size\n"));
14099 printf (_(" Language: %s\n"), pnote
->descdata
);
14102 case NT_VMS_FPMODE
:
14103 printf (_(" Floating Point mode: "));
14104 printf ("0x%016" BFD_VMA_FMT
"x\n",
14105 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14107 case NT_VMS_LINKTIME
:
14108 printf (_(" Link time: "));
14110 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14113 case NT_VMS_PATCHTIME
:
14114 printf (_(" Patch time: "));
14116 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14119 case NT_VMS_ORIG_DYN
:
14120 printf (_(" Major id: %u, minor id: %u\n"),
14121 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14122 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14123 printf (_(" Last modified : "));
14125 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14126 printf (_("\n Link flags : "));
14127 printf ("0x%016" BFD_VMA_FMT
"x\n",
14128 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14129 printf (_(" Header flags: 0x%08x\n"),
14130 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14131 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14134 case NT_VMS_IMGNAM
:
14135 printf (_(" Image name: %s\n"), pnote
->descdata
);
14137 case NT_VMS_GSTNAM
:
14138 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14141 printf (_(" Image id: %s\n"), pnote
->descdata
);
14143 case NT_VMS_LINKID
:
14144 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14152 /* Note that by the ELF standard, the name field is already null byte
14153 terminated, and namesz includes the terminating null byte.
14154 I.E. the value of namesz for the name "FSF" is 4.
14156 If the value of namesz is zero, there is no name present. */
14158 process_note (Elf_Internal_Note
* pnote
)
14160 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14163 if (pnote
->namesz
== 0)
14164 /* If there is no note name, then use the default set of
14165 note type strings. */
14166 nt
= get_note_type (pnote
->type
);
14168 else if (const_strneq (pnote
->namedata
, "GNU"))
14169 /* GNU-specific object file notes. */
14170 nt
= get_gnu_elf_note_type (pnote
->type
);
14172 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14173 /* NetBSD-specific core file notes. */
14174 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14176 else if (strneq (pnote
->namedata
, "SPU/", 4))
14178 /* SPU-specific core file notes. */
14179 nt
= pnote
->namedata
+ 4;
14183 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14184 /* VMS/ia64-specific file notes. */
14185 nt
= get_ia64_vms_note_type (pnote
->type
);
14187 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14188 nt
= get_stapsdt_note_type (pnote
->type
);
14191 /* Don't recognize this note name; just use the default set of
14192 note type strings. */
14193 nt
= get_note_type (pnote
->type
);
14195 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14197 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14198 return print_ia64_vms_note (pnote
);
14199 else if (const_strneq (pnote
->namedata
, "GNU"))
14200 return print_gnu_note (pnote
);
14201 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14202 return print_stapsdt_note (pnote
);
14203 else if (const_strneq (pnote
->namedata
, "CORE"))
14204 return print_core_note (pnote
);
14211 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14213 Elf_External_Note
* pnotes
;
14214 Elf_External_Note
* external
;
14220 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14222 if (pnotes
== NULL
)
14227 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14228 (unsigned long) offset
, (unsigned long) length
);
14229 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14231 while ((char *) external
< (char *) pnotes
+ length
)
14233 Elf_Internal_Note inote
;
14236 char * temp
= NULL
;
14237 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14239 if (!is_ia64_vms ())
14241 /* PR binutils/15191
14242 Make sure that there is enough data to read. */
14243 min_notesz
= offsetof (Elf_External_Note
, name
);
14244 if (data_remaining
< min_notesz
)
14246 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14247 (int) data_remaining
);
14250 inote
.type
= BYTE_GET (external
->type
);
14251 inote
.namesz
= BYTE_GET (external
->namesz
);
14252 inote
.namedata
= external
->name
;
14253 inote
.descsz
= BYTE_GET (external
->descsz
);
14254 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14255 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14256 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14260 Elf64_External_VMS_Note
*vms_external
;
14262 /* PR binutils/15191
14263 Make sure that there is enough data to read. */
14264 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14265 if (data_remaining
< min_notesz
)
14267 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14268 (int) data_remaining
);
14272 vms_external
= (Elf64_External_VMS_Note
*) external
;
14273 inote
.type
= BYTE_GET (vms_external
->type
);
14274 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14275 inote
.namedata
= vms_external
->name
;
14276 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14277 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14278 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14279 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14282 if (inote
.descdata
< (char *) external
+ min_notesz
14283 || next
< (char *) external
+ min_notesz
14284 || data_remaining
< (size_t)(next
- (char *) external
))
14286 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14287 (unsigned long) ((char *) external
- (char *) pnotes
));
14288 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14289 inote
.type
, inote
.namesz
, inote
.descsz
);
14293 external
= (Elf_External_Note
*) next
;
14295 /* Verify that name is null terminated. It appears that at least
14296 one version of Linux (RedHat 6.0) generates corefiles that don't
14297 comply with the ELF spec by failing to include the null byte in
14299 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14301 temp
= (char *) malloc (inote
.namesz
+ 1);
14305 error (_("Out of memory\n"));
14310 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14311 temp
[inote
.namesz
] = 0;
14313 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14314 inote
.namedata
= temp
;
14317 res
&= process_note (& inote
);
14332 process_corefile_note_segments (FILE * file
)
14334 Elf_Internal_Phdr
* segment
;
14338 if (! get_program_headers (file
))
14341 for (i
= 0, segment
= program_headers
;
14342 i
< elf_header
.e_phnum
;
14345 if (segment
->p_type
== PT_NOTE
)
14346 res
&= process_corefile_note_segment (file
,
14347 (bfd_vma
) segment
->p_offset
,
14348 (bfd_vma
) segment
->p_filesz
);
14355 process_note_sections (FILE * file
)
14357 Elf_Internal_Shdr
* section
;
14362 for (i
= 0, section
= section_headers
;
14363 i
< elf_header
.e_shnum
&& section
!= NULL
;
14365 if (section
->sh_type
== SHT_NOTE
)
14367 res
&= process_corefile_note_segment (file
,
14368 (bfd_vma
) section
->sh_offset
,
14369 (bfd_vma
) section
->sh_size
);
14374 /* Try processing NOTE segments instead. */
14375 return process_corefile_note_segments (file
);
14381 process_notes (FILE * file
)
14383 /* If we have not been asked to display the notes then do nothing. */
14387 if (elf_header
.e_type
!= ET_CORE
)
14388 return process_note_sections (file
);
14390 /* No program headers means no NOTE segment. */
14391 if (elf_header
.e_phnum
> 0)
14392 return process_corefile_note_segments (file
);
14394 printf (_("No note segments present in the core file.\n"));
14399 process_arch_specific (FILE * file
)
14404 switch (elf_header
.e_machine
)
14407 return process_arm_specific (file
);
14409 case EM_MIPS_RS3_LE
:
14410 return process_mips_specific (file
);
14413 return process_nds32_specific (file
);
14416 return process_power_specific (file
);
14419 case EM_SPARC32PLUS
:
14421 return process_sparc_specific (file
);
14424 return process_tic6x_specific (file
);
14427 return process_msp430x_specific (file
);
14435 get_file_header (FILE * file
)
14437 /* Read in the identity array. */
14438 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14441 /* Determine how to read the rest of the header. */
14442 switch (elf_header
.e_ident
[EI_DATA
])
14444 default: /* fall through */
14445 case ELFDATANONE
: /* fall through */
14447 byte_get
= byte_get_little_endian
;
14448 byte_put
= byte_put_little_endian
;
14451 byte_get
= byte_get_big_endian
;
14452 byte_put
= byte_put_big_endian
;
14456 /* For now we only support 32 bit and 64 bit ELF files. */
14457 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14459 /* Read in the rest of the header. */
14462 Elf32_External_Ehdr ehdr32
;
14464 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14467 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14468 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14469 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14470 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14471 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14472 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14473 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14474 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14475 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14476 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14477 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14478 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14479 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14483 Elf64_External_Ehdr ehdr64
;
14485 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14486 we will not be able to cope with the 64bit data found in
14487 64 ELF files. Detect this now and abort before we start
14488 overwriting things. */
14489 if (sizeof (bfd_vma
) < 8)
14491 error (_("This instance of readelf has been built without support for a\n\
14492 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14496 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14499 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14500 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14501 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14502 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14503 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14504 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14505 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14506 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14507 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14508 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14509 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14510 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14511 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14514 if (elf_header
.e_shoff
)
14516 /* There may be some extensions in the first section header. Don't
14517 bomb if we can't read it. */
14519 get_32bit_section_headers (file
, TRUE
);
14521 get_64bit_section_headers (file
, TRUE
);
14527 /* Process one ELF object file according to the command line options.
14528 This file may actually be stored in an archive. The file is
14529 positioned at the start of the ELF object. */
14532 process_object (char * file_name
, FILE * file
)
14536 if (! get_file_header (file
))
14538 error (_("%s: Failed to read file header\n"), file_name
);
14542 /* Initialise per file variables. */
14543 for (i
= ARRAY_SIZE (version_info
); i
--;)
14544 version_info
[i
] = 0;
14546 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14547 dynamic_info
[i
] = 0;
14548 dynamic_info_DT_GNU_HASH
= 0;
14550 /* Process the file. */
14552 printf (_("\nFile: %s\n"), file_name
);
14554 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14555 Note we do this even if cmdline_dump_sects is empty because we
14556 must make sure that the dump_sets array is zeroed out before each
14557 object file is processed. */
14558 if (num_dump_sects
> num_cmdline_dump_sects
)
14559 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14561 if (num_cmdline_dump_sects
> 0)
14563 if (num_dump_sects
== 0)
14564 /* A sneaky way of allocating the dump_sects array. */
14565 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14567 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14568 memcpy (dump_sects
, cmdline_dump_sects
,
14569 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14572 if (! process_file_header ())
14575 if (! process_section_headers (file
))
14577 /* Without loaded section headers we cannot process lots of
14579 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14581 if (! do_using_dynamic
)
14582 do_syms
= do_dyn_syms
= do_reloc
= 0;
14585 if (! process_section_groups (file
))
14587 /* Without loaded section groups we cannot process unwind. */
14591 if (process_program_headers (file
))
14592 process_dynamic_section (file
);
14594 process_relocs (file
);
14596 process_unwind (file
);
14598 process_symbol_table (file
);
14600 process_syminfo (file
);
14602 process_version_sections (file
);
14604 process_section_contents (file
);
14606 process_notes (file
);
14608 process_gnu_liblist (file
);
14610 process_arch_specific (file
);
14612 if (program_headers
)
14614 free (program_headers
);
14615 program_headers
= NULL
;
14618 if (section_headers
)
14620 free (section_headers
);
14621 section_headers
= NULL
;
14626 free (string_table
);
14627 string_table
= NULL
;
14628 string_table_length
= 0;
14631 if (dynamic_strings
)
14633 free (dynamic_strings
);
14634 dynamic_strings
= NULL
;
14635 dynamic_strings_length
= 0;
14638 if (dynamic_symbols
)
14640 free (dynamic_symbols
);
14641 dynamic_symbols
= NULL
;
14642 num_dynamic_syms
= 0;
14645 if (dynamic_syminfo
)
14647 free (dynamic_syminfo
);
14648 dynamic_syminfo
= NULL
;
14651 if (dynamic_section
)
14653 free (dynamic_section
);
14654 dynamic_section
= NULL
;
14657 if (section_headers_groups
)
14659 free (section_headers_groups
);
14660 section_headers_groups
= NULL
;
14663 if (section_groups
)
14665 struct group_list
* g
;
14666 struct group_list
* next
;
14668 for (i
= 0; i
< group_count
; i
++)
14670 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14677 free (section_groups
);
14678 section_groups
= NULL
;
14681 free_debug_memory ();
14686 /* Process an ELF archive.
14687 On entry the file is positioned just after the ARMAG string. */
14690 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14692 struct archive_info arch
;
14693 struct archive_info nested_arch
;
14699 /* The ARCH structure is used to hold information about this archive. */
14700 arch
.file_name
= NULL
;
14702 arch
.index_array
= NULL
;
14703 arch
.sym_table
= NULL
;
14704 arch
.longnames
= NULL
;
14706 /* The NESTED_ARCH structure is used as a single-item cache of information
14707 about a nested archive (when members of a thin archive reside within
14708 another regular archive file). */
14709 nested_arch
.file_name
= NULL
;
14710 nested_arch
.file
= NULL
;
14711 nested_arch
.index_array
= NULL
;
14712 nested_arch
.sym_table
= NULL
;
14713 nested_arch
.longnames
= NULL
;
14715 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14721 if (do_archive_index
)
14723 if (arch
.sym_table
== NULL
)
14724 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14728 unsigned long current_pos
;
14730 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14731 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14732 current_pos
= ftell (file
);
14734 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14736 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14738 char * member_name
;
14740 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14742 if (member_name
!= NULL
)
14744 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14746 if (qualified_name
!= NULL
)
14748 printf (_("Contents of binary %s at offset "), qualified_name
);
14749 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14751 free (qualified_name
);
14756 if (l
>= arch
.sym_size
)
14758 error (_("%s: end of the symbol table reached before the end of the index\n"),
14762 printf ("\t%s\n", arch
.sym_table
+ l
);
14763 l
+= strlen (arch
.sym_table
+ l
) + 1;
14766 if (arch
.uses_64bit_indicies
)
14771 if (l
< arch
.sym_size
)
14772 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14773 file_name
, arch
.sym_size
- l
);
14775 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14777 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14783 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14784 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14785 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14786 && !do_section_groups
&& !do_dyn_syms
)
14788 ret
= 0; /* Archive index only. */
14799 char * qualified_name
;
14801 /* Read the next archive header. */
14802 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14804 error (_("%s: failed to seek to next archive header\n"), file_name
);
14807 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14808 if (got
!= sizeof arch
.arhdr
)
14812 error (_("%s: failed to read archive header\n"), file_name
);
14816 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14818 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14823 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14825 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14826 if (archive_file_size
& 01)
14827 ++archive_file_size
;
14829 name
= get_archive_member_name (&arch
, &nested_arch
);
14832 error (_("%s: bad archive file name\n"), file_name
);
14836 namelen
= strlen (name
);
14838 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
14839 if (qualified_name
== NULL
)
14841 error (_("%s: bad archive file name\n"), file_name
);
14846 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
14848 /* This is a proxy for an external member of a thin archive. */
14849 FILE * member_file
;
14850 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
14851 if (member_file_name
== NULL
)
14857 member_file
= fopen (member_file_name
, "rb");
14858 if (member_file
== NULL
)
14860 error (_("Input file '%s' is not readable.\n"), member_file_name
);
14861 free (member_file_name
);
14866 archive_file_offset
= arch
.nested_member_origin
;
14868 ret
|= process_object (qualified_name
, member_file
);
14870 fclose (member_file
);
14871 free (member_file_name
);
14873 else if (is_thin_archive
)
14875 /* PR 15140: Allow for corrupt thin archives. */
14876 if (nested_arch
.file
== NULL
)
14878 error (_("%s: contains corrupt thin archive: %s\n"),
14884 /* This is a proxy for a member of a nested archive. */
14885 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
14887 /* The nested archive file will have been opened and setup by
14888 get_archive_member_name. */
14889 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
14891 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
14896 ret
|= process_object (qualified_name
, nested_arch
.file
);
14900 archive_file_offset
= arch
.next_arhdr_offset
;
14901 arch
.next_arhdr_offset
+= archive_file_size
;
14903 ret
|= process_object (qualified_name
, file
);
14906 if (dump_sects
!= NULL
)
14910 num_dump_sects
= 0;
14913 free (qualified_name
);
14917 if (nested_arch
.file
!= NULL
)
14918 fclose (nested_arch
.file
);
14919 release_archive (&nested_arch
);
14920 release_archive (&arch
);
14926 process_file (char * file_name
)
14929 struct stat statbuf
;
14930 char armag
[SARMAG
];
14933 if (stat (file_name
, &statbuf
) < 0)
14935 if (errno
== ENOENT
)
14936 error (_("'%s': No such file\n"), file_name
);
14938 error (_("Could not locate '%s'. System error message: %s\n"),
14939 file_name
, strerror (errno
));
14943 if (! S_ISREG (statbuf
.st_mode
))
14945 error (_("'%s' is not an ordinary file\n"), file_name
);
14949 file
= fopen (file_name
, "rb");
14952 error (_("Input file '%s' is not readable.\n"), file_name
);
14956 if (fread (armag
, SARMAG
, 1, file
) != 1)
14958 error (_("%s: Failed to read file's magic number\n"), file_name
);
14963 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
14965 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14966 ret
= process_archive (file_name
, file
, FALSE
);
14967 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14968 ret
= process_archive (file_name
, file
, TRUE
);
14971 if (do_archive_index
)
14972 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14976 archive_file_size
= archive_file_offset
= 0;
14977 ret
= process_object (file_name
, file
);
14982 current_file_size
= 0;
14986 #ifdef SUPPORT_DISASSEMBLY
14987 /* Needed by the i386 disassembler. For extra credit, someone could
14988 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14992 print_address (unsigned int addr
, FILE * outfile
)
14994 fprintf (outfile
,"0x%8.8x", addr
);
14997 /* Needed by the i386 disassembler. */
14999 db_task_printsym (unsigned int addr
)
15001 print_address (addr
, stderr
);
15006 main (int argc
, char ** argv
)
15010 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15011 setlocale (LC_MESSAGES
, "");
15013 #if defined (HAVE_SETLOCALE)
15014 setlocale (LC_CTYPE
, "");
15016 bindtextdomain (PACKAGE
, LOCALEDIR
);
15017 textdomain (PACKAGE
);
15019 expandargv (&argc
, &argv
);
15021 parse_args (argc
, argv
);
15023 if (num_dump_sects
> 0)
15025 /* Make a copy of the dump_sects array. */
15026 cmdline_dump_sects
= (dump_type
*)
15027 malloc (num_dump_sects
* sizeof (* dump_sects
));
15028 if (cmdline_dump_sects
== NULL
)
15029 error (_("Out of memory allocating dump request table.\n"));
15032 memcpy (cmdline_dump_sects
, dump_sects
,
15033 num_dump_sects
* sizeof (* dump_sects
));
15034 num_cmdline_dump_sects
= num_dump_sects
;
15038 if (optind
< (argc
- 1))
15042 while (optind
< argc
)
15043 err
|= process_file (argv
[optind
++]);
15045 if (dump_sects
!= NULL
)
15047 if (cmdline_dump_sects
!= NULL
)
15048 free (cmdline_dump_sects
);