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
;
428 /* Set the remaining width to a very large value.
429 This simplifies the code below. */
430 width_remaining
= INT_MAX
;
432 width_remaining
= width
;
434 #ifdef HAVE_MBSTATE_T
435 /* Initialise the multibyte conversion state. */
436 memset (& state
, 0, sizeof (state
));
439 while (width_remaining
)
442 const char c
= *symbol
++;
447 /* Do not print control characters directly as they can affect terminal
448 settings. Such characters usually appear in the names generated
449 by the assembler for local labels. */
452 if (width_remaining
< 2)
455 printf ("^%c", c
+ 0x40);
456 width_remaining
-= 2;
459 else if (ISPRINT (c
))
467 #ifdef HAVE_MBSTATE_T
470 /* Let printf do the hard work of displaying multibyte characters. */
471 printf ("%.1s", symbol
- 1);
475 #ifdef HAVE_MBSTATE_T
476 /* Try to find out how many bytes made up the character that was
477 just printed. Advance the symbol pointer past the bytes that
479 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
483 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
488 if (extra_padding
&& num_printed
< width
)
490 /* Fill in the remaining spaces. */
491 printf ("%-*s", width
- num_printed
, " ");
498 /* Returns a pointer to a static buffer containing a printable version of
499 the given section's name. Like print_symbol, except that it does not try
500 to print multibyte characters, it just interprets them as hex values. */
503 printable_section_name (Elf_Internal_Shdr
* sec
)
505 #define MAX_PRINT_SEC_NAME_LEN 128
506 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
507 const char * name
= SECTION_NAME (sec
);
508 char * buf
= sec_name_buf
;
510 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
512 while ((c
= * name
++) != 0)
523 else if (ISPRINT (c
))
530 static char hex
[17] = "0123456789ABCDEF";
535 * buf
++ = hex
[(c
& 0xf0) >> 4];
536 * buf
++ = hex
[c
& 0x0f];
550 printable_section_name_from_index (unsigned long ndx
)
552 if (ndx
>= elf_header
.e_shnum
)
553 return _("<corrupt>");
555 return printable_section_name (section_headers
+ ndx
);
558 /* Return a pointer to section NAME, or NULL if no such section exists. */
560 static Elf_Internal_Shdr
*
561 find_section (const char * name
)
565 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
566 if (streq (SECTION_NAME (section_headers
+ i
), name
))
567 return section_headers
+ i
;
572 /* Return a pointer to a section containing ADDR, or NULL if no such
575 static Elf_Internal_Shdr
*
576 find_section_by_address (bfd_vma addr
)
580 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
582 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
583 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
590 /* Return a pointer to section NAME, or NULL if no such section exists,
591 restricted to the list of sections given in SET. */
593 static Elf_Internal_Shdr
*
594 find_section_in_set (const char * name
, unsigned int * set
)
600 while ((i
= *set
++) > 0)
601 if (streq (SECTION_NAME (section_headers
+ i
), name
))
602 return section_headers
+ i
;
605 return find_section (name
);
608 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
611 static inline unsigned long
612 read_uleb128 (unsigned char *data
,
613 unsigned int *length_return
,
614 const unsigned char * const end
)
616 return read_leb128 (data
, length_return
, FALSE
, end
);
619 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
620 This OS has so many departures from the ELF standard that we test it at
626 return elf_header
.e_machine
== EM_IA_64
627 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
630 /* Guess the relocation size commonly used by the specific machines. */
633 guess_is_rela (unsigned int e_machine
)
637 /* Targets that use REL relocations. */
652 /* Targets that use RELA relocations. */
656 case EM_ADAPTEVA_EPIPHANY
:
658 case EM_ALTERA_NIOS2
:
677 case EM_LATTICEMICO32
:
686 case EM_CYGNUS_MN10200
:
688 case EM_CYGNUS_MN10300
:
721 case EM_MICROBLAZE_OLD
:
742 warn (_("Don't know about relocations on this machine architecture\n"));
748 slurp_rela_relocs (FILE * file
,
749 unsigned long rel_offset
,
750 unsigned long rel_size
,
751 Elf_Internal_Rela
** relasp
,
752 unsigned long * nrelasp
)
754 Elf_Internal_Rela
* relas
;
755 unsigned long nrelas
;
760 Elf32_External_Rela
* erelas
;
762 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
763 rel_size
, _("32-bit relocation data"));
767 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
769 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
770 sizeof (Elf_Internal_Rela
));
775 error (_("out of memory parsing relocs\n"));
779 for (i
= 0; i
< nrelas
; i
++)
781 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
782 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
783 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
790 Elf64_External_Rela
* erelas
;
792 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
793 rel_size
, _("64-bit relocation data"));
797 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
799 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
800 sizeof (Elf_Internal_Rela
));
805 error (_("out of memory parsing relocs\n"));
809 for (i
= 0; i
< nrelas
; i
++)
811 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
812 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
813 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
815 /* The #ifdef BFD64 below is to prevent a compile time
816 warning. We know that if we do not have a 64 bit data
817 type that we will never execute this code anyway. */
819 if (elf_header
.e_machine
== EM_MIPS
820 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
822 /* In little-endian objects, r_info isn't really a
823 64-bit little-endian value: it has a 32-bit
824 little-endian symbol index followed by four
825 individual byte fields. Reorder INFO
827 bfd_vma inf
= relas
[i
].r_info
;
828 inf
= (((inf
& 0xffffffff) << 32)
829 | ((inf
>> 56) & 0xff)
830 | ((inf
>> 40) & 0xff00)
831 | ((inf
>> 24) & 0xff0000)
832 | ((inf
>> 8) & 0xff000000));
833 relas
[i
].r_info
= inf
;
846 slurp_rel_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relsp
,
850 unsigned long * nrelsp
)
852 Elf_Internal_Rela
* rels
;
858 Elf32_External_Rel
* erels
;
860 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
867 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
872 error (_("out of memory parsing relocs\n"));
876 for (i
= 0; i
< nrels
; i
++)
878 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
879 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
880 rels
[i
].r_addend
= 0;
887 Elf64_External_Rel
* erels
;
889 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
890 rel_size
, _("64-bit relocation data"));
894 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
896 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
901 error (_("out of memory parsing relocs\n"));
905 for (i
= 0; i
< nrels
; i
++)
907 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
908 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
909 rels
[i
].r_addend
= 0;
911 /* The #ifdef BFD64 below is to prevent a compile time
912 warning. We know that if we do not have a 64 bit data
913 type that we will never execute this code anyway. */
915 if (elf_header
.e_machine
== EM_MIPS
916 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
918 /* In little-endian objects, r_info isn't really a
919 64-bit little-endian value: it has a 32-bit
920 little-endian symbol index followed by four
921 individual byte fields. Reorder INFO
923 bfd_vma inf
= rels
[i
].r_info
;
924 inf
= (((inf
& 0xffffffff) << 32)
925 | ((inf
>> 56) & 0xff)
926 | ((inf
>> 40) & 0xff00)
927 | ((inf
>> 24) & 0xff0000)
928 | ((inf
>> 8) & 0xff000000));
929 rels
[i
].r_info
= inf
;
941 /* Returns the reloc type extracted from the reloc info field. */
944 get_reloc_type (bfd_vma reloc_info
)
947 return ELF32_R_TYPE (reloc_info
);
949 switch (elf_header
.e_machine
)
952 /* Note: We assume that reloc_info has already been adjusted for us. */
953 return ELF64_MIPS_R_TYPE (reloc_info
);
956 return ELF64_R_TYPE_ID (reloc_info
);
959 return ELF64_R_TYPE (reloc_info
);
963 /* Return the symbol index extracted from the reloc info field. */
966 get_reloc_symindex (bfd_vma reloc_info
)
968 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
971 static inline bfd_boolean
972 uses_msp430x_relocs (void)
975 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
976 /* GCC uses osabi == ELFOSBI_STANDALONE. */
977 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
978 /* TI compiler uses ELFOSABI_NONE. */
979 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
982 /* Display the contents of the relocation data found at the specified
986 dump_relocations (FILE * file
,
987 unsigned long rel_offset
,
988 unsigned long rel_size
,
989 Elf_Internal_Sym
* symtab
,
992 unsigned long strtablen
,
996 Elf_Internal_Rela
* rels
;
998 if (is_rela
== UNKNOWN
)
999 is_rela
= guess_is_rela (elf_header
.e_machine
);
1003 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1008 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1017 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1019 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1024 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1026 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1034 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1036 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1041 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1043 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1047 for (i
= 0; i
< rel_size
; i
++)
1052 bfd_vma symtab_index
;
1055 offset
= rels
[i
].r_offset
;
1056 inf
= rels
[i
].r_info
;
1058 type
= get_reloc_type (inf
);
1059 symtab_index
= get_reloc_symindex (inf
);
1063 printf ("%8.8lx %8.8lx ",
1064 (unsigned long) offset
& 0xffffffff,
1065 (unsigned long) inf
& 0xffffffff);
1069 #if BFD_HOST_64BIT_LONG
1071 ? "%16.16lx %16.16lx "
1072 : "%12.12lx %12.12lx ",
1074 #elif BFD_HOST_64BIT_LONG_LONG
1077 ? "%16.16llx %16.16llx "
1078 : "%12.12llx %12.12llx ",
1082 ? "%16.16I64x %16.16I64x "
1083 : "%12.12I64x %12.12I64x ",
1088 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1089 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1090 _bfd_int64_high (offset
),
1091 _bfd_int64_low (offset
),
1092 _bfd_int64_high (inf
),
1093 _bfd_int64_low (inf
));
1097 switch (elf_header
.e_machine
)
1104 rtype
= elf_aarch64_reloc_type (type
);
1108 case EM_CYGNUS_M32R
:
1109 rtype
= elf_m32r_reloc_type (type
);
1114 rtype
= elf_i386_reloc_type (type
);
1119 rtype
= elf_m68hc11_reloc_type (type
);
1123 rtype
= elf_m68k_reloc_type (type
);
1127 rtype
= elf_i960_reloc_type (type
);
1132 rtype
= elf_avr_reloc_type (type
);
1135 case EM_OLD_SPARCV9
:
1136 case EM_SPARC32PLUS
:
1139 rtype
= elf_sparc_reloc_type (type
);
1143 rtype
= elf_spu_reloc_type (type
);
1147 rtype
= v800_reloc_type (type
);
1150 case EM_CYGNUS_V850
:
1151 rtype
= v850_reloc_type (type
);
1155 case EM_CYGNUS_D10V
:
1156 rtype
= elf_d10v_reloc_type (type
);
1160 case EM_CYGNUS_D30V
:
1161 rtype
= elf_d30v_reloc_type (type
);
1165 rtype
= elf_dlx_reloc_type (type
);
1169 rtype
= elf_sh_reloc_type (type
);
1173 case EM_CYGNUS_MN10300
:
1174 rtype
= elf_mn10300_reloc_type (type
);
1178 case EM_CYGNUS_MN10200
:
1179 rtype
= elf_mn10200_reloc_type (type
);
1183 case EM_CYGNUS_FR30
:
1184 rtype
= elf_fr30_reloc_type (type
);
1188 rtype
= elf_frv_reloc_type (type
);
1192 rtype
= elf_mcore_reloc_type (type
);
1196 rtype
= elf_mmix_reloc_type (type
);
1200 rtype
= elf_moxie_reloc_type (type
);
1204 if (uses_msp430x_relocs ())
1206 rtype
= elf_msp430x_reloc_type (type
);
1210 rtype
= elf_msp430_reloc_type (type
);
1214 rtype
= elf_nds32_reloc_type (type
);
1218 rtype
= elf_ppc_reloc_type (type
);
1222 rtype
= elf_ppc64_reloc_type (type
);
1226 case EM_MIPS_RS3_LE
:
1227 rtype
= elf_mips_reloc_type (type
);
1231 rtype
= elf_alpha_reloc_type (type
);
1235 rtype
= elf_arm_reloc_type (type
);
1239 rtype
= elf_arc_reloc_type (type
);
1243 rtype
= elf_hppa_reloc_type (type
);
1249 rtype
= elf_h8_reloc_type (type
);
1253 rtype
= elf_or1k_reloc_type (type
);
1258 rtype
= elf_pj_reloc_type (type
);
1261 rtype
= elf_ia64_reloc_type (type
);
1265 rtype
= elf_cris_reloc_type (type
);
1269 rtype
= elf_i860_reloc_type (type
);
1275 rtype
= elf_x86_64_reloc_type (type
);
1279 rtype
= i370_reloc_type (type
);
1284 rtype
= elf_s390_reloc_type (type
);
1288 rtype
= elf_score_reloc_type (type
);
1292 rtype
= elf_xstormy16_reloc_type (type
);
1296 rtype
= elf_crx_reloc_type (type
);
1300 rtype
= elf_vax_reloc_type (type
);
1303 case EM_ADAPTEVA_EPIPHANY
:
1304 rtype
= elf_epiphany_reloc_type (type
);
1309 rtype
= elf_ip2k_reloc_type (type
);
1313 rtype
= elf_iq2000_reloc_type (type
);
1318 rtype
= elf_xtensa_reloc_type (type
);
1321 case EM_LATTICEMICO32
:
1322 rtype
= elf_lm32_reloc_type (type
);
1327 rtype
= elf_m32c_reloc_type (type
);
1331 rtype
= elf_mt_reloc_type (type
);
1335 rtype
= elf_bfin_reloc_type (type
);
1339 rtype
= elf_mep_reloc_type (type
);
1343 rtype
= elf_cr16_reloc_type (type
);
1347 case EM_MICROBLAZE_OLD
:
1348 rtype
= elf_microblaze_reloc_type (type
);
1352 rtype
= elf_rl78_reloc_type (type
);
1356 rtype
= elf_rx_reloc_type (type
);
1360 rtype
= elf_metag_reloc_type (type
);
1365 rtype
= elf_xc16x_reloc_type (type
);
1369 rtype
= elf_tic6x_reloc_type (type
);
1373 rtype
= elf_tilegx_reloc_type (type
);
1377 rtype
= elf_tilepro_reloc_type (type
);
1381 rtype
= elf_xgate_reloc_type (type
);
1384 case EM_ALTERA_NIOS2
:
1385 rtype
= elf_nios2_reloc_type (type
);
1390 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1392 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1394 if (elf_header
.e_machine
== EM_ALPHA
1396 && streq (rtype
, "R_ALPHA_LITUSE")
1399 switch (rels
[i
].r_addend
)
1401 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1402 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1403 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1404 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1405 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1406 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1407 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1408 default: rtype
= NULL
;
1411 printf (" (%s)", rtype
);
1415 printf (_("<unknown addend: %lx>"),
1416 (unsigned long) rels
[i
].r_addend
);
1419 else if (symtab_index
)
1421 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1422 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1425 Elf_Internal_Sym
* psym
;
1427 psym
= symtab
+ symtab_index
;
1431 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1435 unsigned int width
= is_32bit_elf
? 8 : 14;
1437 /* Relocations against GNU_IFUNC symbols do not use the value
1438 of the symbol as the address to relocate against. Instead
1439 they invoke the function named by the symbol and use its
1440 result as the address for relocation.
1442 To indicate this to the user, do not display the value of
1443 the symbol in the "Symbols's Value" field. Instead show
1444 its name followed by () as a hint that the symbol is
1448 || psym
->st_name
== 0
1449 || psym
->st_name
>= strtablen
)
1452 name
= strtab
+ psym
->st_name
;
1454 len
= print_symbol (width
, name
);
1455 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1459 print_vma (psym
->st_value
, LONG_HEX
);
1461 printf (is_32bit_elf
? " " : " ");
1464 if (psym
->st_name
== 0)
1466 const char * sec_name
= "<null>";
1469 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1471 if (psym
->st_shndx
< elf_header
.e_shnum
)
1472 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1473 else if (psym
->st_shndx
== SHN_ABS
)
1475 else if (psym
->st_shndx
== SHN_COMMON
)
1476 sec_name
= "COMMON";
1477 else if ((elf_header
.e_machine
== EM_MIPS
1478 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1479 || (elf_header
.e_machine
== EM_TI_C6000
1480 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1481 sec_name
= "SCOMMON";
1482 else if (elf_header
.e_machine
== EM_MIPS
1483 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1484 sec_name
= "SUNDEF";
1485 else if ((elf_header
.e_machine
== EM_X86_64
1486 || elf_header
.e_machine
== EM_L1OM
1487 || elf_header
.e_machine
== EM_K1OM
)
1488 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1489 sec_name
= "LARGE_COMMON";
1490 else if (elf_header
.e_machine
== EM_IA_64
1491 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1492 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1493 sec_name
= "ANSI_COM";
1494 else if (is_ia64_vms ()
1495 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1496 sec_name
= "VMS_SYMVEC";
1499 sprintf (name_buf
, "<section 0x%x>",
1500 (unsigned int) psym
->st_shndx
);
1501 sec_name
= name_buf
;
1504 print_symbol (22, sec_name
);
1506 else if (strtab
== NULL
)
1507 printf (_("<string table index: %3ld>"), psym
->st_name
);
1508 else if (psym
->st_name
>= strtablen
)
1509 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1511 print_symbol (22, strtab
+ psym
->st_name
);
1515 bfd_signed_vma off
= rels
[i
].r_addend
;
1518 printf (" - %" BFD_VMA_FMT
"x", - off
);
1520 printf (" + %" BFD_VMA_FMT
"x", off
);
1526 bfd_signed_vma off
= rels
[i
].r_addend
;
1528 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1530 printf ("-%" BFD_VMA_FMT
"x", - off
);
1532 printf ("%" BFD_VMA_FMT
"x", off
);
1535 if (elf_header
.e_machine
== EM_SPARCV9
1537 && streq (rtype
, "R_SPARC_OLO10"))
1538 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1543 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1545 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1546 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1547 const char * rtype2
= elf_mips_reloc_type (type2
);
1548 const char * rtype3
= elf_mips_reloc_type (type3
);
1550 printf (" Type2: ");
1553 printf (_("unrecognized: %-7lx"),
1554 (unsigned long) type2
& 0xffffffff);
1556 printf ("%-17.17s", rtype2
);
1558 printf ("\n Type3: ");
1561 printf (_("unrecognized: %-7lx"),
1562 (unsigned long) type3
& 0xffffffff);
1564 printf ("%-17.17s", rtype3
);
1575 get_mips_dynamic_type (unsigned long type
)
1579 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1580 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1581 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1582 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1583 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1584 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1585 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1586 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1587 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1588 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1589 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1590 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1591 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1592 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1593 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1594 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1595 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1596 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1597 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1598 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1599 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1600 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1601 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1602 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1603 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1604 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1605 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1606 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1607 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1608 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1609 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1610 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1611 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1612 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1613 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1614 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1615 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1616 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1617 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1618 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1619 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1620 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1621 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1622 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1623 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1630 get_sparc64_dynamic_type (unsigned long type
)
1634 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1641 get_ppc_dynamic_type (unsigned long type
)
1645 case DT_PPC_GOT
: return "PPC_GOT";
1646 case DT_PPC_OPT
: return "PPC_OPT";
1653 get_ppc64_dynamic_type (unsigned long type
)
1657 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1658 case DT_PPC64_OPD
: return "PPC64_OPD";
1659 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1660 case DT_PPC64_OPT
: return "PPC64_OPT";
1667 get_parisc_dynamic_type (unsigned long type
)
1671 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1672 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1673 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1674 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1675 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1676 case DT_HP_PREINIT
: return "HP_PREINIT";
1677 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1678 case DT_HP_NEEDED
: return "HP_NEEDED";
1679 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1680 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1681 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1682 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1683 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1684 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1685 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1686 case DT_HP_FILTERED
: return "HP_FILTERED";
1687 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1688 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1689 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1690 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1691 case DT_PLT
: return "PLT";
1692 case DT_PLT_SIZE
: return "PLT_SIZE";
1693 case DT_DLT
: return "DLT";
1694 case DT_DLT_SIZE
: return "DLT_SIZE";
1701 get_ia64_dynamic_type (unsigned long type
)
1705 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1706 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1707 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1708 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1709 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1710 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1711 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1712 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1713 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1714 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1715 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1716 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1717 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1718 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1719 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1720 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1721 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1722 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1723 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1724 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1725 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1726 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1727 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1728 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1729 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1730 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1731 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1732 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1733 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1734 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1735 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1742 get_alpha_dynamic_type (unsigned long type
)
1746 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1753 get_score_dynamic_type (unsigned long type
)
1757 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1758 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1759 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1760 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1761 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1762 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1769 get_tic6x_dynamic_type (unsigned long type
)
1773 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1774 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1775 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1776 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1777 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1778 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1785 get_nios2_dynamic_type (unsigned long type
)
1789 case DT_NIOS2_GP
: return "NIOS2_GP";
1796 get_dynamic_type (unsigned long type
)
1798 static char buff
[64];
1802 case DT_NULL
: return "NULL";
1803 case DT_NEEDED
: return "NEEDED";
1804 case DT_PLTRELSZ
: return "PLTRELSZ";
1805 case DT_PLTGOT
: return "PLTGOT";
1806 case DT_HASH
: return "HASH";
1807 case DT_STRTAB
: return "STRTAB";
1808 case DT_SYMTAB
: return "SYMTAB";
1809 case DT_RELA
: return "RELA";
1810 case DT_RELASZ
: return "RELASZ";
1811 case DT_RELAENT
: return "RELAENT";
1812 case DT_STRSZ
: return "STRSZ";
1813 case DT_SYMENT
: return "SYMENT";
1814 case DT_INIT
: return "INIT";
1815 case DT_FINI
: return "FINI";
1816 case DT_SONAME
: return "SONAME";
1817 case DT_RPATH
: return "RPATH";
1818 case DT_SYMBOLIC
: return "SYMBOLIC";
1819 case DT_REL
: return "REL";
1820 case DT_RELSZ
: return "RELSZ";
1821 case DT_RELENT
: return "RELENT";
1822 case DT_PLTREL
: return "PLTREL";
1823 case DT_DEBUG
: return "DEBUG";
1824 case DT_TEXTREL
: return "TEXTREL";
1825 case DT_JMPREL
: return "JMPREL";
1826 case DT_BIND_NOW
: return "BIND_NOW";
1827 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1828 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1829 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1830 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1831 case DT_RUNPATH
: return "RUNPATH";
1832 case DT_FLAGS
: return "FLAGS";
1834 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1835 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1837 case DT_CHECKSUM
: return "CHECKSUM";
1838 case DT_PLTPADSZ
: return "PLTPADSZ";
1839 case DT_MOVEENT
: return "MOVEENT";
1840 case DT_MOVESZ
: return "MOVESZ";
1841 case DT_FEATURE
: return "FEATURE";
1842 case DT_POSFLAG_1
: return "POSFLAG_1";
1843 case DT_SYMINSZ
: return "SYMINSZ";
1844 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1846 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1847 case DT_CONFIG
: return "CONFIG";
1848 case DT_DEPAUDIT
: return "DEPAUDIT";
1849 case DT_AUDIT
: return "AUDIT";
1850 case DT_PLTPAD
: return "PLTPAD";
1851 case DT_MOVETAB
: return "MOVETAB";
1852 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1854 case DT_VERSYM
: return "VERSYM";
1856 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1857 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1858 case DT_RELACOUNT
: return "RELACOUNT";
1859 case DT_RELCOUNT
: return "RELCOUNT";
1860 case DT_FLAGS_1
: return "FLAGS_1";
1861 case DT_VERDEF
: return "VERDEF";
1862 case DT_VERDEFNUM
: return "VERDEFNUM";
1863 case DT_VERNEED
: return "VERNEED";
1864 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1866 case DT_AUXILIARY
: return "AUXILIARY";
1867 case DT_USED
: return "USED";
1868 case DT_FILTER
: return "FILTER";
1870 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1871 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1872 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1873 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1874 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1875 case DT_GNU_HASH
: return "GNU_HASH";
1878 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1880 const char * result
;
1882 switch (elf_header
.e_machine
)
1885 case EM_MIPS_RS3_LE
:
1886 result
= get_mips_dynamic_type (type
);
1889 result
= get_sparc64_dynamic_type (type
);
1892 result
= get_ppc_dynamic_type (type
);
1895 result
= get_ppc64_dynamic_type (type
);
1898 result
= get_ia64_dynamic_type (type
);
1901 result
= get_alpha_dynamic_type (type
);
1904 result
= get_score_dynamic_type (type
);
1907 result
= get_tic6x_dynamic_type (type
);
1909 case EM_ALTERA_NIOS2
:
1910 result
= get_nios2_dynamic_type (type
);
1920 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1922 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1923 || (elf_header
.e_machine
== EM_PARISC
1924 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1926 const char * result
;
1928 switch (elf_header
.e_machine
)
1931 result
= get_parisc_dynamic_type (type
);
1934 result
= get_ia64_dynamic_type (type
);
1944 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1948 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1955 get_file_type (unsigned e_type
)
1957 static char buff
[32];
1961 case ET_NONE
: return _("NONE (None)");
1962 case ET_REL
: return _("REL (Relocatable file)");
1963 case ET_EXEC
: return _("EXEC (Executable file)");
1964 case ET_DYN
: return _("DYN (Shared object file)");
1965 case ET_CORE
: return _("CORE (Core file)");
1968 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1969 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1970 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1971 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1973 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1979 get_machine_name (unsigned e_machine
)
1981 static char buff
[64]; /* XXX */
1985 case EM_NONE
: return _("None");
1986 case EM_AARCH64
: return "AArch64";
1987 case EM_M32
: return "WE32100";
1988 case EM_SPARC
: return "Sparc";
1989 case EM_SPU
: return "SPU";
1990 case EM_386
: return "Intel 80386";
1991 case EM_68K
: return "MC68000";
1992 case EM_88K
: return "MC88000";
1993 case EM_486
: return "Intel 80486";
1994 case EM_860
: return "Intel 80860";
1995 case EM_MIPS
: return "MIPS R3000";
1996 case EM_S370
: return "IBM System/370";
1997 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1998 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1999 case EM_PARISC
: return "HPPA";
2000 case EM_PPC_OLD
: return "Power PC (old)";
2001 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2002 case EM_960
: return "Intel 90860";
2003 case EM_PPC
: return "PowerPC";
2004 case EM_PPC64
: return "PowerPC64";
2005 case EM_FR20
: return "Fujitsu FR20";
2006 case EM_RH32
: return "TRW RH32";
2007 case EM_MCORE
: return "MCORE";
2008 case EM_ARM
: return "ARM";
2009 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2010 case EM_SH
: return "Renesas / SuperH SH";
2011 case EM_SPARCV9
: return "Sparc v9";
2012 case EM_TRICORE
: return "Siemens Tricore";
2013 case EM_ARC
: return "ARC";
2014 case EM_H8_300
: return "Renesas H8/300";
2015 case EM_H8_300H
: return "Renesas H8/300H";
2016 case EM_H8S
: return "Renesas H8S";
2017 case EM_H8_500
: return "Renesas H8/500";
2018 case EM_IA_64
: return "Intel IA-64";
2019 case EM_MIPS_X
: return "Stanford MIPS-X";
2020 case EM_COLDFIRE
: return "Motorola Coldfire";
2021 case EM_ALPHA
: return "Alpha";
2022 case EM_CYGNUS_D10V
:
2023 case EM_D10V
: return "d10v";
2024 case EM_CYGNUS_D30V
:
2025 case EM_D30V
: return "d30v";
2026 case EM_CYGNUS_M32R
:
2027 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2028 case EM_CYGNUS_V850
:
2029 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2030 case EM_V850
: return "Renesas V850";
2031 case EM_CYGNUS_MN10300
:
2032 case EM_MN10300
: return "mn10300";
2033 case EM_CYGNUS_MN10200
:
2034 case EM_MN10200
: return "mn10200";
2035 case EM_MOXIE
: return "Moxie";
2036 case EM_CYGNUS_FR30
:
2037 case EM_FR30
: return "Fujitsu FR30";
2038 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2040 case EM_PJ
: return "picoJava";
2041 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2042 case EM_PCP
: return "Siemens PCP";
2043 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2044 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2045 case EM_STARCORE
: return "Motorola Star*Core processor";
2046 case EM_ME16
: return "Toyota ME16 processor";
2047 case EM_ST100
: return "STMicroelectronics ST100 processor";
2048 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2049 case EM_PDSP
: return "Sony DSP processor";
2050 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2051 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2052 case EM_FX66
: return "Siemens FX66 microcontroller";
2053 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2054 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2055 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2056 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2057 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2058 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2059 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2060 case EM_SVX
: return "Silicon Graphics SVx";
2061 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2062 case EM_VAX
: return "Digital VAX";
2064 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2065 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2066 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2067 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2068 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2069 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2070 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2071 case EM_PRISM
: return "Vitesse Prism";
2072 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2073 case EM_L1OM
: return "Intel L1OM";
2074 case EM_K1OM
: return "Intel K1OM";
2076 case EM_S390
: return "IBM S/390";
2077 case EM_SCORE
: return "SUNPLUS S+Core";
2078 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2079 case EM_OR1K
: return "OpenRISC 1000";
2080 case EM_ARC_A5
: return "ARC International ARCompact processor";
2081 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2082 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2083 case EM_DLX
: return "OpenDLX";
2085 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2086 case EM_IQ2000
: return "Vitesse IQ2000";
2088 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2089 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2090 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2091 case EM_NS32K
: return "National Semiconductor 32000 series";
2092 case EM_TPC
: return "Tenor Network TPC processor";
2093 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2094 case EM_MAX
: return "MAX Processor";
2095 case EM_CR
: return "National Semiconductor CompactRISC";
2096 case EM_F2MC16
: return "Fujitsu F2MC16";
2097 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2098 case EM_LATTICEMICO32
: return "Lattice Mico32";
2100 case EM_M32C
: return "Renesas M32c";
2101 case EM_MT
: return "Morpho Techologies MT processor";
2102 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2103 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2104 case EM_SEP
: return "Sharp embedded microprocessor";
2105 case EM_ARCA
: return "Arca RISC microprocessor";
2106 case EM_UNICORE
: return "Unicore";
2107 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2108 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2109 case EM_NIOS32
: return "Altera Nios";
2110 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2112 case EM_XC16X
: return "Infineon Technologies xc16x";
2113 case EM_M16C
: return "Renesas M16C series microprocessors";
2114 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2115 case EM_CE
: return "Freescale Communication Engine RISC core";
2116 case EM_TSK3000
: return "Altium TSK3000 core";
2117 case EM_RS08
: return "Freescale RS08 embedded processor";
2118 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2119 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2120 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2121 case EM_SE_C17
: return "Seiko Epson C17 family";
2122 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2123 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2124 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2125 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2126 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2127 case EM_R32C
: return "Renesas R32C series microprocessors";
2128 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2129 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2130 case EM_8051
: return "Intel 8051 and variants";
2131 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2132 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2133 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2134 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2135 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2136 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2137 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2138 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2141 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2142 case EM_RL78
: return "Renesas RL78";
2143 case EM_RX
: return "Renesas RX";
2144 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2145 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2146 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2147 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2148 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2149 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2150 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2151 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2152 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2153 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2154 case EM_CUDA
: return "NVIDIA CUDA architecture";
2155 case EM_XGATE
: return "Motorola XGATE embedded processor";
2157 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2163 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2168 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2169 e_flags
&= ~ EF_ARM_EABIMASK
;
2171 /* Handle "generic" ARM flags. */
2172 if (e_flags
& EF_ARM_RELEXEC
)
2174 strcat (buf
, ", relocatable executable");
2175 e_flags
&= ~ EF_ARM_RELEXEC
;
2178 if (e_flags
& EF_ARM_HASENTRY
)
2180 strcat (buf
, ", has entry point");
2181 e_flags
&= ~ EF_ARM_HASENTRY
;
2184 /* Now handle EABI specific flags. */
2188 strcat (buf
, ", <unrecognized EABI>");
2193 case EF_ARM_EABI_VER1
:
2194 strcat (buf
, ", Version1 EABI");
2199 /* Process flags one bit at a time. */
2200 flag
= e_flags
& - e_flags
;
2205 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2206 strcat (buf
, ", sorted symbol tables");
2216 case EF_ARM_EABI_VER2
:
2217 strcat (buf
, ", Version2 EABI");
2222 /* Process flags one bit at a time. */
2223 flag
= e_flags
& - e_flags
;
2228 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2229 strcat (buf
, ", sorted symbol tables");
2232 case EF_ARM_DYNSYMSUSESEGIDX
:
2233 strcat (buf
, ", dynamic symbols use segment index");
2236 case EF_ARM_MAPSYMSFIRST
:
2237 strcat (buf
, ", mapping symbols precede others");
2247 case EF_ARM_EABI_VER3
:
2248 strcat (buf
, ", Version3 EABI");
2251 case EF_ARM_EABI_VER4
:
2252 strcat (buf
, ", Version4 EABI");
2257 /* Process flags one bit at a time. */
2258 flag
= e_flags
& - e_flags
;
2264 strcat (buf
, ", BE8");
2268 strcat (buf
, ", LE8");
2279 case EF_ARM_EABI_VER5
:
2280 strcat (buf
, ", Version5 EABI");
2285 /* Process flags one bit at a time. */
2286 flag
= e_flags
& - e_flags
;
2292 strcat (buf
, ", BE8");
2296 strcat (buf
, ", LE8");
2299 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2300 strcat (buf
, ", soft-float ABI");
2303 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2304 strcat (buf
, ", hard-float ABI");
2314 case EF_ARM_EABI_UNKNOWN
:
2315 strcat (buf
, ", GNU EABI");
2320 /* Process flags one bit at a time. */
2321 flag
= e_flags
& - e_flags
;
2326 case EF_ARM_INTERWORK
:
2327 strcat (buf
, ", interworking enabled");
2330 case EF_ARM_APCS_26
:
2331 strcat (buf
, ", uses APCS/26");
2334 case EF_ARM_APCS_FLOAT
:
2335 strcat (buf
, ", uses APCS/float");
2339 strcat (buf
, ", position independent");
2343 strcat (buf
, ", 8 bit structure alignment");
2346 case EF_ARM_NEW_ABI
:
2347 strcat (buf
, ", uses new ABI");
2350 case EF_ARM_OLD_ABI
:
2351 strcat (buf
, ", uses old ABI");
2354 case EF_ARM_SOFT_FLOAT
:
2355 strcat (buf
, ", software FP");
2358 case EF_ARM_VFP_FLOAT
:
2359 strcat (buf
, ", VFP");
2362 case EF_ARM_MAVERICK_FLOAT
:
2363 strcat (buf
, ", Maverick FP");
2374 strcat (buf
,_(", <unknown>"));
2378 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2387 static const char *ABI_STRINGS
[] =
2389 "ABI v0", /* use r5 as return register; only used in N1213HC */
2390 "ABI v1", /* use r0 as return register */
2391 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2392 "ABI v2fp", /* for FPU */
2396 static const char *VER_STRINGS
[] =
2398 "Andes ELF V1.3 or older",
2402 static const char *ARCH_STRINGS
[] =
2411 abi
= EF_NDS_ABI
& e_flags
;
2412 arch
= EF_NDS_ARCH
& e_flags
;
2413 config
= EF_NDS_INST
& e_flags
;
2414 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2416 memset (buf
, 0, size
);
2423 case E_NDS_ABI_V2FP
:
2424 case E_NDS_ABI_AABI
:
2425 case E_NDS_ABI_V2FP_PLUS
:
2426 /* In case there are holes in the array. */
2427 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2431 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2437 case E_NDS32_ELF_VER_1_2
:
2438 case E_NDS32_ELF_VER_1_3
:
2439 case E_NDS32_ELF_VER_1_4
:
2440 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2444 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2448 if (E_NDS_ABI_V0
== abi
)
2450 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2451 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2452 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2453 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2459 case E_NDS_ARCH_STAR_V1_0
:
2460 case E_NDS_ARCH_STAR_V2_0
:
2461 case E_NDS_ARCH_STAR_V3_0
:
2462 case E_NDS_ARCH_STAR_V3_M
:
2463 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2467 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2468 /* ARCH version determines how the e_flags are interpreted.
2469 If it is unknown, we cannot proceed. */
2473 /* Newer ABI; Now handle architecture specific flags. */
2474 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2476 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2477 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2479 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2480 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2482 if (config
& E_NDS32_HAS_DIV_INST
)
2483 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2485 if (config
& E_NDS32_HAS_16BIT_INST
)
2486 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2490 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2492 if (version
<= E_NDS32_ELF_VER_1_3
)
2493 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2495 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2498 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2499 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2501 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2502 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2504 if (config
& E_NDS32_HAS_16BIT_INST
)
2506 if (version
<= E_NDS32_ELF_VER_1_3
)
2507 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2509 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2513 if (config
& E_NDS32_HAS_EXT_INST
)
2514 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2516 if (config
& E_NDS32_HAS_EXT2_INST
)
2517 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2519 if (config
& E_NDS32_HAS_FPU_INST
)
2522 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2525 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2528 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2531 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2534 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2539 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2541 case E_NDS32_FPU_REG_8SP_4DP
:
2542 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2544 case E_NDS32_FPU_REG_16SP_8DP
:
2545 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2547 case E_NDS32_FPU_REG_32SP_16DP
:
2548 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2550 case E_NDS32_FPU_REG_32SP_32DP
:
2551 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2556 if (config
& E_NDS32_HAS_AUDIO_INST
)
2557 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2559 if (config
& E_NDS32_HAS_STRING_INST
)
2560 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2562 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2563 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2565 if (config
& E_NDS32_HAS_VIDEO_INST
)
2567 if (version
<= E_NDS32_ELF_VER_1_3
)
2568 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2570 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2573 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2574 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2576 if (config
& E_NDS32_HAS_L2C_INST
)
2577 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2581 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2583 static char buf
[1024];
2595 decode_ARM_machine_flags (e_flags
, buf
);
2599 if (e_flags
& EF_BFIN_PIC
)
2600 strcat (buf
, ", PIC");
2602 if (e_flags
& EF_BFIN_FDPIC
)
2603 strcat (buf
, ", FDPIC");
2605 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2606 strcat (buf
, ", code in L1");
2608 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2609 strcat (buf
, ", data in L1");
2614 switch (e_flags
& EF_FRV_CPU_MASK
)
2616 case EF_FRV_CPU_GENERIC
:
2620 strcat (buf
, ", fr???");
2623 case EF_FRV_CPU_FR300
:
2624 strcat (buf
, ", fr300");
2627 case EF_FRV_CPU_FR400
:
2628 strcat (buf
, ", fr400");
2630 case EF_FRV_CPU_FR405
:
2631 strcat (buf
, ", fr405");
2634 case EF_FRV_CPU_FR450
:
2635 strcat (buf
, ", fr450");
2638 case EF_FRV_CPU_FR500
:
2639 strcat (buf
, ", fr500");
2641 case EF_FRV_CPU_FR550
:
2642 strcat (buf
, ", fr550");
2645 case EF_FRV_CPU_SIMPLE
:
2646 strcat (buf
, ", simple");
2648 case EF_FRV_CPU_TOMCAT
:
2649 strcat (buf
, ", tomcat");
2655 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2656 strcat (buf
, ", m68000");
2657 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2658 strcat (buf
, ", cpu32");
2659 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2660 strcat (buf
, ", fido_a");
2663 char const * isa
= _("unknown");
2664 char const * mac
= _("unknown mac");
2665 char const * additional
= NULL
;
2667 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2669 case EF_M68K_CF_ISA_A_NODIV
:
2671 additional
= ", nodiv";
2673 case EF_M68K_CF_ISA_A
:
2676 case EF_M68K_CF_ISA_A_PLUS
:
2679 case EF_M68K_CF_ISA_B_NOUSP
:
2681 additional
= ", nousp";
2683 case EF_M68K_CF_ISA_B
:
2686 case EF_M68K_CF_ISA_C
:
2689 case EF_M68K_CF_ISA_C_NODIV
:
2691 additional
= ", nodiv";
2694 strcat (buf
, ", cf, isa ");
2697 strcat (buf
, additional
);
2698 if (e_flags
& EF_M68K_CF_FLOAT
)
2699 strcat (buf
, ", float");
2700 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2705 case EF_M68K_CF_MAC
:
2708 case EF_M68K_CF_EMAC
:
2711 case EF_M68K_CF_EMAC_B
:
2724 if (e_flags
& EF_PPC_EMB
)
2725 strcat (buf
, ", emb");
2727 if (e_flags
& EF_PPC_RELOCATABLE
)
2728 strcat (buf
, _(", relocatable"));
2730 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2731 strcat (buf
, _(", relocatable-lib"));
2735 if (e_flags
& EF_PPC64_ABI
)
2737 char abi
[] = ", abiv0";
2739 abi
[6] += e_flags
& EF_PPC64_ABI
;
2745 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2746 strcat (buf
, ", RH850 ABI");
2748 if (e_flags
& EF_V800_850E3
)
2749 strcat (buf
, ", V3 architecture");
2751 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2752 strcat (buf
, ", FPU not used");
2754 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2755 strcat (buf
, ", regmode: COMMON");
2757 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2758 strcat (buf
, ", r4 not used");
2760 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2761 strcat (buf
, ", r30 not used");
2763 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2764 strcat (buf
, ", r5 not used");
2766 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2767 strcat (buf
, ", r2 not used");
2769 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2771 switch (e_flags
& - e_flags
)
2773 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2774 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2775 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2776 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2777 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2778 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2779 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2780 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2781 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2782 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2783 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2784 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2785 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2786 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2787 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2788 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2795 case EM_CYGNUS_V850
:
2796 switch (e_flags
& EF_V850_ARCH
)
2798 case E_V850E3V5_ARCH
:
2799 strcat (buf
, ", v850e3v5");
2801 case E_V850E2V3_ARCH
:
2802 strcat (buf
, ", v850e2v3");
2805 strcat (buf
, ", v850e2");
2808 strcat (buf
, ", v850e1");
2811 strcat (buf
, ", v850e");
2814 strcat (buf
, ", v850");
2817 strcat (buf
, _(", unknown v850 architecture variant"));
2823 case EM_CYGNUS_M32R
:
2824 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2825 strcat (buf
, ", m32r");
2829 case EM_MIPS_RS3_LE
:
2830 if (e_flags
& EF_MIPS_NOREORDER
)
2831 strcat (buf
, ", noreorder");
2833 if (e_flags
& EF_MIPS_PIC
)
2834 strcat (buf
, ", pic");
2836 if (e_flags
& EF_MIPS_CPIC
)
2837 strcat (buf
, ", cpic");
2839 if (e_flags
& EF_MIPS_UCODE
)
2840 strcat (buf
, ", ugen_reserved");
2842 if (e_flags
& EF_MIPS_ABI2
)
2843 strcat (buf
, ", abi2");
2845 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2846 strcat (buf
, ", odk first");
2848 if (e_flags
& EF_MIPS_32BITMODE
)
2849 strcat (buf
, ", 32bitmode");
2851 if (e_flags
& EF_MIPS_NAN2008
)
2852 strcat (buf
, ", nan2008");
2854 if (e_flags
& EF_MIPS_FP64
)
2855 strcat (buf
, ", fp64");
2857 switch ((e_flags
& EF_MIPS_MACH
))
2859 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2860 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2861 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2862 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2863 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2864 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2865 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2866 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2867 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2868 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2869 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2870 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2871 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2872 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2873 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2874 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
2875 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2877 /* We simply ignore the field in this case to avoid confusion:
2878 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2881 default: strcat (buf
, _(", unknown CPU")); break;
2884 switch ((e_flags
& EF_MIPS_ABI
))
2886 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2887 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2888 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2889 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2891 /* We simply ignore the field in this case to avoid confusion:
2892 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2893 This means it is likely to be an o32 file, but not for
2896 default: strcat (buf
, _(", unknown ABI")); break;
2899 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2900 strcat (buf
, ", mdmx");
2902 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2903 strcat (buf
, ", mips16");
2905 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2906 strcat (buf
, ", micromips");
2908 switch ((e_flags
& EF_MIPS_ARCH
))
2910 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2911 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2912 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2913 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2914 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2915 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2916 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2917 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
2918 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2919 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2920 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
2921 default: strcat (buf
, _(", unknown ISA")); break;
2926 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
2930 switch ((e_flags
& EF_SH_MACH_MASK
))
2932 case EF_SH1
: strcat (buf
, ", sh1"); break;
2933 case EF_SH2
: strcat (buf
, ", sh2"); break;
2934 case EF_SH3
: strcat (buf
, ", sh3"); break;
2935 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2936 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2937 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2938 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2939 case EF_SH4
: strcat (buf
, ", sh4"); break;
2940 case EF_SH5
: strcat (buf
, ", sh5"); break;
2941 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2942 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2943 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2944 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2945 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2946 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2947 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2948 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2949 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2950 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2951 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2952 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2953 default: strcat (buf
, _(", unknown ISA")); break;
2956 if (e_flags
& EF_SH_PIC
)
2957 strcat (buf
, ", pic");
2959 if (e_flags
& EF_SH_FDPIC
)
2960 strcat (buf
, ", fdpic");
2964 if (e_flags
& EF_OR1K_NODELAY
)
2965 strcat (buf
, ", no delay");
2969 if (e_flags
& EF_SPARC_32PLUS
)
2970 strcat (buf
, ", v8+");
2972 if (e_flags
& EF_SPARC_SUN_US1
)
2973 strcat (buf
, ", ultrasparcI");
2975 if (e_flags
& EF_SPARC_SUN_US3
)
2976 strcat (buf
, ", ultrasparcIII");
2978 if (e_flags
& EF_SPARC_HAL_R1
)
2979 strcat (buf
, ", halr1");
2981 if (e_flags
& EF_SPARC_LEDATA
)
2982 strcat (buf
, ", ledata");
2984 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2985 strcat (buf
, ", tso");
2987 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2988 strcat (buf
, ", pso");
2990 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2991 strcat (buf
, ", rmo");
2995 switch (e_flags
& EF_PARISC_ARCH
)
2997 case EFA_PARISC_1_0
:
2998 strcpy (buf
, ", PA-RISC 1.0");
3000 case EFA_PARISC_1_1
:
3001 strcpy (buf
, ", PA-RISC 1.1");
3003 case EFA_PARISC_2_0
:
3004 strcpy (buf
, ", PA-RISC 2.0");
3009 if (e_flags
& EF_PARISC_TRAPNIL
)
3010 strcat (buf
, ", trapnil");
3011 if (e_flags
& EF_PARISC_EXT
)
3012 strcat (buf
, ", ext");
3013 if (e_flags
& EF_PARISC_LSB
)
3014 strcat (buf
, ", lsb");
3015 if (e_flags
& EF_PARISC_WIDE
)
3016 strcat (buf
, ", wide");
3017 if (e_flags
& EF_PARISC_NO_KABP
)
3018 strcat (buf
, ", no kabp");
3019 if (e_flags
& EF_PARISC_LAZYSWAP
)
3020 strcat (buf
, ", lazyswap");
3025 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3026 strcat (buf
, ", new calling convention");
3028 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3029 strcat (buf
, ", gnu calling convention");
3033 if ((e_flags
& EF_IA_64_ABI64
))
3034 strcat (buf
, ", 64-bit");
3036 strcat (buf
, ", 32-bit");
3037 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3038 strcat (buf
, ", reduced fp model");
3039 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3040 strcat (buf
, ", no function descriptors, constant gp");
3041 else if ((e_flags
& EF_IA_64_CONS_GP
))
3042 strcat (buf
, ", constant gp");
3043 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3044 strcat (buf
, ", absolute");
3045 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3047 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3048 strcat (buf
, ", vms_linkages");
3049 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3051 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3053 case EF_IA_64_VMS_COMCOD_WARNING
:
3054 strcat (buf
, ", warning");
3056 case EF_IA_64_VMS_COMCOD_ERROR
:
3057 strcat (buf
, ", error");
3059 case EF_IA_64_VMS_COMCOD_ABORT
:
3060 strcat (buf
, ", abort");
3069 if ((e_flags
& EF_VAX_NONPIC
))
3070 strcat (buf
, ", non-PIC");
3071 if ((e_flags
& EF_VAX_DFLOAT
))
3072 strcat (buf
, ", D-Float");
3073 if ((e_flags
& EF_VAX_GFLOAT
))
3074 strcat (buf
, ", G-Float");
3078 if (e_flags
& E_FLAG_RL78_G10
)
3079 strcat (buf
, ", G10");
3080 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3081 strcat (buf
, ", 64-bit doubles");
3085 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3086 strcat (buf
, ", 64-bit doubles");
3087 if (e_flags
& E_FLAG_RX_DSP
)
3088 strcat (buf
, ", dsp");
3089 if (e_flags
& E_FLAG_RX_PID
)
3090 strcat (buf
, ", pid");
3091 if (e_flags
& E_FLAG_RX_ABI
)
3092 strcat (buf
, ", RX ABI");
3096 if (e_flags
& EF_S390_HIGH_GPRS
)
3097 strcat (buf
, ", highgprs");
3101 if ((e_flags
& EF_C6000_REL
))
3102 strcat (buf
, ", relocatable module");
3106 strcat (buf
, _(": architecture variant: "));
3107 switch (e_flags
& EF_MSP430_MACH
)
3109 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3110 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3111 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3112 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3113 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3114 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3115 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3116 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3117 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3118 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3119 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3120 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3121 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3122 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3123 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3125 strcat (buf
, _(": unknown")); break;
3128 if (e_flags
& ~ EF_MSP430_MACH
)
3129 strcat (buf
, _(": unknown extra flag bits also present"));
3137 get_osabi_name (unsigned int osabi
)
3139 static char buff
[32];
3143 case ELFOSABI_NONE
: return "UNIX - System V";
3144 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3145 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3146 case ELFOSABI_GNU
: return "UNIX - GNU";
3147 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3148 case ELFOSABI_AIX
: return "UNIX - AIX";
3149 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3150 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3151 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3152 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3153 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3154 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3155 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3156 case ELFOSABI_AROS
: return "AROS";
3157 case ELFOSABI_FENIXOS
: return "FenixOS";
3160 switch (elf_header
.e_machine
)
3165 case ELFOSABI_ARM
: return "ARM";
3175 case ELFOSABI_STANDALONE
: return _("Standalone App");
3184 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3185 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3194 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3200 get_aarch64_segment_type (unsigned long type
)
3204 case PT_AARCH64_ARCHEXT
:
3205 return "AARCH64_ARCHEXT";
3214 get_arm_segment_type (unsigned long type
)
3228 get_mips_segment_type (unsigned long type
)
3232 case PT_MIPS_REGINFO
:
3234 case PT_MIPS_RTPROC
:
3236 case PT_MIPS_OPTIONS
:
3238 case PT_MIPS_ABIFLAGS
:
3248 get_parisc_segment_type (unsigned long type
)
3252 case PT_HP_TLS
: return "HP_TLS";
3253 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3254 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3255 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3256 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3257 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3258 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3259 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3260 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3261 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3262 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3263 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3264 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3265 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3266 case PT_HP_STACK
: return "HP_STACK";
3267 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3268 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3269 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3270 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3279 get_ia64_segment_type (unsigned long type
)
3283 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3284 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3285 case PT_HP_TLS
: return "HP_TLS";
3286 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3287 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3288 case PT_IA_64_HP_STACK
: return "HP_STACK";
3297 get_tic6x_segment_type (unsigned long type
)
3301 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3310 get_segment_type (unsigned long p_type
)
3312 static char buff
[32];
3316 case PT_NULL
: return "NULL";
3317 case PT_LOAD
: return "LOAD";
3318 case PT_DYNAMIC
: return "DYNAMIC";
3319 case PT_INTERP
: return "INTERP";
3320 case PT_NOTE
: return "NOTE";
3321 case PT_SHLIB
: return "SHLIB";
3322 case PT_PHDR
: return "PHDR";
3323 case PT_TLS
: return "TLS";
3325 case PT_GNU_EH_FRAME
:
3326 return "GNU_EH_FRAME";
3327 case PT_GNU_STACK
: return "GNU_STACK";
3328 case PT_GNU_RELRO
: return "GNU_RELRO";
3331 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3333 const char * result
;
3335 switch (elf_header
.e_machine
)
3338 result
= get_aarch64_segment_type (p_type
);
3341 result
= get_arm_segment_type (p_type
);
3344 case EM_MIPS_RS3_LE
:
3345 result
= get_mips_segment_type (p_type
);
3348 result
= get_parisc_segment_type (p_type
);
3351 result
= get_ia64_segment_type (p_type
);
3354 result
= get_tic6x_segment_type (p_type
);
3364 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3366 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3368 const char * result
;
3370 switch (elf_header
.e_machine
)
3373 result
= get_parisc_segment_type (p_type
);
3376 result
= get_ia64_segment_type (p_type
);
3386 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3389 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3396 get_mips_section_type_name (unsigned int sh_type
)
3400 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3401 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3402 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3403 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3404 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3405 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3406 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3407 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3408 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3409 case SHT_MIPS_RELD
: return "MIPS_RELD";
3410 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3411 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3412 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3413 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3414 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3415 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3416 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3417 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3418 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3419 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3420 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3421 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3422 case SHT_MIPS_LINE
: return "MIPS_LINE";
3423 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3424 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3425 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3426 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3427 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3428 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3429 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3430 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3431 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3432 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3433 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3434 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3435 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3436 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3437 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3438 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3439 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3447 get_parisc_section_type_name (unsigned int sh_type
)
3451 case SHT_PARISC_EXT
: return "PARISC_EXT";
3452 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3453 case SHT_PARISC_DOC
: return "PARISC_DOC";
3454 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3455 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3456 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3457 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3465 get_ia64_section_type_name (unsigned int sh_type
)
3467 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3468 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3469 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3473 case SHT_IA_64_EXT
: return "IA_64_EXT";
3474 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3475 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3476 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3477 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3478 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3479 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3480 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3481 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3482 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3490 get_x86_64_section_type_name (unsigned int sh_type
)
3494 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3502 get_aarch64_section_type_name (unsigned int sh_type
)
3506 case SHT_AARCH64_ATTRIBUTES
:
3507 return "AARCH64_ATTRIBUTES";
3515 get_arm_section_type_name (unsigned int sh_type
)
3519 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3520 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3521 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3522 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3523 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3531 get_tic6x_section_type_name (unsigned int sh_type
)
3535 case SHT_C6000_UNWIND
:
3536 return "C6000_UNWIND";
3537 case SHT_C6000_PREEMPTMAP
:
3538 return "C6000_PREEMPTMAP";
3539 case SHT_C6000_ATTRIBUTES
:
3540 return "C6000_ATTRIBUTES";
3545 case SHT_TI_HANDLER
:
3546 return "TI_HANDLER";
3547 case SHT_TI_INITINFO
:
3548 return "TI_INITINFO";
3549 case SHT_TI_PHATTRS
:
3550 return "TI_PHATTRS";
3558 get_msp430x_section_type_name (unsigned int sh_type
)
3562 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3563 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3564 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3565 default: return NULL
;
3570 get_section_type_name (unsigned int sh_type
)
3572 static char buff
[32];
3576 case SHT_NULL
: return "NULL";
3577 case SHT_PROGBITS
: return "PROGBITS";
3578 case SHT_SYMTAB
: return "SYMTAB";
3579 case SHT_STRTAB
: return "STRTAB";
3580 case SHT_RELA
: return "RELA";
3581 case SHT_HASH
: return "HASH";
3582 case SHT_DYNAMIC
: return "DYNAMIC";
3583 case SHT_NOTE
: return "NOTE";
3584 case SHT_NOBITS
: return "NOBITS";
3585 case SHT_REL
: return "REL";
3586 case SHT_SHLIB
: return "SHLIB";
3587 case SHT_DYNSYM
: return "DYNSYM";
3588 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3589 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3590 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3591 case SHT_GNU_HASH
: return "GNU_HASH";
3592 case SHT_GROUP
: return "GROUP";
3593 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3594 case SHT_GNU_verdef
: return "VERDEF";
3595 case SHT_GNU_verneed
: return "VERNEED";
3596 case SHT_GNU_versym
: return "VERSYM";
3597 case 0x6ffffff0: return "VERSYM";
3598 case 0x6ffffffc: return "VERDEF";
3599 case 0x7ffffffd: return "AUXILIARY";
3600 case 0x7fffffff: return "FILTER";
3601 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3604 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3606 const char * result
;
3608 switch (elf_header
.e_machine
)
3611 case EM_MIPS_RS3_LE
:
3612 result
= get_mips_section_type_name (sh_type
);
3615 result
= get_parisc_section_type_name (sh_type
);
3618 result
= get_ia64_section_type_name (sh_type
);
3623 result
= get_x86_64_section_type_name (sh_type
);
3626 result
= get_aarch64_section_type_name (sh_type
);
3629 result
= get_arm_section_type_name (sh_type
);
3632 result
= get_tic6x_section_type_name (sh_type
);
3635 result
= get_msp430x_section_type_name (sh_type
);
3645 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3647 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3649 const char * result
;
3651 switch (elf_header
.e_machine
)
3654 result
= get_ia64_section_type_name (sh_type
);
3664 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3666 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3667 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3669 /* This message is probably going to be displayed in a 15
3670 character wide field, so put the hex value first. */
3671 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3677 #define OPTION_DEBUG_DUMP 512
3678 #define OPTION_DYN_SYMS 513
3679 #define OPTION_DWARF_DEPTH 514
3680 #define OPTION_DWARF_START 515
3681 #define OPTION_DWARF_CHECK 516
3683 static struct option options
[] =
3685 {"all", no_argument
, 0, 'a'},
3686 {"file-header", no_argument
, 0, 'h'},
3687 {"program-headers", no_argument
, 0, 'l'},
3688 {"headers", no_argument
, 0, 'e'},
3689 {"histogram", no_argument
, 0, 'I'},
3690 {"segments", no_argument
, 0, 'l'},
3691 {"sections", no_argument
, 0, 'S'},
3692 {"section-headers", no_argument
, 0, 'S'},
3693 {"section-groups", no_argument
, 0, 'g'},
3694 {"section-details", no_argument
, 0, 't'},
3695 {"full-section-name",no_argument
, 0, 'N'},
3696 {"symbols", no_argument
, 0, 's'},
3697 {"syms", no_argument
, 0, 's'},
3698 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3699 {"relocs", no_argument
, 0, 'r'},
3700 {"notes", no_argument
, 0, 'n'},
3701 {"dynamic", no_argument
, 0, 'd'},
3702 {"arch-specific", no_argument
, 0, 'A'},
3703 {"version-info", no_argument
, 0, 'V'},
3704 {"use-dynamic", no_argument
, 0, 'D'},
3705 {"unwind", no_argument
, 0, 'u'},
3706 {"archive-index", no_argument
, 0, 'c'},
3707 {"hex-dump", required_argument
, 0, 'x'},
3708 {"relocated-dump", required_argument
, 0, 'R'},
3709 {"string-dump", required_argument
, 0, 'p'},
3710 #ifdef SUPPORT_DISASSEMBLY
3711 {"instruction-dump", required_argument
, 0, 'i'},
3713 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3715 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3716 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3717 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3719 {"version", no_argument
, 0, 'v'},
3720 {"wide", no_argument
, 0, 'W'},
3721 {"help", no_argument
, 0, 'H'},
3722 {0, no_argument
, 0, 0}
3726 usage (FILE * stream
)
3728 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3729 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3730 fprintf (stream
, _(" Options are:\n\
3731 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3732 -h --file-header Display the ELF file header\n\
3733 -l --program-headers Display the program headers\n\
3734 --segments An alias for --program-headers\n\
3735 -S --section-headers Display the sections' header\n\
3736 --sections An alias for --section-headers\n\
3737 -g --section-groups Display the section groups\n\
3738 -t --section-details Display the section details\n\
3739 -e --headers Equivalent to: -h -l -S\n\
3740 -s --syms Display the symbol table\n\
3741 --symbols An alias for --syms\n\
3742 --dyn-syms Display the dynamic symbol table\n\
3743 -n --notes Display the core notes (if present)\n\
3744 -r --relocs Display the relocations (if present)\n\
3745 -u --unwind Display the unwind info (if present)\n\
3746 -d --dynamic Display the dynamic section (if present)\n\
3747 -V --version-info Display the version sections (if present)\n\
3748 -A --arch-specific Display architecture specific information (if any)\n\
3749 -c --archive-index Display the symbol/file index in an archive\n\
3750 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3751 -x --hex-dump=<number|name>\n\
3752 Dump the contents of section <number|name> as bytes\n\
3753 -p --string-dump=<number|name>\n\
3754 Dump the contents of section <number|name> as strings\n\
3755 -R --relocated-dump=<number|name>\n\
3756 Dump the contents of section <number|name> as relocated bytes\n\
3757 -w[lLiaprmfFsoRt] or\n\
3758 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3759 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3760 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3762 Display the contents of DWARF2 debug sections\n"));
3763 fprintf (stream
, _("\
3764 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3765 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3767 #ifdef SUPPORT_DISASSEMBLY
3768 fprintf (stream
, _("\
3769 -i --instruction-dump=<number|name>\n\
3770 Disassemble the contents of section <number|name>\n"));
3772 fprintf (stream
, _("\
3773 -I --histogram Display histogram of bucket list lengths\n\
3774 -W --wide Allow output width to exceed 80 characters\n\
3775 @<file> Read options from <file>\n\
3776 -H --help Display this information\n\
3777 -v --version Display the version number of readelf\n"));
3779 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3780 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3782 exit (stream
== stdout
? 0 : 1);
3785 /* Record the fact that the user wants the contents of section number
3786 SECTION to be displayed using the method(s) encoded as flags bits
3787 in TYPE. Note, TYPE can be zero if we are creating the array for
3791 request_dump_bynumber (unsigned int section
, dump_type type
)
3793 if (section
>= num_dump_sects
)
3795 dump_type
* new_dump_sects
;
3797 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3798 sizeof (* dump_sects
));
3800 if (new_dump_sects
== NULL
)
3801 error (_("Out of memory allocating dump request table.\n"));
3804 /* Copy current flag settings. */
3805 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3809 dump_sects
= new_dump_sects
;
3810 num_dump_sects
= section
+ 1;
3815 dump_sects
[section
] |= type
;
3820 /* Request a dump by section name. */
3823 request_dump_byname (const char * section
, dump_type type
)
3825 struct dump_list_entry
* new_request
;
3827 new_request
= (struct dump_list_entry
*)
3828 malloc (sizeof (struct dump_list_entry
));
3830 error (_("Out of memory allocating dump request table.\n"));
3832 new_request
->name
= strdup (section
);
3833 if (!new_request
->name
)
3834 error (_("Out of memory allocating dump request table.\n"));
3836 new_request
->type
= type
;
3838 new_request
->next
= dump_sects_byname
;
3839 dump_sects_byname
= new_request
;
3843 request_dump (dump_type type
)
3849 section
= strtoul (optarg
, & cp
, 0);
3851 if (! *cp
&& section
>= 0)
3852 request_dump_bynumber (section
, type
);
3854 request_dump_byname (optarg
, type
);
3859 parse_args (int argc
, char ** argv
)
3866 while ((c
= getopt_long
3867 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3885 do_section_groups
++;
3893 do_section_groups
++;
3898 do_section_details
++;
3942 request_dump (HEX_DUMP
);
3945 request_dump (STRING_DUMP
);
3948 request_dump (RELOC_DUMP
);
3955 dwarf_select_sections_all ();
3960 dwarf_select_sections_by_letters (optarg
);
3963 case OPTION_DEBUG_DUMP
:
3970 dwarf_select_sections_by_names (optarg
);
3973 case OPTION_DWARF_DEPTH
:
3977 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3980 case OPTION_DWARF_START
:
3984 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3987 case OPTION_DWARF_CHECK
:
3990 case OPTION_DYN_SYMS
:
3993 #ifdef SUPPORT_DISASSEMBLY
3995 request_dump (DISASS_DUMP
);
3999 print_version (program_name
);
4008 /* xgettext:c-format */
4009 error (_("Invalid option '-%c'\n"), c
);
4016 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4017 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4018 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4019 && !do_section_groups
&& !do_archive_index
4024 warn (_("Nothing to do.\n"));
4030 get_elf_class (unsigned int elf_class
)
4032 static char buff
[32];
4036 case ELFCLASSNONE
: return _("none");
4037 case ELFCLASS32
: return "ELF32";
4038 case ELFCLASS64
: return "ELF64";
4040 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4046 get_data_encoding (unsigned int encoding
)
4048 static char buff
[32];
4052 case ELFDATANONE
: return _("none");
4053 case ELFDATA2LSB
: return _("2's complement, little endian");
4054 case ELFDATA2MSB
: return _("2's complement, big endian");
4056 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4061 /* Decode the data held in 'elf_header'. */
4064 process_file_header (void)
4066 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4067 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4068 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4069 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4072 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4076 init_dwarf_regnames (elf_header
.e_machine
);
4082 printf (_("ELF Header:\n"));
4083 printf (_(" Magic: "));
4084 for (i
= 0; i
< EI_NIDENT
; i
++)
4085 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4087 printf (_(" Class: %s\n"),
4088 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4089 printf (_(" Data: %s\n"),
4090 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4091 printf (_(" Version: %d %s\n"),
4092 elf_header
.e_ident
[EI_VERSION
],
4093 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4095 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4096 ? _("<unknown: %lx>")
4098 printf (_(" OS/ABI: %s\n"),
4099 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4100 printf (_(" ABI Version: %d\n"),
4101 elf_header
.e_ident
[EI_ABIVERSION
]);
4102 printf (_(" Type: %s\n"),
4103 get_file_type (elf_header
.e_type
));
4104 printf (_(" Machine: %s\n"),
4105 get_machine_name (elf_header
.e_machine
));
4106 printf (_(" Version: 0x%lx\n"),
4107 (unsigned long) elf_header
.e_version
);
4109 printf (_(" Entry point address: "));
4110 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4111 printf (_("\n Start of program headers: "));
4112 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4113 printf (_(" (bytes into file)\n Start of section headers: "));
4114 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4115 printf (_(" (bytes into file)\n"));
4117 printf (_(" Flags: 0x%lx%s\n"),
4118 (unsigned long) elf_header
.e_flags
,
4119 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4120 printf (_(" Size of this header: %ld (bytes)\n"),
4121 (long) elf_header
.e_ehsize
);
4122 printf (_(" Size of program headers: %ld (bytes)\n"),
4123 (long) elf_header
.e_phentsize
);
4124 printf (_(" Number of program headers: %ld"),
4125 (long) elf_header
.e_phnum
);
4126 if (section_headers
!= NULL
4127 && elf_header
.e_phnum
== PN_XNUM
4128 && section_headers
[0].sh_info
!= 0)
4129 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4130 putc ('\n', stdout
);
4131 printf (_(" Size of section headers: %ld (bytes)\n"),
4132 (long) elf_header
.e_shentsize
);
4133 printf (_(" Number of section headers: %ld"),
4134 (long) elf_header
.e_shnum
);
4135 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4136 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4137 putc ('\n', stdout
);
4138 printf (_(" Section header string table index: %ld"),
4139 (long) elf_header
.e_shstrndx
);
4140 if (section_headers
!= NULL
4141 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4142 printf (" (%u)", section_headers
[0].sh_link
);
4143 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4144 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4145 printf (_(" <corrupt: out of range>"));
4146 putc ('\n', stdout
);
4149 if (section_headers
!= NULL
)
4151 if (elf_header
.e_phnum
== PN_XNUM
4152 && section_headers
[0].sh_info
!= 0)
4153 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4154 if (elf_header
.e_shnum
== SHN_UNDEF
)
4155 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4156 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4157 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4158 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4159 elf_header
.e_shstrndx
= SHN_UNDEF
;
4160 free (section_headers
);
4161 section_headers
= NULL
;
4168 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4170 Elf32_External_Phdr
* phdrs
;
4171 Elf32_External_Phdr
* external
;
4172 Elf_Internal_Phdr
* internal
;
4174 unsigned int size
= elf_header
.e_phentsize
;
4175 unsigned int num
= elf_header
.e_phnum
;
4177 /* PR binutils/17531: Cope with unexpected section header sizes. */
4178 if (size
== 0 || num
== 0)
4180 if (size
< sizeof * phdrs
)
4182 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4185 if (size
> sizeof * phdrs
)
4186 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4188 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4189 size
, num
, _("program headers"));
4193 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4194 i
< elf_header
.e_phnum
;
4195 i
++, internal
++, external
++)
4197 internal
->p_type
= BYTE_GET (external
->p_type
);
4198 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4199 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4200 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4201 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4202 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4203 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4204 internal
->p_align
= BYTE_GET (external
->p_align
);
4212 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4214 Elf64_External_Phdr
* phdrs
;
4215 Elf64_External_Phdr
* external
;
4216 Elf_Internal_Phdr
* internal
;
4218 unsigned int size
= elf_header
.e_phentsize
;
4219 unsigned int num
= elf_header
.e_phnum
;
4221 /* PR binutils/17531: Cope with unexpected section header sizes. */
4222 if (size
== 0 || num
== 0)
4224 if (size
< sizeof * phdrs
)
4226 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4229 if (size
> sizeof * phdrs
)
4230 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4232 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4233 size
, num
, _("program headers"));
4237 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4238 i
< elf_header
.e_phnum
;
4239 i
++, internal
++, external
++)
4241 internal
->p_type
= BYTE_GET (external
->p_type
);
4242 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4243 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4244 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4245 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4246 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4247 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4248 internal
->p_align
= BYTE_GET (external
->p_align
);
4255 /* Returns 1 if the program headers were read into `program_headers'. */
4258 get_program_headers (FILE * file
)
4260 Elf_Internal_Phdr
* phdrs
;
4262 /* Check cache of prior read. */
4263 if (program_headers
!= NULL
)
4266 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4267 sizeof (Elf_Internal_Phdr
));
4271 error (_("Out of memory\n"));
4276 ? get_32bit_program_headers (file
, phdrs
)
4277 : get_64bit_program_headers (file
, phdrs
))
4279 program_headers
= phdrs
;
4287 /* Returns 1 if the program headers were loaded. */
4290 process_program_headers (FILE * file
)
4292 Elf_Internal_Phdr
* segment
;
4295 if (elf_header
.e_phnum
== 0)
4297 /* PR binutils/12467. */
4298 if (elf_header
.e_phoff
!= 0)
4299 warn (_("possibly corrupt ELF header - it has a non-zero program"
4300 " header offset, but no program headers"));
4301 else if (do_segments
)
4302 printf (_("\nThere are no program headers in this file.\n"));
4306 if (do_segments
&& !do_header
)
4308 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4309 printf (_("Entry point "));
4310 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4311 printf (_("\nThere are %d program headers, starting at offset "),
4312 elf_header
.e_phnum
);
4313 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4317 if (! get_program_headers (file
))
4322 if (elf_header
.e_phnum
> 1)
4323 printf (_("\nProgram Headers:\n"));
4325 printf (_("\nProgram Headers:\n"));
4329 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4332 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4336 (_(" Type Offset VirtAddr PhysAddr\n"));
4338 (_(" FileSiz MemSiz Flags Align\n"));
4345 for (i
= 0, segment
= program_headers
;
4346 i
< elf_header
.e_phnum
;
4351 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4355 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4356 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4357 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4358 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4359 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4361 (segment
->p_flags
& PF_R
? 'R' : ' '),
4362 (segment
->p_flags
& PF_W
? 'W' : ' '),
4363 (segment
->p_flags
& PF_X
? 'E' : ' '));
4364 printf ("%#lx", (unsigned long) segment
->p_align
);
4368 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4369 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4372 print_vma (segment
->p_offset
, FULL_HEX
);
4376 print_vma (segment
->p_vaddr
, FULL_HEX
);
4378 print_vma (segment
->p_paddr
, FULL_HEX
);
4381 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4382 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4385 print_vma (segment
->p_filesz
, FULL_HEX
);
4389 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4390 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4393 print_vma (segment
->p_memsz
, FULL_HEX
);
4397 (segment
->p_flags
& PF_R
? 'R' : ' '),
4398 (segment
->p_flags
& PF_W
? 'W' : ' '),
4399 (segment
->p_flags
& PF_X
? 'E' : ' '));
4401 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4402 printf ("%#lx", (unsigned long) segment
->p_align
);
4405 print_vma (segment
->p_align
, PREFIX_HEX
);
4410 print_vma (segment
->p_offset
, FULL_HEX
);
4412 print_vma (segment
->p_vaddr
, FULL_HEX
);
4414 print_vma (segment
->p_paddr
, FULL_HEX
);
4416 print_vma (segment
->p_filesz
, FULL_HEX
);
4418 print_vma (segment
->p_memsz
, FULL_HEX
);
4420 (segment
->p_flags
& PF_R
? 'R' : ' '),
4421 (segment
->p_flags
& PF_W
? 'W' : ' '),
4422 (segment
->p_flags
& PF_X
? 'E' : ' '));
4423 print_vma (segment
->p_align
, HEX
);
4428 putc ('\n', stdout
);
4430 switch (segment
->p_type
)
4434 error (_("more than one dynamic segment\n"));
4436 /* By default, assume that the .dynamic section is the first
4437 section in the DYNAMIC segment. */
4438 dynamic_addr
= segment
->p_offset
;
4439 dynamic_size
= segment
->p_filesz
;
4440 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4441 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4443 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4444 dynamic_addr
= dynamic_size
= 0;
4447 /* Try to locate the .dynamic section. If there is
4448 a section header table, we can easily locate it. */
4449 if (section_headers
!= NULL
)
4451 Elf_Internal_Shdr
* sec
;
4453 sec
= find_section (".dynamic");
4454 if (sec
== NULL
|| sec
->sh_size
== 0)
4456 /* A corresponding .dynamic section is expected, but on
4457 IA-64/OpenVMS it is OK for it to be missing. */
4458 if (!is_ia64_vms ())
4459 error (_("no .dynamic section in the dynamic segment\n"));
4463 if (sec
->sh_type
== SHT_NOBITS
)
4469 dynamic_addr
= sec
->sh_offset
;
4470 dynamic_size
= sec
->sh_size
;
4472 if (dynamic_addr
< segment
->p_offset
4473 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4474 warn (_("the .dynamic section is not contained"
4475 " within the dynamic segment\n"));
4476 else if (dynamic_addr
> segment
->p_offset
)
4477 warn (_("the .dynamic section is not the first section"
4478 " in the dynamic segment.\n"));
4483 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4485 error (_("Unable to find program interpreter name\n"));
4489 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4491 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4492 error (_("Internal error: failed to create format string to display program interpreter\n"));
4494 program_interpreter
[0] = 0;
4495 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4496 error (_("Unable to read program interpreter name\n"));
4499 printf (_(" [Requesting program interpreter: %s]\n"),
4500 program_interpreter
);
4506 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4508 printf (_("\n Section to Segment mapping:\n"));
4509 printf (_(" Segment Sections...\n"));
4511 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4514 Elf_Internal_Shdr
* section
;
4516 segment
= program_headers
+ i
;
4517 section
= section_headers
+ 1;
4519 printf (" %2.2d ", i
);
4521 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4523 if (!ELF_TBSS_SPECIAL (section
, segment
)
4524 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4525 printf ("%s ", printable_section_name (section
));
4536 /* Find the file offset corresponding to VMA by using the program headers. */
4539 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4541 Elf_Internal_Phdr
* seg
;
4543 if (! get_program_headers (file
))
4545 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4549 for (seg
= program_headers
;
4550 seg
< program_headers
+ elf_header
.e_phnum
;
4553 if (seg
->p_type
!= PT_LOAD
)
4556 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4557 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4558 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4561 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4562 (unsigned long) vma
);
4567 /* Allocate memory and load the sections headers into the global pointer
4568 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4569 generate any error messages if the load fails. */
4572 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4574 Elf32_External_Shdr
* shdrs
;
4575 Elf_Internal_Shdr
* internal
;
4577 unsigned int size
= elf_header
.e_shentsize
;
4578 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4580 /* PR binutils/17531: Cope with unexpected section header sizes. */
4581 if (size
== 0 || num
== 0)
4583 if (size
< sizeof * shdrs
)
4586 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4589 if (!probe
&& size
> sizeof * shdrs
)
4590 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4592 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4594 probe
? NULL
: _("section headers"));
4598 if (section_headers
!= NULL
)
4599 free (section_headers
);
4600 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4601 sizeof (Elf_Internal_Shdr
));
4602 if (section_headers
== NULL
)
4605 error (_("Out of memory\n"));
4609 for (i
= 0, internal
= section_headers
;
4613 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4614 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4615 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4616 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4617 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4618 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4619 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4620 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4621 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4622 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4630 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4632 Elf64_External_Shdr
* shdrs
;
4633 Elf_Internal_Shdr
* internal
;
4635 unsigned int size
= elf_header
.e_shentsize
;
4636 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4638 /* PR binutils/17531: Cope with unexpected section header sizes. */
4639 if (size
== 0 || num
== 0)
4641 if (size
< sizeof * shdrs
)
4644 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4647 if (! probe
&& size
> sizeof * shdrs
)
4648 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4650 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4652 probe
? NULL
: _("section headers"));
4656 if (section_headers
!= NULL
)
4657 free (section_headers
);
4658 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4659 sizeof (Elf_Internal_Shdr
));
4660 if (section_headers
== NULL
)
4663 error (_("Out of memory\n"));
4667 for (i
= 0, internal
= section_headers
;
4671 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4672 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4673 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4674 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4675 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4676 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4677 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4678 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4679 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4680 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4687 static Elf_Internal_Sym
*
4688 get_32bit_elf_symbols (FILE * file
,
4689 Elf_Internal_Shdr
* section
,
4690 unsigned long * num_syms_return
)
4692 unsigned long number
= 0;
4693 Elf32_External_Sym
* esyms
= NULL
;
4694 Elf_External_Sym_Shndx
* shndx
= NULL
;
4695 Elf_Internal_Sym
* isyms
= NULL
;
4696 Elf_Internal_Sym
* psym
;
4699 /* Run some sanity checks first. */
4700 if (section
->sh_entsize
== 0)
4702 error (_("sh_entsize is zero\n"));
4706 if (section
->sh_size
> current_file_size
)
4708 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4709 printable_section_name (section
), (unsigned long) section
->sh_size
);
4713 number
= section
->sh_size
/ section
->sh_entsize
;
4715 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4717 error (_("Invalid sh_entsize\n"));
4721 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4722 section
->sh_size
, _("symbols"));
4727 if (symtab_shndx_hdr
!= NULL
4728 && (symtab_shndx_hdr
->sh_link
4729 == (unsigned long) (section
- section_headers
)))
4731 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4732 symtab_shndx_hdr
->sh_offset
,
4733 1, symtab_shndx_hdr
->sh_size
,
4734 _("symbol table section indicies"));
4739 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4743 error (_("Out of memory\n"));
4747 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4749 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4750 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4751 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4752 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4753 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4755 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4756 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4757 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4758 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4759 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4768 if (num_syms_return
!= NULL
)
4769 * num_syms_return
= isyms
== NULL
? 0 : number
;
4774 static Elf_Internal_Sym
*
4775 get_64bit_elf_symbols (FILE * file
,
4776 Elf_Internal_Shdr
* section
,
4777 unsigned long * num_syms_return
)
4779 unsigned long number
= 0;
4780 Elf64_External_Sym
* esyms
= NULL
;
4781 Elf_External_Sym_Shndx
* shndx
= NULL
;
4782 Elf_Internal_Sym
* isyms
= NULL
;
4783 Elf_Internal_Sym
* psym
;
4786 /* Run some sanity checks first. */
4787 if (section
->sh_entsize
== 0)
4789 error (_("sh_entsize is zero\n"));
4793 if (section
->sh_size
> current_file_size
)
4795 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4796 printable_section_name (section
), (unsigned long) section
->sh_size
);
4800 number
= section
->sh_size
/ section
->sh_entsize
;
4802 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4804 error (_("Invalid sh_entsize\n"));
4808 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4809 section
->sh_size
, _("symbols"));
4813 if (symtab_shndx_hdr
!= NULL
4814 && (symtab_shndx_hdr
->sh_link
4815 == (unsigned long) (section
- section_headers
)))
4817 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4818 symtab_shndx_hdr
->sh_offset
,
4819 1, symtab_shndx_hdr
->sh_size
,
4820 _("symbol table section indicies"));
4825 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4829 error (_("Out of memory\n"));
4833 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4835 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4836 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4837 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4838 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4840 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4842 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4843 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4844 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4846 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4847 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4856 if (num_syms_return
!= NULL
)
4857 * num_syms_return
= isyms
== NULL
? 0 : number
;
4863 get_elf_section_flags (bfd_vma sh_flags
)
4865 static char buff
[1024];
4867 int field_size
= is_32bit_elf
? 8 : 16;
4869 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4870 bfd_vma os_flags
= 0;
4871 bfd_vma proc_flags
= 0;
4872 bfd_vma unknown_flags
= 0;
4880 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4881 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4882 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4883 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4884 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4885 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4886 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4887 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4888 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4889 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4890 /* IA-64 specific. */
4891 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4892 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4893 /* IA-64 OpenVMS specific. */
4894 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4895 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4896 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4897 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4898 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4899 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4901 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4902 /* SPARC specific. */
4903 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4906 if (do_section_details
)
4908 sprintf (buff
, "[%*.*lx]: ",
4909 field_size
, field_size
, (unsigned long) sh_flags
);
4910 p
+= field_size
+ 4;
4917 flag
= sh_flags
& - sh_flags
;
4920 if (do_section_details
)
4924 case SHF_WRITE
: sindex
= 0; break;
4925 case SHF_ALLOC
: sindex
= 1; break;
4926 case SHF_EXECINSTR
: sindex
= 2; break;
4927 case SHF_MERGE
: sindex
= 3; break;
4928 case SHF_STRINGS
: sindex
= 4; break;
4929 case SHF_INFO_LINK
: sindex
= 5; break;
4930 case SHF_LINK_ORDER
: sindex
= 6; break;
4931 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4932 case SHF_GROUP
: sindex
= 8; break;
4933 case SHF_TLS
: sindex
= 9; break;
4934 case SHF_EXCLUDE
: sindex
= 18; break;
4938 switch (elf_header
.e_machine
)
4941 if (flag
== SHF_IA_64_SHORT
)
4943 else if (flag
== SHF_IA_64_NORECOV
)
4946 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4949 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4950 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4951 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4952 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4953 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4954 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4965 case EM_OLD_SPARCV9
:
4966 case EM_SPARC32PLUS
:
4969 if (flag
== SHF_ORDERED
)
4979 if (p
!= buff
+ field_size
+ 4)
4981 if (size
< (10 + 2))
4988 size
-= flags
[sindex
].len
;
4989 p
= stpcpy (p
, flags
[sindex
].str
);
4991 else if (flag
& SHF_MASKOS
)
4993 else if (flag
& SHF_MASKPROC
)
4996 unknown_flags
|= flag
;
5002 case SHF_WRITE
: *p
= 'W'; break;
5003 case SHF_ALLOC
: *p
= 'A'; break;
5004 case SHF_EXECINSTR
: *p
= 'X'; break;
5005 case SHF_MERGE
: *p
= 'M'; break;
5006 case SHF_STRINGS
: *p
= 'S'; break;
5007 case SHF_INFO_LINK
: *p
= 'I'; break;
5008 case SHF_LINK_ORDER
: *p
= 'L'; break;
5009 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5010 case SHF_GROUP
: *p
= 'G'; break;
5011 case SHF_TLS
: *p
= 'T'; break;
5012 case SHF_EXCLUDE
: *p
= 'E'; break;
5015 if ((elf_header
.e_machine
== EM_X86_64
5016 || elf_header
.e_machine
== EM_L1OM
5017 || elf_header
.e_machine
== EM_K1OM
)
5018 && flag
== SHF_X86_64_LARGE
)
5020 else if (flag
& SHF_MASKOS
)
5023 sh_flags
&= ~ SHF_MASKOS
;
5025 else if (flag
& SHF_MASKPROC
)
5028 sh_flags
&= ~ SHF_MASKPROC
;
5038 if (do_section_details
)
5042 size
-= 5 + field_size
;
5043 if (p
!= buff
+ field_size
+ 4)
5051 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5052 (unsigned long) os_flags
);
5053 p
+= 5 + field_size
;
5057 size
-= 7 + field_size
;
5058 if (p
!= buff
+ field_size
+ 4)
5066 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5067 (unsigned long) proc_flags
);
5068 p
+= 7 + field_size
;
5072 size
-= 10 + field_size
;
5073 if (p
!= buff
+ field_size
+ 4)
5081 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5082 (unsigned long) unknown_flags
);
5083 p
+= 10 + field_size
;
5092 process_section_headers (FILE * file
)
5094 Elf_Internal_Shdr
* section
;
5097 section_headers
= NULL
;
5099 if (elf_header
.e_shnum
== 0)
5101 /* PR binutils/12467. */
5102 if (elf_header
.e_shoff
!= 0)
5103 warn (_("possibly corrupt ELF file header - it has a non-zero"
5104 " section header offset, but no section headers\n"));
5105 else if (do_sections
)
5106 printf (_("\nThere are no sections in this file.\n"));
5111 if (do_sections
&& !do_header
)
5112 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5113 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5117 if (! get_32bit_section_headers (file
, FALSE
))
5120 else if (! get_64bit_section_headers (file
, FALSE
))
5123 /* Read in the string table, so that we have names to display. */
5124 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5125 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5127 section
= section_headers
+ elf_header
.e_shstrndx
;
5129 if (section
->sh_size
!= 0)
5131 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5132 1, section
->sh_size
,
5135 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5139 /* Scan the sections for the dynamic symbol table
5140 and dynamic string table and debug sections. */
5141 dynamic_symbols
= NULL
;
5142 dynamic_strings
= NULL
;
5143 dynamic_syminfo
= NULL
;
5144 symtab_shndx_hdr
= NULL
;
5146 eh_addr_size
= is_32bit_elf
? 4 : 8;
5147 switch (elf_header
.e_machine
)
5150 case EM_MIPS_RS3_LE
:
5151 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5152 FDE addresses. However, the ABI also has a semi-official ILP32
5153 variant for which the normal FDE address size rules apply.
5155 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5156 section, where XX is the size of longs in bits. Unfortunately,
5157 earlier compilers provided no way of distinguishing ILP32 objects
5158 from LP64 objects, so if there's any doubt, we should assume that
5159 the official LP64 form is being used. */
5160 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5161 && find_section (".gcc_compiled_long32") == NULL
)
5167 switch (elf_header
.e_flags
& EF_H8_MACH
)
5169 case E_H8_MACH_H8300
:
5170 case E_H8_MACH_H8300HN
:
5171 case E_H8_MACH_H8300SN
:
5172 case E_H8_MACH_H8300SXN
:
5175 case E_H8_MACH_H8300H
:
5176 case E_H8_MACH_H8300S
:
5177 case E_H8_MACH_H8300SX
:
5185 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5187 case EF_M32C_CPU_M16C
:
5194 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5197 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5198 if (section->sh_entsize != expected_entsize) \
5201 sprintf_vma (buf, section->sh_entsize); \
5202 /* Note: coded this way so that there is a single string for \
5204 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5205 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5206 (unsigned) expected_entsize); \
5207 section->sh_entsize = expected_entsize; \
5212 #define CHECK_ENTSIZE(section, i, type) \
5213 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5214 sizeof (Elf64_External_##type))
5216 for (i
= 0, section
= section_headers
;
5217 i
< elf_header
.e_shnum
;
5220 char * name
= SECTION_NAME (section
);
5222 if (section
->sh_type
== SHT_DYNSYM
)
5224 if (dynamic_symbols
!= NULL
)
5226 error (_("File contains multiple dynamic symbol tables\n"));
5230 CHECK_ENTSIZE (section
, i
, Sym
);
5231 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5233 else if (section
->sh_type
== SHT_STRTAB
5234 && streq (name
, ".dynstr"))
5236 if (dynamic_strings
!= NULL
)
5238 error (_("File contains multiple dynamic string tables\n"));
5242 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5243 1, section
->sh_size
,
5244 _("dynamic strings"));
5245 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5247 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5249 if (symtab_shndx_hdr
!= NULL
)
5251 error (_("File contains multiple symtab shndx tables\n"));
5254 symtab_shndx_hdr
= section
;
5256 else if (section
->sh_type
== SHT_SYMTAB
)
5257 CHECK_ENTSIZE (section
, i
, Sym
);
5258 else if (section
->sh_type
== SHT_GROUP
)
5259 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5260 else if (section
->sh_type
== SHT_REL
)
5261 CHECK_ENTSIZE (section
, i
, Rel
);
5262 else if (section
->sh_type
== SHT_RELA
)
5263 CHECK_ENTSIZE (section
, i
, Rela
);
5264 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5265 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5266 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5267 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5268 || do_debug_addr
|| do_debug_cu_index
)
5269 && (const_strneq (name
, ".debug_")
5270 || const_strneq (name
, ".zdebug_")))
5273 name
+= sizeof (".zdebug_") - 1;
5275 name
+= sizeof (".debug_") - 1;
5278 || (do_debug_info
&& const_strneq (name
, "info"))
5279 || (do_debug_info
&& const_strneq (name
, "types"))
5280 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5281 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5282 || (do_debug_lines
&& const_strneq (name
, "line."))
5283 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5284 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5285 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5286 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5287 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5288 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5289 || (do_debug_frames
&& const_strneq (name
, "frame"))
5290 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5291 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5292 || (do_debug_str
&& const_strneq (name
, "str"))
5293 || (do_debug_loc
&& const_strneq (name
, "loc"))
5294 || (do_debug_addr
&& const_strneq (name
, "addr"))
5295 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5296 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5298 request_dump_bynumber (i
, DEBUG_DUMP
);
5300 /* Linkonce section to be combined with .debug_info at link time. */
5301 else if ((do_debugging
|| do_debug_info
)
5302 && const_strneq (name
, ".gnu.linkonce.wi."))
5303 request_dump_bynumber (i
, DEBUG_DUMP
);
5304 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5305 request_dump_bynumber (i
, DEBUG_DUMP
);
5306 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5307 request_dump_bynumber (i
, DEBUG_DUMP
);
5308 /* Trace sections for Itanium VMS. */
5309 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5310 || do_trace_aranges
)
5311 && const_strneq (name
, ".trace_"))
5313 name
+= sizeof (".trace_") - 1;
5316 || (do_trace_info
&& streq (name
, "info"))
5317 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5318 || (do_trace_aranges
&& streq (name
, "aranges"))
5320 request_dump_bynumber (i
, DEBUG_DUMP
);
5327 if (elf_header
.e_shnum
> 1)
5328 printf (_("\nSection Headers:\n"));
5330 printf (_("\nSection Header:\n"));
5334 if (do_section_details
)
5336 printf (_(" [Nr] Name\n"));
5337 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5341 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5345 if (do_section_details
)
5347 printf (_(" [Nr] Name\n"));
5348 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5352 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5356 if (do_section_details
)
5358 printf (_(" [Nr] Name\n"));
5359 printf (_(" Type Address Offset Link\n"));
5360 printf (_(" Size EntSize Info Align\n"));
5364 printf (_(" [Nr] Name Type Address Offset\n"));
5365 printf (_(" Size EntSize Flags Link Info Align\n"));
5369 if (do_section_details
)
5370 printf (_(" Flags\n"));
5372 for (i
= 0, section
= section_headers
;
5373 i
< elf_header
.e_shnum
;
5376 printf (" [%2u] ", i
);
5377 if (do_section_details
)
5378 printf ("%s\n ", printable_section_name (section
));
5380 print_symbol (-17, SECTION_NAME (section
));
5382 printf (do_wide
? " %-15s " : " %-15.15s ",
5383 get_section_type_name (section
->sh_type
));
5387 const char * link_too_big
= NULL
;
5389 print_vma (section
->sh_addr
, LONG_HEX
);
5391 printf ( " %6.6lx %6.6lx %2.2lx",
5392 (unsigned long) section
->sh_offset
,
5393 (unsigned long) section
->sh_size
,
5394 (unsigned long) section
->sh_entsize
);
5396 if (do_section_details
)
5397 fputs (" ", stdout
);
5399 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5401 if (section
->sh_link
>= elf_header
.e_shnum
)
5404 /* The sh_link value is out of range. Normally this indicates
5405 an error but it can have special values in Solaris binaries. */
5406 switch (elf_header
.e_machine
)
5413 case EM_OLD_SPARCV9
:
5414 case EM_SPARC32PLUS
:
5417 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5418 link_too_big
= "BEFORE";
5419 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5420 link_too_big
= "AFTER";
5427 if (do_section_details
)
5429 if (link_too_big
!= NULL
&& * link_too_big
)
5430 printf ("<%s> ", link_too_big
);
5432 printf ("%2u ", section
->sh_link
);
5433 printf ("%3u %2lu\n", section
->sh_info
,
5434 (unsigned long) section
->sh_addralign
);
5437 printf ("%2u %3u %2lu\n",
5440 (unsigned long) section
->sh_addralign
);
5442 if (link_too_big
&& ! * link_too_big
)
5443 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5444 i
, section
->sh_link
);
5448 print_vma (section
->sh_addr
, LONG_HEX
);
5450 if ((long) section
->sh_offset
== section
->sh_offset
)
5451 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5455 print_vma (section
->sh_offset
, LONG_HEX
);
5458 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5459 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5463 print_vma (section
->sh_size
, LONG_HEX
);
5466 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5467 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5471 print_vma (section
->sh_entsize
, LONG_HEX
);
5474 if (do_section_details
)
5475 fputs (" ", stdout
);
5477 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5479 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5481 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5482 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5485 print_vma (section
->sh_addralign
, DEC
);
5489 else if (do_section_details
)
5491 printf (" %-15.15s ",
5492 get_section_type_name (section
->sh_type
));
5493 print_vma (section
->sh_addr
, LONG_HEX
);
5494 if ((long) section
->sh_offset
== section
->sh_offset
)
5495 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5499 print_vma (section
->sh_offset
, LONG_HEX
);
5501 printf (" %u\n ", section
->sh_link
);
5502 print_vma (section
->sh_size
, LONG_HEX
);
5504 print_vma (section
->sh_entsize
, LONG_HEX
);
5506 printf (" %-16u %lu\n",
5508 (unsigned long) section
->sh_addralign
);
5513 print_vma (section
->sh_addr
, LONG_HEX
);
5514 if ((long) section
->sh_offset
== section
->sh_offset
)
5515 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5519 print_vma (section
->sh_offset
, LONG_HEX
);
5522 print_vma (section
->sh_size
, LONG_HEX
);
5524 print_vma (section
->sh_entsize
, LONG_HEX
);
5526 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5528 printf (" %2u %3u %lu\n",
5531 (unsigned long) section
->sh_addralign
);
5534 if (do_section_details
)
5535 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5538 if (!do_section_details
)
5540 if (elf_header
.e_machine
== EM_X86_64
5541 || elf_header
.e_machine
== EM_L1OM
5542 || elf_header
.e_machine
== EM_K1OM
)
5543 printf (_("Key to Flags:\n\
5544 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5545 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5546 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5548 printf (_("Key to Flags:\n\
5549 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5550 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5551 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5558 get_group_flags (unsigned int flags
)
5560 static char buff
[32];
5570 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5577 process_section_groups (FILE * file
)
5579 Elf_Internal_Shdr
* section
;
5581 struct group
* group
;
5582 Elf_Internal_Shdr
* symtab_sec
;
5583 Elf_Internal_Shdr
* strtab_sec
;
5584 Elf_Internal_Sym
* symtab
;
5585 unsigned long num_syms
;
5589 /* Don't process section groups unless needed. */
5590 if (!do_unwind
&& !do_section_groups
)
5593 if (elf_header
.e_shnum
== 0)
5595 if (do_section_groups
)
5596 printf (_("\nThere are no sections to group in this file.\n"));
5601 if (section_headers
== NULL
)
5603 error (_("Section headers are not available!\n"));
5604 /* PR 13622: This can happen with a corrupt ELF header. */
5608 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5609 sizeof (struct group
*));
5611 if (section_headers_groups
== NULL
)
5613 error (_("Out of memory\n"));
5617 /* Scan the sections for the group section. */
5619 for (i
= 0, section
= section_headers
;
5620 i
< elf_header
.e_shnum
;
5622 if (section
->sh_type
== SHT_GROUP
)
5625 if (group_count
== 0)
5627 if (do_section_groups
)
5628 printf (_("\nThere are no section groups in this file.\n"));
5633 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5635 if (section_groups
== NULL
)
5637 error (_("Out of memory\n"));
5647 for (i
= 0, section
= section_headers
, group
= section_groups
;
5648 i
< elf_header
.e_shnum
;
5651 if (section
->sh_type
== SHT_GROUP
)
5653 const char * name
= printable_section_name (section
);
5654 const char * group_name
;
5655 unsigned char * start
;
5656 unsigned char * indices
;
5657 unsigned int entry
, j
, size
;
5658 Elf_Internal_Shdr
* sec
;
5659 Elf_Internal_Sym
* sym
;
5661 /* Get the symbol table. */
5662 if (section
->sh_link
>= elf_header
.e_shnum
5663 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5666 error (_("Bad sh_link in group section `%s'\n"), name
);
5670 if (symtab_sec
!= sec
)
5675 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5680 error (_("Corrupt header in group section `%s'\n"), name
);
5684 if (section
->sh_info
>= num_syms
)
5686 error (_("Bad sh_info in group section `%s'\n"), name
);
5690 sym
= symtab
+ section
->sh_info
;
5692 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5694 if (sym
->st_shndx
== 0
5695 || sym
->st_shndx
>= elf_header
.e_shnum
)
5697 error (_("Bad sh_info in group section `%s'\n"), name
);
5701 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5710 /* Get the string table. */
5711 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5720 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5725 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5726 1, strtab_sec
->sh_size
,
5728 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5730 group_name
= sym
->st_name
< strtab_size
5731 ? strtab
+ sym
->st_name
: _("<corrupt>");
5734 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5735 1, section
->sh_size
,
5741 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5742 entry
= byte_get (indices
, 4);
5745 if (do_section_groups
)
5747 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5748 get_group_flags (entry
), i
, name
, group_name
, size
);
5750 printf (_(" [Index] Name\n"));
5753 group
->group_index
= i
;
5755 for (j
= 0; j
< size
; j
++)
5757 struct group_list
* g
;
5759 entry
= byte_get (indices
, 4);
5762 if (entry
>= elf_header
.e_shnum
)
5764 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5765 entry
, i
, elf_header
.e_shnum
- 1);
5769 if (section_headers_groups
[entry
] != NULL
)
5773 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5775 section_headers_groups
[entry
]->group_index
);
5780 /* Intel C/C++ compiler may put section 0 in a
5781 section group. We just warn it the first time
5782 and ignore it afterwards. */
5783 static int warned
= 0;
5786 error (_("section 0 in group section [%5u]\n"),
5787 section_headers_groups
[entry
]->group_index
);
5793 section_headers_groups
[entry
] = group
;
5795 if (do_section_groups
)
5797 sec
= section_headers
+ entry
;
5798 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
5801 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5802 g
->section_index
= entry
;
5803 g
->next
= group
->root
;
5821 /* Data used to display dynamic fixups. */
5823 struct ia64_vms_dynfixup
5825 bfd_vma needed_ident
; /* Library ident number. */
5826 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5827 bfd_vma fixup_needed
; /* Index of the library. */
5828 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5829 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5832 /* Data used to display dynamic relocations. */
5834 struct ia64_vms_dynimgrela
5836 bfd_vma img_rela_cnt
; /* Number of relocations. */
5837 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5840 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5844 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5845 const char *strtab
, unsigned int strtab_sz
)
5847 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5849 const char *lib_name
;
5851 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5852 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5853 _("dynamic section image fixups"));
5857 if (fixup
->needed
< strtab_sz
)
5858 lib_name
= strtab
+ fixup
->needed
;
5861 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5862 (unsigned long) fixup
->needed
);
5865 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5866 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5868 (_("Seg Offset Type SymVec DataType\n"));
5870 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5875 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5876 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5877 type
= BYTE_GET (imfs
[i
].type
);
5878 rtype
= elf_ia64_reloc_type (type
);
5880 printf (" 0x%08x ", type
);
5882 printf (" %-32s ", rtype
);
5883 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5884 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5890 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5893 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5895 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5898 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5899 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5900 _("dynamic section image relocations"));
5904 printf (_("\nImage relocs\n"));
5906 (_("Seg Offset Type Addend Seg Sym Off\n"));
5908 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5913 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5914 printf ("%08" BFD_VMA_FMT
"x ",
5915 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5916 type
= BYTE_GET (imrs
[i
].type
);
5917 rtype
= elf_ia64_reloc_type (type
);
5919 printf ("0x%08x ", type
);
5921 printf ("%-31s ", rtype
);
5922 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5923 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5924 printf ("%08" BFD_VMA_FMT
"x\n",
5925 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5931 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5934 process_ia64_vms_dynamic_relocs (FILE *file
)
5936 struct ia64_vms_dynfixup fixup
;
5937 struct ia64_vms_dynimgrela imgrela
;
5938 Elf_Internal_Dyn
*entry
;
5940 bfd_vma strtab_off
= 0;
5941 bfd_vma strtab_sz
= 0;
5942 char *strtab
= NULL
;
5944 memset (&fixup
, 0, sizeof (fixup
));
5945 memset (&imgrela
, 0, sizeof (imgrela
));
5947 /* Note: the order of the entries is specified by the OpenVMS specs. */
5948 for (entry
= dynamic_section
;
5949 entry
< dynamic_section
+ dynamic_nent
;
5952 switch (entry
->d_tag
)
5954 case DT_IA_64_VMS_STRTAB_OFFSET
:
5955 strtab_off
= entry
->d_un
.d_val
;
5958 strtab_sz
= entry
->d_un
.d_val
;
5960 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5961 1, strtab_sz
, _("dynamic string section"));
5964 case DT_IA_64_VMS_NEEDED_IDENT
:
5965 fixup
.needed_ident
= entry
->d_un
.d_val
;
5968 fixup
.needed
= entry
->d_un
.d_val
;
5970 case DT_IA_64_VMS_FIXUP_NEEDED
:
5971 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5973 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5974 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5976 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5977 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5979 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5982 case DT_IA_64_VMS_IMG_RELA_CNT
:
5983 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5985 case DT_IA_64_VMS_IMG_RELA_OFF
:
5986 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5988 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6008 } dynamic_relocations
[] =
6010 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6011 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6012 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6015 /* Process the reloc section. */
6018 process_relocs (FILE * file
)
6020 unsigned long rel_size
;
6021 unsigned long rel_offset
;
6027 if (do_using_dynamic
)
6031 int has_dynamic_reloc
;
6034 has_dynamic_reloc
= 0;
6036 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6038 is_rela
= dynamic_relocations
[i
].rela
;
6039 name
= dynamic_relocations
[i
].name
;
6040 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6041 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6043 has_dynamic_reloc
|= rel_size
;
6045 if (is_rela
== UNKNOWN
)
6047 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6048 switch (dynamic_info
[DT_PLTREL
])
6062 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6063 name
, rel_offset
, rel_size
);
6065 dump_relocations (file
,
6066 offset_from_vma (file
, rel_offset
, rel_size
),
6068 dynamic_symbols
, num_dynamic_syms
,
6069 dynamic_strings
, dynamic_strings_length
, is_rela
);
6074 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6076 if (! has_dynamic_reloc
)
6077 printf (_("\nThere are no dynamic relocations in this file.\n"));
6081 Elf_Internal_Shdr
* section
;
6085 for (i
= 0, section
= section_headers
;
6086 i
< elf_header
.e_shnum
;
6089 if ( section
->sh_type
!= SHT_RELA
6090 && section
->sh_type
!= SHT_REL
)
6093 rel_offset
= section
->sh_offset
;
6094 rel_size
= section
->sh_size
;
6098 Elf_Internal_Shdr
* strsec
;
6101 printf (_("\nRelocation section "));
6103 if (string_table
== NULL
)
6104 printf ("%d", section
->sh_name
);
6106 printf ("'%s'", printable_section_name (section
));
6108 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6109 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6111 is_rela
= section
->sh_type
== SHT_RELA
;
6113 if (section
->sh_link
!= 0
6114 && section
->sh_link
< elf_header
.e_shnum
)
6116 Elf_Internal_Shdr
* symsec
;
6117 Elf_Internal_Sym
* symtab
;
6118 unsigned long nsyms
;
6119 unsigned long strtablen
= 0;
6120 char * strtab
= NULL
;
6122 symsec
= section_headers
+ section
->sh_link
;
6123 if (symsec
->sh_type
!= SHT_SYMTAB
6124 && symsec
->sh_type
!= SHT_DYNSYM
)
6127 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6132 if (symsec
->sh_link
!= 0
6133 && symsec
->sh_link
< elf_header
.e_shnum
)
6135 strsec
= section_headers
+ symsec
->sh_link
;
6137 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6140 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6143 dump_relocations (file
, rel_offset
, rel_size
,
6144 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
6150 dump_relocations (file
, rel_offset
, rel_size
,
6151 NULL
, 0, NULL
, 0, is_rela
);
6158 printf (_("\nThere are no relocations in this file.\n"));
6164 /* Process the unwind section. */
6166 #include "unwind-ia64.h"
6168 /* An absolute address consists of a section and an offset. If the
6169 section is NULL, the offset itself is the address, otherwise, the
6170 address equals to LOAD_ADDRESS(section) + offset. */
6174 unsigned short section
;
6178 #define ABSADDR(a) \
6180 ? section_headers [(a).section].sh_addr + (a).offset \
6183 struct ia64_unw_table_entry
6185 struct absaddr start
;
6187 struct absaddr info
;
6190 struct ia64_unw_aux_info
6193 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6194 unsigned long table_len
; /* Length of unwind table. */
6195 unsigned char * info
; /* Unwind info. */
6196 unsigned long info_size
; /* Size of unwind info. */
6197 bfd_vma info_addr
; /* starting address of unwind info. */
6198 bfd_vma seg_base
; /* Starting address of segment. */
6199 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6200 unsigned long nsyms
; /* Number of symbols. */
6201 char * strtab
; /* The string table. */
6202 unsigned long strtab_size
; /* Size of string table. */
6206 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6207 unsigned long nsyms
,
6208 const char * strtab
,
6209 unsigned long strtab_size
,
6210 struct absaddr addr
,
6211 const char ** symname
,
6214 bfd_vma dist
= 0x100000;
6215 Elf_Internal_Sym
* sym
;
6216 Elf_Internal_Sym
* best
= NULL
;
6219 REMOVE_ARCH_BITS (addr
.offset
);
6221 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
6223 bfd_vma value
= sym
->st_value
;
6225 REMOVE_ARCH_BITS (value
);
6227 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
6228 && sym
->st_name
!= 0
6229 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6230 && addr
.offset
>= value
6231 && addr
.offset
- value
< dist
)
6234 dist
= addr
.offset
- value
;
6242 *symname
= (best
->st_name
>= strtab_size
6243 ? _("<corrupt>") : strtab
+ best
->st_name
);
6249 *offset
= addr
.offset
;
6253 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6255 struct ia64_unw_table_entry
* tp
;
6258 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6262 const unsigned char * dp
;
6263 const unsigned char * head
;
6264 const char * procname
;
6266 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6267 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6269 fputs ("\n<", stdout
);
6273 fputs (procname
, stdout
);
6276 printf ("+%lx", (unsigned long) offset
);
6279 fputs (">: [", stdout
);
6280 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6281 fputc ('-', stdout
);
6282 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6283 printf ("], info at +0x%lx\n",
6284 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6286 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6287 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6289 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6290 (unsigned) UNW_VER (stamp
),
6291 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6292 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6293 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6294 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6296 if (UNW_VER (stamp
) != 1)
6298 printf (_("\tUnknown version.\n"));
6303 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
6304 dp
= unw_decode (dp
, in_body
, & in_body
);
6309 slurp_ia64_unwind_table (FILE * file
,
6310 struct ia64_unw_aux_info
* aux
,
6311 Elf_Internal_Shdr
* sec
)
6313 unsigned long size
, nrelas
, i
;
6314 Elf_Internal_Phdr
* seg
;
6315 struct ia64_unw_table_entry
* tep
;
6316 Elf_Internal_Shdr
* relsec
;
6317 Elf_Internal_Rela
* rela
;
6318 Elf_Internal_Rela
* rp
;
6319 unsigned char * table
;
6321 Elf_Internal_Sym
* sym
;
6322 const char * relname
;
6324 /* First, find the starting address of the segment that includes
6327 if (elf_header
.e_phnum
)
6329 if (! get_program_headers (file
))
6332 for (seg
= program_headers
;
6333 seg
< program_headers
+ elf_header
.e_phnum
;
6336 if (seg
->p_type
!= PT_LOAD
)
6339 if (sec
->sh_addr
>= seg
->p_vaddr
6340 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6342 aux
->seg_base
= seg
->p_vaddr
;
6348 /* Second, build the unwind table from the contents of the unwind section: */
6349 size
= sec
->sh_size
;
6350 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6355 aux
->table
= (struct ia64_unw_table_entry
*)
6356 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
6358 for (tp
= table
; tp
< table
+ size
; ++tep
)
6360 tep
->start
.section
= SHN_UNDEF
;
6361 tep
->end
.section
= SHN_UNDEF
;
6362 tep
->info
.section
= SHN_UNDEF
;
6363 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6364 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6365 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6366 tep
->start
.offset
+= aux
->seg_base
;
6367 tep
->end
.offset
+= aux
->seg_base
;
6368 tep
->info
.offset
+= aux
->seg_base
;
6372 /* Third, apply any relocations to the unwind table: */
6373 for (relsec
= section_headers
;
6374 relsec
< section_headers
+ elf_header
.e_shnum
;
6377 if (relsec
->sh_type
!= SHT_RELA
6378 || relsec
->sh_info
>= elf_header
.e_shnum
6379 || section_headers
+ relsec
->sh_info
!= sec
)
6382 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6386 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6388 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6389 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6391 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6393 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6397 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6399 switch (rp
->r_offset
/eh_addr_size
% 3)
6402 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6403 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6406 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6407 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6410 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6411 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6421 aux
->table_len
= size
/ (3 * eh_addr_size
);
6426 ia64_process_unwind (FILE * file
)
6428 Elf_Internal_Shdr
* sec
;
6429 Elf_Internal_Shdr
* unwsec
= NULL
;
6430 Elf_Internal_Shdr
* strsec
;
6431 unsigned long i
, unwcount
= 0, unwstart
= 0;
6432 struct ia64_unw_aux_info aux
;
6434 memset (& aux
, 0, sizeof (aux
));
6436 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6438 if (sec
->sh_type
== SHT_SYMTAB
6439 && sec
->sh_link
< elf_header
.e_shnum
)
6441 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6443 strsec
= section_headers
+ sec
->sh_link
;
6444 assert (aux
.strtab
== NULL
);
6445 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6448 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6450 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6455 printf (_("\nThere are no unwind sections in this file.\n"));
6457 while (unwcount
-- > 0)
6462 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
6463 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6464 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6471 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6473 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6475 /* We need to find which section group it is in. */
6476 struct group_list
* g
= section_headers_groups
[i
]->root
;
6478 for (; g
!= NULL
; g
= g
->next
)
6480 sec
= section_headers
+ g
->section_index
;
6482 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6487 i
= elf_header
.e_shnum
;
6489 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6491 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6492 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6493 suffix
= SECTION_NAME (unwsec
) + len
;
6494 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6496 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6497 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6502 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6503 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6504 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6505 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6507 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6508 suffix
= SECTION_NAME (unwsec
) + len
;
6509 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6511 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6512 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6516 if (i
== elf_header
.e_shnum
)
6518 printf (_("\nCould not find unwind info section for "));
6520 if (string_table
== NULL
)
6521 printf ("%d", unwsec
->sh_name
);
6523 printf ("'%s'", printable_section_name (unwsec
));
6527 aux
.info_addr
= sec
->sh_addr
;
6528 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6531 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6533 printf (_("\nUnwind section "));
6535 if (string_table
== NULL
)
6536 printf ("%d", unwsec
->sh_name
);
6538 printf ("'%s'", printable_section_name (unwsec
));
6540 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6541 (unsigned long) unwsec
->sh_offset
,
6542 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6544 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6546 if (aux
.table_len
> 0)
6547 dump_ia64_unwind (& aux
);
6550 free ((char *) aux
.table
);
6552 free ((char *) aux
.info
);
6561 free ((char *) aux
.strtab
);
6564 struct hppa_unw_table_entry
6566 struct absaddr start
;
6568 unsigned int Cannot_unwind
:1; /* 0 */
6569 unsigned int Millicode
:1; /* 1 */
6570 unsigned int Millicode_save_sr0
:1; /* 2 */
6571 unsigned int Region_description
:2; /* 3..4 */
6572 unsigned int reserved1
:1; /* 5 */
6573 unsigned int Entry_SR
:1; /* 6 */
6574 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6575 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6576 unsigned int Args_stored
:1; /* 16 */
6577 unsigned int Variable_Frame
:1; /* 17 */
6578 unsigned int Separate_Package_Body
:1; /* 18 */
6579 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6580 unsigned int Stack_Overflow_Check
:1; /* 20 */
6581 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6582 unsigned int Ada_Region
:1; /* 22 */
6583 unsigned int cxx_info
:1; /* 23 */
6584 unsigned int cxx_try_catch
:1; /* 24 */
6585 unsigned int sched_entry_seq
:1; /* 25 */
6586 unsigned int reserved2
:1; /* 26 */
6587 unsigned int Save_SP
:1; /* 27 */
6588 unsigned int Save_RP
:1; /* 28 */
6589 unsigned int Save_MRP_in_frame
:1; /* 29 */
6590 unsigned int extn_ptr_defined
:1; /* 30 */
6591 unsigned int Cleanup_defined
:1; /* 31 */
6593 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6594 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6595 unsigned int Large_frame
:1; /* 2 */
6596 unsigned int Pseudo_SP_Set
:1; /* 3 */
6597 unsigned int reserved4
:1; /* 4 */
6598 unsigned int Total_frame_size
:27; /* 5..31 */
6601 struct hppa_unw_aux_info
6603 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6604 unsigned long table_len
; /* Length of unwind table. */
6605 bfd_vma seg_base
; /* Starting address of segment. */
6606 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6607 unsigned long nsyms
; /* Number of symbols. */
6608 char * strtab
; /* The string table. */
6609 unsigned long strtab_size
; /* Size of string table. */
6613 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6615 struct hppa_unw_table_entry
* tp
;
6617 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6620 const char * procname
;
6622 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6623 aux
->strtab_size
, tp
->start
, &procname
,
6626 fputs ("\n<", stdout
);
6630 fputs (procname
, stdout
);
6633 printf ("+%lx", (unsigned long) offset
);
6636 fputs (">: [", stdout
);
6637 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6638 fputc ('-', stdout
);
6639 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6642 #define PF(_m) if (tp->_m) printf (#_m " ");
6643 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6646 PF(Millicode_save_sr0
);
6647 /* PV(Region_description); */
6653 PF(Separate_Package_Body
);
6654 PF(Frame_Extension_Millicode
);
6655 PF(Stack_Overflow_Check
);
6656 PF(Two_Instruction_SP_Increment
);
6660 PF(sched_entry_seq
);
6663 PF(Save_MRP_in_frame
);
6664 PF(extn_ptr_defined
);
6665 PF(Cleanup_defined
);
6666 PF(MPE_XL_interrupt_marker
);
6667 PF(HP_UX_interrupt_marker
);
6670 PV(Total_frame_size
);
6679 slurp_hppa_unwind_table (FILE * file
,
6680 struct hppa_unw_aux_info
* aux
,
6681 Elf_Internal_Shdr
* sec
)
6683 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6684 Elf_Internal_Phdr
* seg
;
6685 struct hppa_unw_table_entry
* tep
;
6686 Elf_Internal_Shdr
* relsec
;
6687 Elf_Internal_Rela
* rela
;
6688 Elf_Internal_Rela
* rp
;
6689 unsigned char * table
;
6691 Elf_Internal_Sym
* sym
;
6692 const char * relname
;
6694 /* First, find the starting address of the segment that includes
6697 if (elf_header
.e_phnum
)
6699 if (! get_program_headers (file
))
6702 for (seg
= program_headers
;
6703 seg
< program_headers
+ elf_header
.e_phnum
;
6706 if (seg
->p_type
!= PT_LOAD
)
6709 if (sec
->sh_addr
>= seg
->p_vaddr
6710 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6712 aux
->seg_base
= seg
->p_vaddr
;
6718 /* Second, build the unwind table from the contents of the unwind
6720 size
= sec
->sh_size
;
6721 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6727 nentries
= size
/ unw_ent_size
;
6728 size
= unw_ent_size
* nentries
;
6730 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6731 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6733 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6735 unsigned int tmp1
, tmp2
;
6737 tep
->start
.section
= SHN_UNDEF
;
6738 tep
->end
.section
= SHN_UNDEF
;
6740 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6741 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6742 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6743 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6745 tep
->start
.offset
+= aux
->seg_base
;
6746 tep
->end
.offset
+= aux
->seg_base
;
6748 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6749 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6750 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6751 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6752 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6753 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6754 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6755 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6756 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6757 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6758 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6759 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6760 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6761 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6762 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6763 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6764 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6765 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6766 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6767 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6768 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6769 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6770 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6771 tep
->Cleanup_defined
= tmp1
& 0x1;
6773 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6774 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6775 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6776 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6777 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6778 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6782 /* Third, apply any relocations to the unwind table. */
6783 for (relsec
= section_headers
;
6784 relsec
< section_headers
+ elf_header
.e_shnum
;
6787 if (relsec
->sh_type
!= SHT_RELA
6788 || relsec
->sh_info
>= elf_header
.e_shnum
6789 || section_headers
+ relsec
->sh_info
!= sec
)
6792 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6796 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6798 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6799 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6801 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6802 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6804 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6808 i
= rp
->r_offset
/ unw_ent_size
;
6810 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6813 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6814 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6817 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6818 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6828 aux
->table_len
= nentries
;
6834 hppa_process_unwind (FILE * file
)
6836 struct hppa_unw_aux_info aux
;
6837 Elf_Internal_Shdr
* unwsec
= NULL
;
6838 Elf_Internal_Shdr
* strsec
;
6839 Elf_Internal_Shdr
* sec
;
6842 if (string_table
== NULL
)
6845 memset (& aux
, 0, sizeof (aux
));
6847 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6849 if (sec
->sh_type
== SHT_SYMTAB
6850 && sec
->sh_link
< elf_header
.e_shnum
)
6852 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6854 strsec
= section_headers
+ sec
->sh_link
;
6855 assert (aux
.strtab
== NULL
);
6856 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6859 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6861 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6866 printf (_("\nThere are no unwind sections in this file.\n"));
6868 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6870 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6872 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
6873 printable_section_name (sec
),
6874 (unsigned long) sec
->sh_offset
,
6875 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6877 slurp_hppa_unwind_table (file
, &aux
, sec
);
6878 if (aux
.table_len
> 0)
6879 dump_hppa_unwind (&aux
);
6882 free ((char *) aux
.table
);
6890 free ((char *) aux
.strtab
);
6895 unsigned char * data
; /* The unwind data. */
6896 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6897 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6898 unsigned long nrelas
; /* The number of relocations. */
6899 unsigned int rel_type
; /* REL or RELA ? */
6900 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6903 struct arm_unw_aux_info
6905 FILE * file
; /* The file containing the unwind sections. */
6906 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6907 unsigned long nsyms
; /* Number of symbols. */
6908 char * strtab
; /* The file's string table. */
6909 unsigned long strtab_size
; /* Size of string table. */
6913 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6914 bfd_vma fn
, struct absaddr addr
)
6916 const char *procname
;
6919 if (addr
.section
== SHN_UNDEF
)
6922 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6923 aux
->strtab_size
, addr
, &procname
,
6926 print_vma (fn
, PREFIX_HEX
);
6930 fputs (" <", stdout
);
6931 fputs (procname
, stdout
);
6934 printf ("+0x%lx", (unsigned long) sym_offset
);
6935 fputc ('>', stdout
);
6942 arm_free_section (struct arm_section
*arm_sec
)
6944 if (arm_sec
->data
!= NULL
)
6945 free (arm_sec
->data
);
6947 if (arm_sec
->rela
!= NULL
)
6948 free (arm_sec
->rela
);
6951 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6952 cached section and install SEC instead.
6953 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6954 and return its valued in * WORDP, relocating if necessary.
6955 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6956 relocation's offset in ADDR.
6957 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6958 into the string table of the symbol associated with the reloc. If no
6959 reloc was applied store -1 there.
6960 5) Return TRUE upon success, FALSE otherwise. */
6963 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6964 struct arm_section
* arm_sec
,
6965 Elf_Internal_Shdr
* sec
,
6966 bfd_vma word_offset
,
6967 unsigned int * wordp
,
6968 struct absaddr
* addr
,
6971 Elf_Internal_Rela
*rp
;
6972 Elf_Internal_Sym
*sym
;
6973 const char * relname
;
6975 bfd_boolean wrapped
;
6977 if (sec
== NULL
|| arm_sec
== NULL
)
6980 addr
->section
= SHN_UNDEF
;
6983 if (sym_name
!= NULL
)
6984 *sym_name
= (bfd_vma
) -1;
6986 /* If necessary, update the section cache. */
6987 if (sec
!= arm_sec
->sec
)
6989 Elf_Internal_Shdr
*relsec
;
6991 arm_free_section (arm_sec
);
6994 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6995 sec
->sh_size
, _("unwind data"));
6996 arm_sec
->rela
= NULL
;
6997 arm_sec
->nrelas
= 0;
6999 for (relsec
= section_headers
;
7000 relsec
< section_headers
+ elf_header
.e_shnum
;
7003 if (relsec
->sh_info
>= elf_header
.e_shnum
7004 || section_headers
+ relsec
->sh_info
!= sec
7005 /* PR 15745: Check the section type as well. */
7006 || (relsec
->sh_type
!= SHT_REL
7007 && relsec
->sh_type
!= SHT_RELA
))
7010 arm_sec
->rel_type
= relsec
->sh_type
;
7011 if (relsec
->sh_type
== SHT_REL
)
7013 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7015 & arm_sec
->rela
, & arm_sec
->nrelas
))
7018 else /* relsec->sh_type == SHT_RELA */
7020 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7022 & arm_sec
->rela
, & arm_sec
->nrelas
))
7028 arm_sec
->next_rela
= arm_sec
->rela
;
7031 /* If there is no unwind data we can do nothing. */
7032 if (arm_sec
->data
== NULL
)
7035 /* If the offset is invalid then fail. */
7036 if (word_offset
> sec
->sh_size
- 4)
7039 /* Get the word at the required offset. */
7040 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7042 /* Look through the relocs to find the one that applies to the provided offset. */
7044 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7046 bfd_vma prelval
, offset
;
7048 if (rp
->r_offset
> word_offset
&& !wrapped
)
7053 if (rp
->r_offset
> word_offset
)
7056 if (rp
->r_offset
& 3)
7058 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7059 (unsigned long) rp
->r_offset
);
7063 if (rp
->r_offset
< word_offset
)
7066 /* PR 17531: file: 027-161405-0.004 */
7067 if (aux
->symtab
== NULL
)
7070 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7072 if (arm_sec
->rel_type
== SHT_REL
)
7074 offset
= word
& 0x7fffffff;
7075 if (offset
& 0x40000000)
7076 offset
|= ~ (bfd_vma
) 0x7fffffff;
7078 else if (arm_sec
->rel_type
== SHT_RELA
)
7079 offset
= rp
->r_addend
;
7082 error (_("Unknown section relocation type %d encountered\n"),
7087 offset
+= sym
->st_value
;
7088 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7090 /* Check that we are processing the expected reloc type. */
7091 if (elf_header
.e_machine
== EM_ARM
)
7093 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7095 if (streq (relname
, "R_ARM_NONE"))
7098 if (! streq (relname
, "R_ARM_PREL31"))
7100 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7104 else if (elf_header
.e_machine
== EM_TI_C6000
)
7106 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7108 if (streq (relname
, "R_C6000_NONE"))
7111 if (! streq (relname
, "R_C6000_PREL31"))
7113 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7121 /* This function currently only supports ARM and TI unwinders. */
7122 warn (_("Only TI and ARM unwinders are currently supported\n"));
7126 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7127 addr
->section
= sym
->st_shndx
;
7128 addr
->offset
= offset
;
7131 * sym_name
= sym
->st_name
;
7136 arm_sec
->next_rela
= rp
;
7141 static const char *tic6x_unwind_regnames
[16] =
7143 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7144 "A14", "A13", "A12", "A11", "A10",
7145 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7149 decode_tic6x_unwind_regmask (unsigned int mask
)
7153 for (i
= 12; mask
; mask
>>= 1, i
--)
7157 fputs (tic6x_unwind_regnames
[i
], stdout
);
7159 fputs (", ", stdout
);
7165 if (remaining == 0 && more_words) \
7168 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7169 data_offset, & word, & addr, NULL)) \
7175 #define GET_OP(OP) \
7180 (OP) = word >> 24; \
7185 printf (_("[Truncated opcode]\n")); \
7188 printf ("0x%02x ", OP)
7191 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7192 unsigned int word
, unsigned int remaining
,
7193 unsigned int more_words
,
7194 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7195 struct arm_section
*data_arm_sec
)
7197 struct absaddr addr
;
7199 /* Decode the unwinding instructions. */
7202 unsigned int op
, op2
;
7211 printf (" 0x%02x ", op
);
7213 if ((op
& 0xc0) == 0x00)
7215 int offset
= ((op
& 0x3f) << 2) + 4;
7217 printf (" vsp = vsp + %d", offset
);
7219 else if ((op
& 0xc0) == 0x40)
7221 int offset
= ((op
& 0x3f) << 2) + 4;
7223 printf (" vsp = vsp - %d", offset
);
7225 else if ((op
& 0xf0) == 0x80)
7228 if (op
== 0x80 && op2
== 0)
7229 printf (_("Refuse to unwind"));
7232 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7237 for (i
= 0; i
< 12; i
++)
7238 if (mask
& (1 << i
))
7244 printf ("r%d", 4 + i
);
7249 else if ((op
& 0xf0) == 0x90)
7251 if (op
== 0x9d || op
== 0x9f)
7252 printf (_(" [Reserved]"));
7254 printf (" vsp = r%d", op
& 0x0f);
7256 else if ((op
& 0xf0) == 0xa0)
7258 int end
= 4 + (op
& 0x07);
7263 for (i
= 4; i
<= end
; i
++)
7279 else if (op
== 0xb0)
7280 printf (_(" finish"));
7281 else if (op
== 0xb1)
7284 if (op2
== 0 || (op2
& 0xf0) != 0)
7285 printf (_("[Spare]"));
7288 unsigned int mask
= op2
& 0x0f;
7293 for (i
= 0; i
< 12; i
++)
7294 if (mask
& (1 << i
))
7305 else if (op
== 0xb2)
7307 unsigned char buf
[9];
7308 unsigned int i
, len
;
7309 unsigned long offset
;
7311 for (i
= 0; i
< sizeof (buf
); i
++)
7314 if ((buf
[i
] & 0x80) == 0)
7317 assert (i
< sizeof (buf
));
7318 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7319 assert (len
== i
+ 1);
7320 offset
= offset
* 4 + 0x204;
7321 printf ("vsp = vsp + %ld", offset
);
7323 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7325 unsigned int first
, last
;
7332 printf ("pop {D%d", first
);
7334 printf ("-D%d", first
+ last
);
7337 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7339 unsigned int count
= op
& 0x07;
7343 printf ("-D%d", 8 + count
);
7346 else if (op
>= 0xc0 && op
<= 0xc5)
7348 unsigned int count
= op
& 0x07;
7350 printf (" pop {wR10");
7352 printf ("-wR%d", 10 + count
);
7355 else if (op
== 0xc6)
7357 unsigned int first
, last
;
7362 printf ("pop {wR%d", first
);
7364 printf ("-wR%d", first
+ last
);
7367 else if (op
== 0xc7)
7370 if (op2
== 0 || (op2
& 0xf0) != 0)
7371 printf (_("[Spare]"));
7374 unsigned int mask
= op2
& 0x0f;
7379 for (i
= 0; i
< 4; i
++)
7380 if (mask
& (1 << i
))
7386 printf ("wCGR%d", i
);
7392 printf (_(" [unsupported opcode]"));
7398 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
7399 unsigned int word
, unsigned int remaining
,
7400 unsigned int more_words
,
7401 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
7402 struct arm_section
*data_arm_sec
)
7404 struct absaddr addr
;
7406 /* Decode the unwinding instructions. */
7409 unsigned int op
, op2
;
7418 printf (" 0x%02x ", op
);
7420 if ((op
& 0xc0) == 0x00)
7422 int offset
= ((op
& 0x3f) << 3) + 8;
7423 printf (" sp = sp + %d", offset
);
7425 else if ((op
& 0xc0) == 0x80)
7428 if (op
== 0x80 && op2
== 0)
7429 printf (_("Refuse to unwind"));
7432 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
7434 printf ("pop compact {");
7438 decode_tic6x_unwind_regmask (mask
);
7442 else if ((op
& 0xf0) == 0xc0)
7450 unsigned int offset
;
7454 /* Scan entire instruction first so that GET_OP output is not
7455 interleaved with disassembly. */
7457 for (i
= 0; nregs
< (op
& 0xf); i
++)
7463 regpos
[nregs
].offset
= i
* 2;
7464 regpos
[nregs
].reg
= reg
;
7471 regpos
[nregs
].offset
= i
* 2 + 1;
7472 regpos
[nregs
].reg
= reg
;
7477 printf (_("pop frame {"));
7479 for (i
= i
* 2; i
> 0; i
--)
7481 if (regpos
[reg
].offset
== i
- 1)
7483 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7490 fputs (name
, stdout
);
7497 else if (op
== 0xd0)
7498 printf (" MOV FP, SP");
7499 else if (op
== 0xd1)
7500 printf (" __c6xabi_pop_rts");
7501 else if (op
== 0xd2)
7503 unsigned char buf
[9];
7504 unsigned int i
, len
;
7505 unsigned long offset
;
7507 for (i
= 0; i
< sizeof (buf
); i
++)
7510 if ((buf
[i
] & 0x80) == 0)
7513 assert (i
< sizeof (buf
));
7514 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7515 assert (len
== i
+ 1);
7516 offset
= offset
* 8 + 0x408;
7517 printf (_("sp = sp + %ld"), offset
);
7519 else if ((op
& 0xf0) == 0xe0)
7521 if ((op
& 0x0f) == 7)
7524 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7528 printf (_(" [unsupported opcode]"));
7535 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7539 offset
= word
& 0x7fffffff;
7540 if (offset
& 0x40000000)
7541 offset
|= ~ (bfd_vma
) 0x7fffffff;
7543 if (elf_header
.e_machine
== EM_TI_C6000
)
7546 return offset
+ where
;
7550 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7552 unsigned int remaining
,
7553 bfd_vma data_offset
,
7554 Elf_Internal_Shdr
* data_sec
,
7555 struct arm_section
* data_arm_sec
)
7558 unsigned int more_words
= 0;
7559 struct absaddr addr
;
7560 bfd_vma sym_name
= (bfd_vma
) -1;
7564 /* Fetch the first word.
7565 Note - when decoding an object file the address extracted
7566 here will always be 0. So we also pass in the sym_name
7567 parameter so that we can find the symbol associated with
7568 the personality routine. */
7569 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7570 & word
, & addr
, & sym_name
))
7576 if ((word
& 0x80000000) == 0)
7578 /* Expand prel31 for personality routine. */
7580 const char *procname
;
7582 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7583 printf (_(" Personality routine: "));
7585 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7586 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7588 procname
= aux
->strtab
+ sym_name
;
7589 print_vma (fn
, PREFIX_HEX
);
7592 fputs (" <", stdout
);
7593 fputs (procname
, stdout
);
7594 fputc ('>', stdout
);
7598 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7599 fputc ('\n', stdout
);
7601 /* The GCC personality routines use the standard compact
7602 encoding, starting with one byte giving the number of
7604 if (procname
!= NULL
7605 && (const_strneq (procname
, "__gcc_personality_v0")
7606 || const_strneq (procname
, "__gxx_personality_v0")
7607 || const_strneq (procname
, "__gcj_personality_v0")
7608 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7615 printf (_(" [Truncated data]\n"));
7618 more_words
= word
>> 24;
7628 /* ARM EHABI Section 6.3:
7630 An exception-handling table entry for the compact model looks like:
7634 1 0 index Data for personalityRoutine[index] */
7636 if (elf_header
.e_machine
== EM_ARM
7637 && (word
& 0x70000000))
7638 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7640 per_index
= (word
>> 24) & 0x7f;
7641 printf (_(" Compact model index: %d\n"), per_index
);
7648 else if (per_index
< 3)
7650 more_words
= (word
>> 16) & 0xff;
7656 switch (elf_header
.e_machine
)
7661 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7662 data_offset
, data_sec
, data_arm_sec
);
7666 warn (_("Unknown ARM compact model index encountered\n"));
7667 printf (_(" [reserved]\n"));
7674 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7675 data_offset
, data_sec
, data_arm_sec
);
7677 else if (per_index
< 5)
7679 if (((word
>> 17) & 0x7f) == 0x7f)
7680 printf (_(" Restore stack from frame pointer\n"));
7682 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7683 printf (_(" Registers restored: "));
7685 printf (" (compact) ");
7686 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7688 printf (_(" Return register: %s\n"),
7689 tic6x_unwind_regnames
[word
& 0xf]);
7692 printf (_(" [reserved (%d)]\n"), per_index
);
7696 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
7697 elf_header
.e_machine
);
7700 /* Decode the descriptors. Not implemented. */
7704 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7706 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7707 unsigned int i
, exidx_len
;
7709 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7710 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7711 exidx_len
= exidx_sec
->sh_size
/ 8;
7713 for (i
= 0; i
< exidx_len
; i
++)
7715 unsigned int exidx_fn
, exidx_entry
;
7716 struct absaddr fn_addr
, entry_addr
;
7719 fputc ('\n', stdout
);
7721 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7722 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7723 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7724 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7726 arm_free_section (& exidx_arm_sec
);
7727 arm_free_section (& extab_arm_sec
);
7731 /* ARM EHABI, Section 5:
7732 An index table entry consists of 2 words.
7733 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7734 if (exidx_fn
& 0x80000000)
7735 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7737 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7739 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7740 fputs (": ", stdout
);
7742 if (exidx_entry
== 1)
7744 print_vma (exidx_entry
, PREFIX_HEX
);
7745 fputs (" [cantunwind]\n", stdout
);
7747 else if (exidx_entry
& 0x80000000)
7749 print_vma (exidx_entry
, PREFIX_HEX
);
7750 fputc ('\n', stdout
);
7751 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7755 bfd_vma table
, table_offset
= 0;
7756 Elf_Internal_Shdr
*table_sec
;
7758 fputs ("@", stdout
);
7759 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7760 print_vma (table
, PREFIX_HEX
);
7763 /* Locate the matching .ARM.extab. */
7764 if (entry_addr
.section
!= SHN_UNDEF
7765 && entry_addr
.section
< elf_header
.e_shnum
)
7767 table_sec
= section_headers
+ entry_addr
.section
;
7768 table_offset
= entry_addr
.offset
;
7772 table_sec
= find_section_by_address (table
);
7773 if (table_sec
!= NULL
)
7774 table_offset
= table
- table_sec
->sh_addr
;
7776 if (table_sec
== NULL
)
7778 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7779 (unsigned long) table
);
7782 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7789 arm_free_section (&exidx_arm_sec
);
7790 arm_free_section (&extab_arm_sec
);
7793 /* Used for both ARM and C6X unwinding tables. */
7796 arm_process_unwind (FILE *file
)
7798 struct arm_unw_aux_info aux
;
7799 Elf_Internal_Shdr
*unwsec
= NULL
;
7800 Elf_Internal_Shdr
*strsec
;
7801 Elf_Internal_Shdr
*sec
;
7803 unsigned int sec_type
;
7805 switch (elf_header
.e_machine
)
7808 sec_type
= SHT_ARM_EXIDX
;
7812 sec_type
= SHT_C6000_UNWIND
;
7816 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
7817 elf_header
.e_machine
);
7821 if (string_table
== NULL
)
7824 memset (& aux
, 0, sizeof (aux
));
7827 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7829 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7831 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7833 strsec
= section_headers
+ sec
->sh_link
;
7835 /* PR binutils/17531 file: 011-12666-0.004. */
7836 if (aux
.strtab
!= NULL
)
7838 warn (_("Multiple string tables found in file.\n"));
7841 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7842 1, strsec
->sh_size
, _("string table"));
7843 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7845 else if (sec
->sh_type
== sec_type
)
7850 printf (_("\nThere are no unwind sections in this file.\n"));
7852 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7854 if (sec
->sh_type
== sec_type
)
7856 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7857 printable_section_name (sec
),
7858 (unsigned long) sec
->sh_offset
,
7859 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7861 dump_arm_unwind (&aux
, sec
);
7868 free ((char *) aux
.strtab
);
7872 process_unwind (FILE * file
)
7874 struct unwind_handler
7877 void (* handler
)(FILE *);
7880 { EM_ARM
, arm_process_unwind
},
7881 { EM_IA_64
, ia64_process_unwind
},
7882 { EM_PARISC
, hppa_process_unwind
},
7883 { EM_TI_C6000
, arm_process_unwind
},
7891 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7892 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7894 handlers
[i
].handler (file
);
7898 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7899 get_machine_name (elf_header
.e_machine
));
7903 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7905 switch (entry
->d_tag
)
7908 if (entry
->d_un
.d_val
== 0)
7912 static const char * opts
[] =
7914 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7915 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7916 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7917 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7923 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7924 if (entry
->d_un
.d_val
& (1 << cnt
))
7926 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7932 case DT_MIPS_IVERSION
:
7933 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7934 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7938 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
7939 /* Note: coded this way so that there is a single string for translation. */
7940 printf (_("<corrupt: %s>"), buf
);
7944 case DT_MIPS_TIME_STAMP
:
7949 time_t atime
= entry
->d_un
.d_val
;
7950 tmp
= gmtime (&atime
);
7951 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7952 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7953 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7954 printf (_("Time Stamp: %s"), timebuf
);
7958 case DT_MIPS_RLD_VERSION
:
7959 case DT_MIPS_LOCAL_GOTNO
:
7960 case DT_MIPS_CONFLICTNO
:
7961 case DT_MIPS_LIBLISTNO
:
7962 case DT_MIPS_SYMTABNO
:
7963 case DT_MIPS_UNREFEXTNO
:
7964 case DT_MIPS_HIPAGENO
:
7965 case DT_MIPS_DELTA_CLASS_NO
:
7966 case DT_MIPS_DELTA_INSTANCE_NO
:
7967 case DT_MIPS_DELTA_RELOC_NO
:
7968 case DT_MIPS_DELTA_SYM_NO
:
7969 case DT_MIPS_DELTA_CLASSSYM_NO
:
7970 case DT_MIPS_COMPACT_SIZE
:
7971 print_vma (entry
->d_un
.d_ptr
, DEC
);
7975 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7981 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7983 switch (entry
->d_tag
)
7985 case DT_HP_DLD_FLAGS
:
7994 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7995 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7996 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7997 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7998 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7999 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8000 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8001 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8002 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8003 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8004 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8005 { DT_HP_GST
, "HP_GST" },
8006 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8007 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8008 { DT_HP_NODELETE
, "HP_NODELETE" },
8009 { DT_HP_GROUP
, "HP_GROUP" },
8010 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8014 bfd_vma val
= entry
->d_un
.d_val
;
8016 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8017 if (val
& flags
[cnt
].bit
)
8021 fputs (flags
[cnt
].str
, stdout
);
8023 val
^= flags
[cnt
].bit
;
8026 if (val
!= 0 || first
)
8030 print_vma (val
, HEX
);
8036 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8044 /* VMS vs Unix time offset and factor. */
8046 #define VMS_EPOCH_OFFSET 35067168000000000LL
8047 #define VMS_GRANULARITY_FACTOR 10000000
8049 /* Display a VMS time in a human readable format. */
8052 print_vms_time (bfd_int64_t vmstime
)
8057 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8058 tm
= gmtime (&unxtime
);
8059 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8060 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8061 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8066 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8068 switch (entry
->d_tag
)
8070 case DT_IA_64_PLT_RESERVE
:
8071 /* First 3 slots reserved. */
8072 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8074 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8077 case DT_IA_64_VMS_LINKTIME
:
8079 print_vms_time (entry
->d_un
.d_val
);
8083 case DT_IA_64_VMS_LNKFLAGS
:
8084 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8085 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8086 printf (" CALL_DEBUG");
8087 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8088 printf (" NOP0BUFS");
8089 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8090 printf (" P0IMAGE");
8091 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8092 printf (" MKTHREADS");
8093 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8094 printf (" UPCALLS");
8095 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8097 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8098 printf (" INITIALIZE");
8099 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8101 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8102 printf (" EXE_INIT");
8103 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8104 printf (" TBK_IN_IMG");
8105 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8106 printf (" DBG_IN_IMG");
8107 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8108 printf (" TBK_IN_DSF");
8109 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8110 printf (" DBG_IN_DSF");
8111 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8112 printf (" SIGNATURES");
8113 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8114 printf (" REL_SEG_OFF");
8118 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8125 get_32bit_dynamic_section (FILE * file
)
8127 Elf32_External_Dyn
* edyn
;
8128 Elf32_External_Dyn
* ext
;
8129 Elf_Internal_Dyn
* entry
;
8131 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8132 dynamic_size
, _("dynamic section"));
8136 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8137 might not have the luxury of section headers. Look for the DT_NULL
8138 terminator to determine the number of entries. */
8139 for (ext
= edyn
, dynamic_nent
= 0;
8140 (char *) ext
< (char *) edyn
+ dynamic_size
;
8144 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8148 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8150 if (dynamic_section
== NULL
)
8152 error (_("Out of memory\n"));
8157 for (ext
= edyn
, entry
= dynamic_section
;
8158 entry
< dynamic_section
+ dynamic_nent
;
8161 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8162 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8171 get_64bit_dynamic_section (FILE * file
)
8173 Elf64_External_Dyn
* edyn
;
8174 Elf64_External_Dyn
* ext
;
8175 Elf_Internal_Dyn
* entry
;
8177 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8178 dynamic_size
, _("dynamic section"));
8182 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8183 might not have the luxury of section headers. Look for the DT_NULL
8184 terminator to determine the number of entries. */
8185 for (ext
= edyn
, dynamic_nent
= 0;
8186 (char *) ext
< (char *) edyn
+ dynamic_size
;
8190 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8194 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8196 if (dynamic_section
== NULL
)
8198 error (_("Out of memory\n"));
8203 for (ext
= edyn
, entry
= dynamic_section
;
8204 entry
< dynamic_section
+ dynamic_nent
;
8207 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8208 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8217 print_dynamic_flags (bfd_vma flags
)
8225 flag
= flags
& - flags
;
8235 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8236 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8237 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8238 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8239 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8240 default: fputs (_("unknown"), stdout
); break;
8246 /* Parse and display the contents of the dynamic section. */
8249 process_dynamic_section (FILE * file
)
8251 Elf_Internal_Dyn
* entry
;
8253 if (dynamic_size
== 0)
8256 printf (_("\nThere is no dynamic section in this file.\n"));
8263 if (! get_32bit_dynamic_section (file
))
8266 else if (! get_64bit_dynamic_section (file
))
8269 /* Find the appropriate symbol table. */
8270 if (dynamic_symbols
== NULL
)
8272 for (entry
= dynamic_section
;
8273 entry
< dynamic_section
+ dynamic_nent
;
8276 Elf_Internal_Shdr section
;
8278 if (entry
->d_tag
!= DT_SYMTAB
)
8281 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8283 /* Since we do not know how big the symbol table is,
8284 we default to reading in the entire file (!) and
8285 processing that. This is overkill, I know, but it
8287 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8289 if (archive_file_offset
!= 0)
8290 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8293 if (fseek (file
, 0, SEEK_END
))
8294 error (_("Unable to seek to end of file!\n"));
8296 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8300 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8302 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8304 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8305 if (num_dynamic_syms
< 1)
8307 error (_("Unable to determine the number of symbols to load\n"));
8313 /* Similarly find a string table. */
8314 if (dynamic_strings
== NULL
)
8316 for (entry
= dynamic_section
;
8317 entry
< dynamic_section
+ dynamic_nent
;
8320 unsigned long offset
;
8323 if (entry
->d_tag
!= DT_STRTAB
)
8326 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8328 /* Since we do not know how big the string table is,
8329 we default to reading in the entire file (!) and
8330 processing that. This is overkill, I know, but it
8333 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8335 if (archive_file_offset
!= 0)
8336 str_tab_len
= archive_file_size
- offset
;
8339 if (fseek (file
, 0, SEEK_END
))
8340 error (_("Unable to seek to end of file\n"));
8341 str_tab_len
= ftell (file
) - offset
;
8344 if (str_tab_len
< 1)
8347 (_("Unable to determine the length of the dynamic string table\n"));
8351 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8353 _("dynamic string table"));
8354 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8359 /* And find the syminfo section if available. */
8360 if (dynamic_syminfo
== NULL
)
8362 unsigned long syminsz
= 0;
8364 for (entry
= dynamic_section
;
8365 entry
< dynamic_section
+ dynamic_nent
;
8368 if (entry
->d_tag
== DT_SYMINENT
)
8370 /* Note: these braces are necessary to avoid a syntax
8371 error from the SunOS4 C compiler. */
8372 /* PR binutils/17531: A corrupt file can trigger this test.
8373 So do not use an assert, instead generate an error message. */
8374 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
8375 error (_("Bad value (%d) for SYMINENT entry"),
8376 (int) entry
->d_un
.d_val
);
8378 else if (entry
->d_tag
== DT_SYMINSZ
)
8379 syminsz
= entry
->d_un
.d_val
;
8380 else if (entry
->d_tag
== DT_SYMINFO
)
8381 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
8385 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
8387 Elf_External_Syminfo
* extsyminfo
;
8388 Elf_External_Syminfo
* extsym
;
8389 Elf_Internal_Syminfo
* syminfo
;
8391 /* There is a syminfo section. Read the data. */
8392 extsyminfo
= (Elf_External_Syminfo
*)
8393 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
8394 _("symbol information"));
8398 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
8399 if (dynamic_syminfo
== NULL
)
8401 error (_("Out of memory\n"));
8405 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
8406 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
8407 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
8408 ++syminfo
, ++extsym
)
8410 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
8411 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
8418 if (do_dynamic
&& dynamic_addr
)
8419 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8420 dynamic_addr
, dynamic_nent
);
8422 printf (_(" Tag Type Name/Value\n"));
8424 for (entry
= dynamic_section
;
8425 entry
< dynamic_section
+ dynamic_nent
;
8433 print_vma (entry
->d_tag
, FULL_HEX
);
8434 dtype
= get_dynamic_type (entry
->d_tag
);
8435 printf (" (%s)%*s", dtype
,
8436 ((is_32bit_elf
? 27 : 19)
8437 - (int) strlen (dtype
)),
8441 switch (entry
->d_tag
)
8445 print_dynamic_flags (entry
->d_un
.d_val
);
8455 switch (entry
->d_tag
)
8458 printf (_("Auxiliary library"));
8462 printf (_("Filter library"));
8466 printf (_("Configuration file"));
8470 printf (_("Dependency audit library"));
8474 printf (_("Audit library"));
8478 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8479 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8483 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8492 printf (_("Flags:"));
8494 if (entry
->d_un
.d_val
== 0)
8495 printf (_(" None\n"));
8498 unsigned long int val
= entry
->d_un
.d_val
;
8500 if (val
& DTF_1_PARINIT
)
8502 printf (" PARINIT");
8503 val
^= DTF_1_PARINIT
;
8505 if (val
& DTF_1_CONFEXP
)
8507 printf (" CONFEXP");
8508 val
^= DTF_1_CONFEXP
;
8511 printf (" %lx", val
);
8520 printf (_("Flags:"));
8522 if (entry
->d_un
.d_val
== 0)
8523 printf (_(" None\n"));
8526 unsigned long int val
= entry
->d_un
.d_val
;
8528 if (val
& DF_P1_LAZYLOAD
)
8530 printf (" LAZYLOAD");
8531 val
^= DF_P1_LAZYLOAD
;
8533 if (val
& DF_P1_GROUPPERM
)
8535 printf (" GROUPPERM");
8536 val
^= DF_P1_GROUPPERM
;
8539 printf (" %lx", val
);
8548 printf (_("Flags:"));
8549 if (entry
->d_un
.d_val
== 0)
8550 printf (_(" None\n"));
8553 unsigned long int val
= entry
->d_un
.d_val
;
8560 if (val
& DF_1_GLOBAL
)
8565 if (val
& DF_1_GROUP
)
8570 if (val
& DF_1_NODELETE
)
8572 printf (" NODELETE");
8573 val
^= DF_1_NODELETE
;
8575 if (val
& DF_1_LOADFLTR
)
8577 printf (" LOADFLTR");
8578 val
^= DF_1_LOADFLTR
;
8580 if (val
& DF_1_INITFIRST
)
8582 printf (" INITFIRST");
8583 val
^= DF_1_INITFIRST
;
8585 if (val
& DF_1_NOOPEN
)
8590 if (val
& DF_1_ORIGIN
)
8595 if (val
& DF_1_DIRECT
)
8600 if (val
& DF_1_TRANS
)
8605 if (val
& DF_1_INTERPOSE
)
8607 printf (" INTERPOSE");
8608 val
^= DF_1_INTERPOSE
;
8610 if (val
& DF_1_NODEFLIB
)
8612 printf (" NODEFLIB");
8613 val
^= DF_1_NODEFLIB
;
8615 if (val
& DF_1_NODUMP
)
8620 if (val
& DF_1_CONFALT
)
8622 printf (" CONFALT");
8623 val
^= DF_1_CONFALT
;
8625 if (val
& DF_1_ENDFILTEE
)
8627 printf (" ENDFILTEE");
8628 val
^= DF_1_ENDFILTEE
;
8630 if (val
& DF_1_DISPRELDNE
)
8632 printf (" DISPRELDNE");
8633 val
^= DF_1_DISPRELDNE
;
8635 if (val
& DF_1_DISPRELPND
)
8637 printf (" DISPRELPND");
8638 val
^= DF_1_DISPRELPND
;
8640 if (val
& DF_1_NODIRECT
)
8642 printf (" NODIRECT");
8643 val
^= DF_1_NODIRECT
;
8645 if (val
& DF_1_IGNMULDEF
)
8647 printf (" IGNMULDEF");
8648 val
^= DF_1_IGNMULDEF
;
8650 if (val
& DF_1_NOKSYMS
)
8652 printf (" NOKSYMS");
8653 val
^= DF_1_NOKSYMS
;
8655 if (val
& DF_1_NOHDR
)
8660 if (val
& DF_1_EDITED
)
8665 if (val
& DF_1_NORELOC
)
8667 printf (" NORELOC");
8668 val
^= DF_1_NORELOC
;
8670 if (val
& DF_1_SYMINTPOSE
)
8672 printf (" SYMINTPOSE");
8673 val
^= DF_1_SYMINTPOSE
;
8675 if (val
& DF_1_GLOBAUDIT
)
8677 printf (" GLOBAUDIT");
8678 val
^= DF_1_GLOBAUDIT
;
8680 if (val
& DF_1_SINGLETON
)
8682 printf (" SINGLETON");
8683 val
^= DF_1_SINGLETON
;
8686 printf (" %lx", val
);
8693 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8695 puts (get_dynamic_type (entry
->d_un
.d_val
));
8715 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8721 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8722 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8728 switch (entry
->d_tag
)
8731 printf (_("Shared library: [%s]"), name
);
8733 if (streq (name
, program_interpreter
))
8734 printf (_(" program interpreter"));
8738 printf (_("Library soname: [%s]"), name
);
8742 printf (_("Library rpath: [%s]"), name
);
8746 printf (_("Library runpath: [%s]"), name
);
8750 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8755 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8768 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8772 case DT_INIT_ARRAYSZ
:
8773 case DT_FINI_ARRAYSZ
:
8774 case DT_GNU_CONFLICTSZ
:
8775 case DT_GNU_LIBLISTSZ
:
8778 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8779 printf (_(" (bytes)\n"));
8789 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8802 if (entry
->d_tag
== DT_USED
8803 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8805 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8809 printf (_("Not needed object: [%s]\n"), name
);
8814 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8820 /* The value of this entry is ignored. */
8825 case DT_GNU_PRELINKED
:
8829 time_t atime
= entry
->d_un
.d_val
;
8831 tmp
= gmtime (&atime
);
8832 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8833 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8834 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8840 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8843 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8849 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8850 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8855 switch (elf_header
.e_machine
)
8858 case EM_MIPS_RS3_LE
:
8859 dynamic_section_mips_val (entry
);
8862 dynamic_section_parisc_val (entry
);
8865 dynamic_section_ia64_val (entry
);
8868 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8880 get_ver_flags (unsigned int flags
)
8882 static char buff
[32];
8889 if (flags
& VER_FLG_BASE
)
8890 strcat (buff
, "BASE ");
8892 if (flags
& VER_FLG_WEAK
)
8894 if (flags
& VER_FLG_BASE
)
8895 strcat (buff
, "| ");
8897 strcat (buff
, "WEAK ");
8900 if (flags
& VER_FLG_INFO
)
8902 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8903 strcat (buff
, "| ");
8905 strcat (buff
, "INFO ");
8908 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8909 strcat (buff
, _("| <unknown>"));
8914 /* Display the contents of the version sections. */
8917 process_version_sections (FILE * file
)
8919 Elf_Internal_Shdr
* section
;
8926 for (i
= 0, section
= section_headers
;
8927 i
< elf_header
.e_shnum
;
8930 switch (section
->sh_type
)
8932 case SHT_GNU_verdef
:
8934 Elf_External_Verdef
* edefs
;
8941 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
8942 printable_section_name (section
),
8945 printf (_(" Addr: 0x"));
8946 printf_vma (section
->sh_addr
);
8947 printf (_(" Offset: %#08lx Link: %u (%s)"),
8948 (unsigned long) section
->sh_offset
, section
->sh_link
,
8949 printable_section_name_from_index (section
->sh_link
));
8951 edefs
= (Elf_External_Verdef
*)
8952 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8953 _("version definition section"));
8956 endbuf
= (char *) edefs
+ section
->sh_size
;
8958 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8961 Elf_External_Verdef
* edef
;
8962 Elf_Internal_Verdef ent
;
8963 Elf_External_Verdaux
* eaux
;
8964 Elf_Internal_Verdaux aux
;
8968 /* Check for very large indicies. */
8969 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8972 vstart
= ((char *) edefs
) + idx
;
8973 if (vstart
+ sizeof (*edef
) > endbuf
)
8976 edef
= (Elf_External_Verdef
*) vstart
;
8978 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8979 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8980 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8981 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8982 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8983 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8984 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8986 printf (_(" %#06x: Rev: %d Flags: %s"),
8987 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8989 printf (_(" Index: %d Cnt: %d "),
8990 ent
.vd_ndx
, ent
.vd_cnt
);
8992 /* Check for overflow. */
8993 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8996 vstart
+= ent
.vd_aux
;
8998 eaux
= (Elf_External_Verdaux
*) vstart
;
9000 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9001 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9003 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9004 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9006 printf (_("Name index: %ld\n"), aux
.vda_name
);
9008 isum
= idx
+ ent
.vd_aux
;
9010 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9012 /* Check for overflow. */
9013 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9016 isum
+= aux
.vda_next
;
9017 vstart
+= aux
.vda_next
;
9019 eaux
= (Elf_External_Verdaux
*) vstart
;
9020 if (vstart
+ sizeof (*eaux
) > endbuf
)
9023 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9024 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9026 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9027 printf (_(" %#06x: Parent %d: %s\n"),
9028 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9030 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9031 isum
, j
, aux
.vda_name
);
9035 printf (_(" Version def aux past end of section\n"));
9040 if (cnt
< section
->sh_info
)
9041 printf (_(" Version definition past end of section\n"));
9047 case SHT_GNU_verneed
:
9049 Elf_External_Verneed
* eneed
;
9056 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9057 printable_section_name (section
), section
->sh_info
);
9059 printf (_(" Addr: 0x"));
9060 printf_vma (section
->sh_addr
);
9061 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9062 (unsigned long) section
->sh_offset
, section
->sh_link
,
9063 printable_section_name_from_index (section
->sh_link
));
9065 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9066 section
->sh_offset
, 1,
9068 _("Version Needs section"));
9071 endbuf
= (char *) eneed
+ section
->sh_size
;
9073 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9075 Elf_External_Verneed
* entry
;
9076 Elf_Internal_Verneed ent
;
9081 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9084 vstart
= ((char *) eneed
) + idx
;
9085 if (vstart
+ sizeof (*entry
) > endbuf
)
9088 entry
= (Elf_External_Verneed
*) vstart
;
9090 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9091 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9092 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9093 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9094 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9096 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9098 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9099 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9101 printf (_(" File: %lx"), ent
.vn_file
);
9103 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9105 /* Check for overflow. */
9106 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9109 vstart
+= ent
.vn_aux
;
9111 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9113 Elf_External_Vernaux
* eaux
;
9114 Elf_Internal_Vernaux aux
;
9116 if (vstart
+ sizeof (*eaux
) > endbuf
)
9118 eaux
= (Elf_External_Vernaux
*) vstart
;
9120 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9121 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9122 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9123 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9124 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9126 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9127 printf (_(" %#06x: Name: %s"),
9128 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9130 printf (_(" %#06x: Name index: %lx"),
9131 isum
, aux
.vna_name
);
9133 printf (_(" Flags: %s Version: %d\n"),
9134 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9136 /* Check for overflow. */
9137 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
9140 isum
+= aux
.vna_next
;
9141 vstart
+= aux
.vna_next
;
9145 warn (_("Missing Version Needs auxillary information\n"));
9147 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9149 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9150 cnt
= section
->sh_info
;
9156 if (cnt
< section
->sh_info
)
9157 warn (_("Missing Version Needs information\n"));
9163 case SHT_GNU_versym
:
9165 Elf_Internal_Shdr
* link_section
;
9168 unsigned char * edata
;
9169 unsigned short * data
;
9171 Elf_Internal_Sym
* symbols
;
9172 Elf_Internal_Shdr
* string_sec
;
9173 unsigned long num_syms
;
9176 if (section
->sh_link
>= elf_header
.e_shnum
)
9179 link_section
= section_headers
+ section
->sh_link
;
9180 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9182 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9187 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9188 if (symbols
== NULL
)
9191 string_sec
= section_headers
+ link_section
->sh_link
;
9193 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9194 string_sec
->sh_size
,
9195 _("version string table"));
9202 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9203 printable_section_name (section
), total
);
9205 printf (_(" Addr: "));
9206 printf_vma (section
->sh_addr
);
9207 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9208 (unsigned long) section
->sh_offset
, section
->sh_link
,
9209 printable_section_name (link_section
));
9211 off
= offset_from_vma (file
,
9212 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9213 total
* sizeof (short));
9214 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9216 _("version symbol data"));
9224 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9226 for (cnt
= total
; cnt
--;)
9227 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9232 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9235 int check_def
, check_need
;
9238 printf (" %03x:", cnt
);
9240 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9241 switch (data
[cnt
+ j
])
9244 fputs (_(" 0 (*local*) "), stdout
);
9248 fputs (_(" 1 (*global*) "), stdout
);
9252 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9253 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9255 /* If this index value is greater than the size of the symbols
9256 array, break to avoid an out-of-bounds read. */
9257 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9259 warn (_("invalid index into symbol array\n"));
9265 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9266 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9269 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9276 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9278 Elf_Internal_Verneed ivn
;
9279 unsigned long offset
;
9281 offset
= offset_from_vma
9282 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9283 sizeof (Elf_External_Verneed
));
9287 Elf_Internal_Vernaux ivna
;
9288 Elf_External_Verneed evn
;
9289 Elf_External_Vernaux evna
;
9290 unsigned long a_off
;
9292 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9293 _("version need")) == NULL
)
9296 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9297 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9299 a_off
= offset
+ ivn
.vn_aux
;
9303 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9304 1, _("version need aux (2)")) == NULL
)
9311 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9312 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9315 a_off
+= ivna
.vna_next
;
9317 while (ivna
.vna_other
!= data
[cnt
+ j
]
9318 && ivna
.vna_next
!= 0);
9320 if (ivna
.vna_other
== data
[cnt
+ j
])
9322 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9324 if (ivna
.vna_name
>= string_sec
->sh_size
)
9325 name
= _("*invalid*");
9327 name
= strtab
+ ivna
.vna_name
;
9328 nn
+= printf ("(%s%-*s",
9330 12 - (int) strlen (name
),
9336 offset
+= ivn
.vn_next
;
9338 while (ivn
.vn_next
);
9341 if (check_def
&& data
[cnt
+ j
] != 0x8001
9342 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9344 Elf_Internal_Verdef ivd
;
9345 Elf_External_Verdef evd
;
9346 unsigned long offset
;
9348 offset
= offset_from_vma
9349 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9354 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9355 _("version def")) == NULL
)
9362 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9363 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9366 offset
+= ivd
.vd_next
;
9368 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
9369 && ivd
.vd_next
!= 0);
9371 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
9373 Elf_External_Verdaux evda
;
9374 Elf_Internal_Verdaux ivda
;
9376 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9378 if (get_data (&evda
, file
,
9379 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
9381 _("version def aux")) == NULL
)
9384 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9386 if (ivda
.vda_name
>= string_sec
->sh_size
)
9387 name
= _("*invalid*");
9389 name
= strtab
+ ivda
.vda_name
;
9390 nn
+= printf ("(%s%-*s",
9392 12 - (int) strlen (name
),
9398 printf ("%*c", 18 - nn
, ' ');
9416 printf (_("\nNo version information found in this file.\n"));
9422 get_symbol_binding (unsigned int binding
)
9424 static char buff
[32];
9428 case STB_LOCAL
: return "LOCAL";
9429 case STB_GLOBAL
: return "GLOBAL";
9430 case STB_WEAK
: return "WEAK";
9432 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
9433 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
9435 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
9437 if (binding
== STB_GNU_UNIQUE
9438 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9439 /* GNU is still using the default value 0. */
9440 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9442 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
9445 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
9451 get_symbol_type (unsigned int type
)
9453 static char buff
[32];
9457 case STT_NOTYPE
: return "NOTYPE";
9458 case STT_OBJECT
: return "OBJECT";
9459 case STT_FUNC
: return "FUNC";
9460 case STT_SECTION
: return "SECTION";
9461 case STT_FILE
: return "FILE";
9462 case STT_COMMON
: return "COMMON";
9463 case STT_TLS
: return "TLS";
9464 case STT_RELC
: return "RELC";
9465 case STT_SRELC
: return "SRELC";
9467 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
9469 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
9470 return "THUMB_FUNC";
9472 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
9475 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
9476 return "PARISC_MILLI";
9478 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
9480 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
9482 if (elf_header
.e_machine
== EM_PARISC
)
9484 if (type
== STT_HP_OPAQUE
)
9486 if (type
== STT_HP_STUB
)
9490 if (type
== STT_GNU_IFUNC
9491 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
9492 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
9493 /* GNU is still using the default value 0. */
9494 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9497 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9500 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9506 get_symbol_visibility (unsigned int visibility
)
9510 case STV_DEFAULT
: return "DEFAULT";
9511 case STV_INTERNAL
: return "INTERNAL";
9512 case STV_HIDDEN
: return "HIDDEN";
9513 case STV_PROTECTED
: return "PROTECTED";
9519 get_mips_symbol_other (unsigned int other
)
9531 case STO_MICROMIPS
| STO_MIPS_PIC
:
9532 return "MICROMIPS, MIPS PIC";
9541 get_ia64_symbol_other (unsigned int other
)
9545 static char res
[32];
9549 /* Function types is for images and .STB files only. */
9550 switch (elf_header
.e_type
)
9554 switch (VMS_ST_FUNC_TYPE (other
))
9556 case VMS_SFT_CODE_ADDR
:
9557 strcat (res
, " CA");
9559 case VMS_SFT_SYMV_IDX
:
9560 strcat (res
, " VEC");
9563 strcat (res
, " FD");
9565 case VMS_SFT_RESERVE
:
9566 strcat (res
, " RSV");
9575 switch (VMS_ST_LINKAGE (other
))
9577 case VMS_STL_IGNORE
:
9578 strcat (res
, " IGN");
9580 case VMS_STL_RESERVE
:
9581 strcat (res
, " RSV");
9584 strcat (res
, " STD");
9587 strcat (res
, " LNK");
9602 get_ppc64_symbol_other (unsigned int other
)
9604 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
9606 static char buf
[32];
9607 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
9608 PPC64_LOCAL_ENTRY_OFFSET (other
));
9615 get_symbol_other (unsigned int other
)
9617 const char * result
= NULL
;
9618 static char buff
[32];
9623 switch (elf_header
.e_machine
)
9626 result
= get_mips_symbol_other (other
);
9629 result
= get_ia64_symbol_other (other
);
9632 result
= get_ppc64_symbol_other (other
);
9641 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9646 get_symbol_index_type (unsigned int type
)
9648 static char buff
[32];
9652 case SHN_UNDEF
: return "UND";
9653 case SHN_ABS
: return "ABS";
9654 case SHN_COMMON
: return "COM";
9656 if (type
== SHN_IA_64_ANSI_COMMON
9657 && elf_header
.e_machine
== EM_IA_64
9658 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9660 else if ((elf_header
.e_machine
== EM_X86_64
9661 || elf_header
.e_machine
== EM_L1OM
9662 || elf_header
.e_machine
== EM_K1OM
)
9663 && type
== SHN_X86_64_LCOMMON
)
9665 else if ((type
== SHN_MIPS_SCOMMON
9666 && elf_header
.e_machine
== EM_MIPS
)
9667 || (type
== SHN_TIC6X_SCOMMON
9668 && elf_header
.e_machine
== EM_TI_C6000
))
9670 else if (type
== SHN_MIPS_SUNDEFINED
9671 && elf_header
.e_machine
== EM_MIPS
)
9673 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9674 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9675 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9676 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9677 else if (type
>= SHN_LORESERVE
)
9678 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9679 else if (type
>= elf_header
.e_shnum
)
9680 sprintf (buff
, _("bad section index[%3d]"), type
);
9682 sprintf (buff
, "%3d", type
);
9690 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9692 unsigned char * e_data
;
9695 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9699 error (_("Out of memory\n"));
9703 if (fread (e_data
, ent_size
, number
, file
) != number
)
9705 error (_("Unable to read in dynamic data\n"));
9709 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9713 error (_("Out of memory\n"));
9719 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9727 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9729 Elf_Internal_Sym
* psym
;
9732 n
= print_vma (si
, DEC_5
);
9734 fputs (&" "[n
], stdout
);
9735 printf (" %3lu: ", hn
);
9737 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
9739 printf (_("<No info available>\n"));
9743 psym
= dynamic_symbols
+ si
;
9744 print_vma (psym
->st_value
, LONG_HEX
);
9746 print_vma (psym
->st_size
, DEC_5
);
9748 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9749 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9750 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9751 /* Check to see if any other bits in the st_other field are set.
9752 Note - displaying this information disrupts the layout of the
9753 table being generated, but for the moment this case is very
9755 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9756 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9757 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9758 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9759 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9761 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9765 /* Dump the symbol table. */
9767 process_symbol_table (FILE * file
)
9769 Elf_Internal_Shdr
* section
;
9770 bfd_vma nbuckets
= 0;
9771 bfd_vma nchains
= 0;
9772 bfd_vma
* buckets
= NULL
;
9773 bfd_vma
* chains
= NULL
;
9774 bfd_vma ngnubuckets
= 0;
9775 bfd_vma
* gnubuckets
= NULL
;
9776 bfd_vma
* gnuchains
= NULL
;
9777 bfd_vma gnusymidx
= 0;
9779 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9782 if (dynamic_info
[DT_HASH
]
9784 || (do_using_dynamic
9786 && dynamic_strings
!= NULL
)))
9788 unsigned char nb
[8];
9789 unsigned char nc
[8];
9790 int hash_ent_size
= 4;
9792 if ((elf_header
.e_machine
== EM_ALPHA
9793 || elf_header
.e_machine
== EM_S390
9794 || elf_header
.e_machine
== EM_S390_OLD
)
9795 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9799 (archive_file_offset
9800 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9801 sizeof nb
+ sizeof nc
)),
9804 error (_("Unable to seek to start of dynamic information\n"));
9808 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9810 error (_("Failed to read in number of buckets\n"));
9814 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9816 error (_("Failed to read in number of chains\n"));
9820 nbuckets
= byte_get (nb
, hash_ent_size
);
9821 nchains
= byte_get (nc
, hash_ent_size
);
9823 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9824 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9827 if (buckets
== NULL
|| chains
== NULL
)
9829 if (do_using_dynamic
)
9840 if (dynamic_info_DT_GNU_HASH
9842 || (do_using_dynamic
9844 && dynamic_strings
!= NULL
)))
9846 unsigned char nb
[16];
9847 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9848 bfd_vma buckets_vma
;
9851 (archive_file_offset
9852 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9856 error (_("Unable to seek to start of dynamic information\n"));
9860 if (fread (nb
, 16, 1, file
) != 1)
9862 error (_("Failed to read in number of buckets\n"));
9866 ngnubuckets
= byte_get (nb
, 4);
9867 gnusymidx
= byte_get (nb
+ 4, 4);
9868 bitmaskwords
= byte_get (nb
+ 8, 4);
9869 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9871 buckets_vma
+= bitmaskwords
* 4;
9873 buckets_vma
+= bitmaskwords
* 8;
9876 (archive_file_offset
9877 + offset_from_vma (file
, buckets_vma
, 4)),
9880 error (_("Unable to seek to start of dynamic information\n"));
9884 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9886 if (gnubuckets
== NULL
)
9889 for (i
= 0; i
< ngnubuckets
; i
++)
9890 if (gnubuckets
[i
] != 0)
9892 if (gnubuckets
[i
] < gnusymidx
)
9895 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9896 maxchain
= gnubuckets
[i
];
9899 if (maxchain
== 0xffffffff)
9902 maxchain
-= gnusymidx
;
9905 (archive_file_offset
9906 + offset_from_vma (file
, buckets_vma
9907 + 4 * (ngnubuckets
+ maxchain
), 4)),
9910 error (_("Unable to seek to start of dynamic information\n"));
9916 if (fread (nb
, 4, 1, file
) != 1)
9918 error (_("Failed to determine last chain length\n"));
9922 if (maxchain
+ 1 == 0)
9927 while ((byte_get (nb
, 4) & 1) == 0);
9930 (archive_file_offset
9931 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9934 error (_("Unable to seek to start of dynamic information\n"));
9938 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9941 if (gnuchains
== NULL
)
9946 if (do_using_dynamic
)
9951 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9954 && dynamic_strings
!= NULL
)
9958 if (dynamic_info
[DT_HASH
])
9962 printf (_("\nSymbol table for image:\n"));
9964 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9966 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9968 for (hn
= 0; hn
< nbuckets
; hn
++)
9973 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9974 print_dynamic_symbol (si
, hn
);
9978 if (dynamic_info_DT_GNU_HASH
)
9980 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9982 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9984 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9986 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9987 if (gnubuckets
[hn
] != 0)
9989 bfd_vma si
= gnubuckets
[hn
];
9990 bfd_vma off
= si
- gnusymidx
;
9994 print_dynamic_symbol (si
, hn
);
9997 while ((gnuchains
[off
++] & 1) == 0);
10001 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10005 for (i
= 0, section
= section_headers
;
10006 i
< elf_header
.e_shnum
;
10010 char * strtab
= NULL
;
10011 unsigned long int strtab_size
= 0;
10012 Elf_Internal_Sym
* symtab
;
10013 Elf_Internal_Sym
* psym
;
10014 unsigned long num_syms
;
10016 if ((section
->sh_type
!= SHT_SYMTAB
10017 && section
->sh_type
!= SHT_DYNSYM
)
10019 && section
->sh_type
== SHT_SYMTAB
))
10022 if (section
->sh_entsize
== 0)
10024 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10025 printable_section_name (section
));
10029 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10030 printable_section_name (section
),
10031 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10034 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10036 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10038 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10039 if (symtab
== NULL
)
10042 if (section
->sh_link
== elf_header
.e_shstrndx
)
10044 strtab
= string_table
;
10045 strtab_size
= string_table_length
;
10047 else if (section
->sh_link
< elf_header
.e_shnum
)
10049 Elf_Internal_Shdr
* string_sec
;
10051 string_sec
= section_headers
+ section
->sh_link
;
10053 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10054 1, string_sec
->sh_size
,
10055 _("string table"));
10056 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10059 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10061 printf ("%6d: ", si
);
10062 print_vma (psym
->st_value
, LONG_HEX
);
10064 print_vma (psym
->st_size
, DEC_5
);
10065 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10066 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10067 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10068 /* Check to see if any other bits in the st_other field are set.
10069 Note - displaying this information disrupts the layout of the
10070 table being generated, but for the moment this case is very rare. */
10071 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10072 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10073 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10074 print_symbol (25, psym
->st_name
< strtab_size
10075 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10077 if (section
->sh_type
== SHT_DYNSYM
10078 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10080 unsigned char data
[2];
10081 unsigned short vers_data
;
10082 unsigned long offset
;
10086 offset
= offset_from_vma
10087 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10088 sizeof data
+ si
* sizeof (vers_data
));
10090 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10091 sizeof (data
), 1, _("version data")) == NULL
)
10094 vers_data
= byte_get (data
, 2);
10096 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
10097 && section_headers
[psym
->st_shndx
].sh_type
10100 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10102 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10104 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10105 && (is_nobits
|| ! check_def
))
10107 Elf_External_Verneed evn
;
10108 Elf_Internal_Verneed ivn
;
10109 Elf_Internal_Vernaux ivna
;
10111 /* We must test both. */
10112 offset
= offset_from_vma
10113 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10118 unsigned long vna_off
;
10120 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10121 _("version need")) == NULL
)
10124 ivna
.vna_other
= 0;
10129 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10130 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10132 vna_off
= offset
+ ivn
.vn_aux
;
10136 Elf_External_Vernaux evna
;
10138 if (get_data (&evna
, file
, vna_off
,
10140 _("version need aux (3)")) == NULL
)
10143 ivna
.vna_other
= 0;
10148 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10149 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10150 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10153 vna_off
+= ivna
.vna_next
;
10155 while (ivna
.vna_other
!= vers_data
10156 && ivna
.vna_next
!= 0);
10158 if (ivna
.vna_other
== vers_data
)
10161 offset
+= ivn
.vn_next
;
10163 while (ivn
.vn_next
!= 0);
10165 if (ivna
.vna_other
== vers_data
)
10167 printf ("@%s (%d)",
10168 ivna
.vna_name
< strtab_size
10169 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
10173 else if (! is_nobits
)
10174 error (_("bad dynamic symbol\n"));
10181 if (vers_data
!= 0x8001
10182 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10184 Elf_Internal_Verdef ivd
;
10185 Elf_Internal_Verdaux ivda
;
10186 Elf_External_Verdaux evda
;
10189 off
= offset_from_vma
10191 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10192 sizeof (Elf_External_Verdef
));
10196 Elf_External_Verdef evd
;
10198 if (get_data (&evd
, file
, off
, sizeof (evd
),
10199 1, _("version def")) == NULL
)
10207 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10208 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10209 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10212 off
+= ivd
.vd_next
;
10214 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10215 && ivd
.vd_next
!= 0);
10217 off
-= ivd
.vd_next
;
10220 if (get_data (&evda
, file
, off
, sizeof (evda
),
10221 1, _("version def aux")) == NULL
)
10224 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10226 if (psym
->st_name
!= ivda
.vda_name
)
10227 printf ((vers_data
& VERSYM_HIDDEN
)
10229 ivda
.vda_name
< strtab_size
10230 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10240 if (strtab
!= string_table
)
10246 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10248 if (do_histogram
&& buckets
!= NULL
)
10250 unsigned long * lengths
;
10251 unsigned long * counts
;
10254 unsigned long maxlength
= 0;
10255 unsigned long nzero_counts
= 0;
10256 unsigned long nsyms
= 0;
10258 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10259 (unsigned long) nbuckets
);
10260 printf (_(" Length Number %% of total Coverage\n"));
10262 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10263 if (lengths
== NULL
)
10265 error (_("Out of memory\n"));
10268 for (hn
= 0; hn
< nbuckets
; ++hn
)
10270 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
10273 if (maxlength
< ++lengths
[hn
])
10276 /* PR binutils/17531: A corrupt binary could contain broken
10277 histogram data. Do not go into an infinite loop trying
10279 if (chains
[si
] == si
)
10281 error (_("histogram chain links to itself\n"));
10287 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10288 if (counts
== NULL
)
10291 error (_("Out of memory\n"));
10295 for (hn
= 0; hn
< nbuckets
; ++hn
)
10296 ++counts
[lengths
[hn
]];
10301 printf (" 0 %-10lu (%5.1f%%)\n",
10302 counts
[0], (counts
[0] * 100.0) / nbuckets
);
10303 for (i
= 1; i
<= maxlength
; ++i
)
10305 nzero_counts
+= counts
[i
] * i
;
10306 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10307 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
10308 (nzero_counts
* 100.0) / nsyms
);
10316 if (buckets
!= NULL
)
10322 if (do_histogram
&& gnubuckets
!= NULL
)
10324 unsigned long * lengths
;
10325 unsigned long * counts
;
10327 unsigned long maxlength
= 0;
10328 unsigned long nzero_counts
= 0;
10329 unsigned long nsyms
= 0;
10331 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
10332 if (lengths
== NULL
)
10334 error (_("Out of memory\n"));
10338 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10339 (unsigned long) ngnubuckets
);
10340 printf (_(" Length Number %% of total Coverage\n"));
10342 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10343 if (gnubuckets
[hn
] != 0)
10345 bfd_vma off
, length
= 1;
10347 for (off
= gnubuckets
[hn
] - gnusymidx
;
10348 (gnuchains
[off
] & 1) == 0; ++off
)
10350 lengths
[hn
] = length
;
10351 if (length
> maxlength
)
10352 maxlength
= length
;
10356 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10357 if (counts
== NULL
)
10360 error (_("Out of memory\n"));
10364 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10365 ++counts
[lengths
[hn
]];
10367 if (ngnubuckets
> 0)
10370 printf (" 0 %-10lu (%5.1f%%)\n",
10371 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
10372 for (j
= 1; j
<= maxlength
; ++j
)
10374 nzero_counts
+= counts
[j
] * j
;
10375 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10376 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
10377 (nzero_counts
* 100.0) / nsyms
);
10391 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
10395 if (dynamic_syminfo
== NULL
10397 /* No syminfo, this is ok. */
10400 /* There better should be a dynamic symbol section. */
10401 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
10405 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10406 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
10408 printf (_(" Num: Name BoundTo Flags\n"));
10409 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
10411 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
10413 printf ("%4d: ", i
);
10414 assert (i
< num_dynamic_syms
);
10415 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
10416 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
10418 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
10421 switch (dynamic_syminfo
[i
].si_boundto
)
10423 case SYMINFO_BT_SELF
:
10424 fputs ("SELF ", stdout
);
10426 case SYMINFO_BT_PARENT
:
10427 fputs ("PARENT ", stdout
);
10430 if (dynamic_syminfo
[i
].si_boundto
> 0
10431 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
10432 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
10434 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
10438 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
10442 if (flags
& SYMINFO_FLG_DIRECT
)
10443 printf (" DIRECT");
10444 if (flags
& SYMINFO_FLG_PASSTHRU
)
10445 printf (" PASSTHRU");
10446 if (flags
& SYMINFO_FLG_COPY
)
10448 if (flags
& SYMINFO_FLG_LAZYLOAD
)
10449 printf (" LAZYLOAD");
10457 /* Check to see if the given reloc needs to be handled in a target specific
10458 manner. If so then process the reloc and return TRUE otherwise return
10462 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
10463 unsigned char * start
,
10464 Elf_Internal_Sym
* symtab
)
10466 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
10468 switch (elf_header
.e_machine
)
10471 case EM_MSP430_OLD
:
10473 static Elf_Internal_Sym
* saved_sym
= NULL
;
10475 switch (reloc_type
)
10477 case 10: /* R_MSP430_SYM_DIFF */
10478 if (uses_msp430x_relocs ())
10480 case 21: /* R_MSP430X_SYM_DIFF */
10481 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10484 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10485 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10486 goto handle_sym_diff
;
10488 case 5: /* R_MSP430_16_BYTE */
10489 case 9: /* R_MSP430_8 */
10490 if (uses_msp430x_relocs ())
10492 goto handle_sym_diff
;
10494 case 2: /* R_MSP430_ABS16 */
10495 case 15: /* R_MSP430X_ABS16 */
10496 if (! uses_msp430x_relocs ())
10498 goto handle_sym_diff
;
10501 if (saved_sym
!= NULL
)
10505 value
= reloc
->r_addend
10506 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10507 - saved_sym
->st_value
);
10509 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10517 if (saved_sym
!= NULL
)
10518 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10525 case EM_CYGNUS_MN10300
:
10527 static Elf_Internal_Sym
* saved_sym
= NULL
;
10529 switch (reloc_type
)
10531 case 34: /* R_MN10300_ALIGN */
10533 case 33: /* R_MN10300_SYM_DIFF */
10534 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
10536 case 1: /* R_MN10300_32 */
10537 case 2: /* R_MN10300_16 */
10538 if (saved_sym
!= NULL
)
10542 value
= reloc
->r_addend
10543 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
10544 - saved_sym
->st_value
);
10546 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
10553 if (saved_sym
!= NULL
)
10554 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10564 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10565 DWARF debug sections. This is a target specific test. Note - we do not
10566 go through the whole including-target-headers-multiple-times route, (as
10567 we have already done with <elf/h8.h>) because this would become very
10568 messy and even then this function would have to contain target specific
10569 information (the names of the relocs instead of their numeric values).
10570 FIXME: This is not the correct way to solve this problem. The proper way
10571 is to have target specific reloc sizing and typing functions created by
10572 the reloc-macros.h header, in the same way that it already creates the
10573 reloc naming functions. */
10576 is_32bit_abs_reloc (unsigned int reloc_type
)
10578 switch (elf_header
.e_machine
)
10582 return reloc_type
== 1; /* R_386_32. */
10584 return reloc_type
== 1; /* R_68K_32. */
10586 return reloc_type
== 1; /* R_860_32. */
10588 return reloc_type
== 2; /* R_960_32. */
10590 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10592 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10594 return reloc_type
== 1; /* R_ARC_32. */
10596 return reloc_type
== 2; /* R_ARM_ABS32 */
10599 return reloc_type
== 1;
10600 case EM_ADAPTEVA_EPIPHANY
:
10601 return reloc_type
== 3;
10603 return reloc_type
== 0x12; /* R_byte4_data. */
10605 return reloc_type
== 3; /* R_CRIS_32. */
10607 return reloc_type
== 3; /* R_CR16_NUM32. */
10609 return reloc_type
== 15; /* R_CRX_NUM32. */
10610 case EM_CYGNUS_FRV
:
10611 return reloc_type
== 1;
10612 case EM_CYGNUS_D10V
:
10614 return reloc_type
== 6; /* R_D10V_32. */
10615 case EM_CYGNUS_D30V
:
10617 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10619 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10620 case EM_CYGNUS_FR30
:
10622 return reloc_type
== 3; /* R_FR30_32. */
10626 return reloc_type
== 1; /* R_H8_DIR32. */
10628 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10631 return reloc_type
== 2; /* R_IP2K_32. */
10633 return reloc_type
== 2; /* R_IQ2000_32. */
10634 case EM_LATTICEMICO32
:
10635 return reloc_type
== 3; /* R_LM32_32. */
10638 return reloc_type
== 3; /* R_M32C_32. */
10640 return reloc_type
== 34; /* R_M32R_32_RELA. */
10642 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10643 case EM_CYGNUS_MEP
:
10644 return reloc_type
== 4; /* R_MEP_32. */
10646 return reloc_type
== 2; /* R_METAG_ADDR32. */
10647 case EM_MICROBLAZE
:
10648 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10650 return reloc_type
== 2; /* R_MIPS_32. */
10652 return reloc_type
== 4; /* R_MMIX_32. */
10653 case EM_CYGNUS_MN10200
:
10655 return reloc_type
== 1; /* R_MN10200_32. */
10656 case EM_CYGNUS_MN10300
:
10658 return reloc_type
== 1; /* R_MN10300_32. */
10660 return reloc_type
== 1; /* R_MOXIE_32. */
10661 case EM_MSP430_OLD
:
10663 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10665 return reloc_type
== 2; /* R_MT_32. */
10667 return reloc_type
== 20; /* R_NDS32_RELA. */
10668 case EM_ALTERA_NIOS2
:
10669 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
10671 return reloc_type
== 1; /* R_NIOS_32. */
10673 return reloc_type
== 1; /* R_OR1K_32. */
10675 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10676 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10679 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10681 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10683 return reloc_type
== 1; /* R_PPC_ADDR32. */
10685 return reloc_type
== 1; /* R_RL78_DIR32. */
10687 return reloc_type
== 1; /* R_RX_DIR32. */
10689 return reloc_type
== 1; /* R_I370_ADDR31. */
10692 return reloc_type
== 4; /* R_S390_32. */
10694 return reloc_type
== 8; /* R_SCORE_ABS32. */
10696 return reloc_type
== 1; /* R_SH_DIR32. */
10697 case EM_SPARC32PLUS
:
10700 return reloc_type
== 3 /* R_SPARC_32. */
10701 || reloc_type
== 23; /* R_SPARC_UA32. */
10703 return reloc_type
== 6; /* R_SPU_ADDR32 */
10705 return reloc_type
== 1; /* R_C6000_ABS32. */
10707 return reloc_type
== 2; /* R_TILEGX_32. */
10709 return reloc_type
== 1; /* R_TILEPRO_32. */
10710 case EM_CYGNUS_V850
:
10712 return reloc_type
== 6; /* R_V850_ABS32. */
10714 return reloc_type
== 0x33; /* R_V810_WORD. */
10716 return reloc_type
== 1; /* R_VAX_32. */
10720 return reloc_type
== 10; /* R_X86_64_32. */
10723 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10725 return reloc_type
== 4; /* R_XGATE_32. */
10727 return reloc_type
== 1; /* R_XSTROMY16_32. */
10728 case EM_XTENSA_OLD
:
10730 return reloc_type
== 1; /* R_XTENSA_32. */
10732 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10733 elf_header
.e_machine
);
10738 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10739 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10742 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10744 switch (elf_header
.e_machine
)
10748 return reloc_type
== 2; /* R_386_PC32. */
10750 return reloc_type
== 4; /* R_68K_PC32. */
10752 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10753 case EM_ADAPTEVA_EPIPHANY
:
10754 return reloc_type
== 6;
10756 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10758 return reloc_type
== 3; /* R_ARM_REL32 */
10759 case EM_MICROBLAZE
:
10760 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10762 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
10764 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10766 return reloc_type
== 26; /* R_PPC_REL32. */
10768 return reloc_type
== 26; /* R_PPC64_REL32. */
10771 return reloc_type
== 5; /* R_390_PC32. */
10773 return reloc_type
== 2; /* R_SH_REL32. */
10774 case EM_SPARC32PLUS
:
10777 return reloc_type
== 6; /* R_SPARC_DISP32. */
10779 return reloc_type
== 13; /* R_SPU_REL32. */
10781 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10783 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10787 return reloc_type
== 2; /* R_X86_64_PC32. */
10788 case EM_XTENSA_OLD
:
10790 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10792 /* Do not abort or issue an error message here. Not all targets use
10793 pc-relative 32-bit relocs in their DWARF debug information and we
10794 have already tested for target coverage in is_32bit_abs_reloc. A
10795 more helpful warning message will be generated by apply_relocations
10796 anyway, so just return. */
10801 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10802 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10805 is_64bit_abs_reloc (unsigned int reloc_type
)
10807 switch (elf_header
.e_machine
)
10810 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10812 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10814 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10816 return reloc_type
== 80; /* R_PARISC_DIR64. */
10818 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10819 case EM_SPARC32PLUS
:
10822 return reloc_type
== 54; /* R_SPARC_UA64. */
10826 return reloc_type
== 1; /* R_X86_64_64. */
10829 return reloc_type
== 22; /* R_S390_64. */
10831 return reloc_type
== 1; /* R_TILEGX_64. */
10833 return reloc_type
== 18; /* R_MIPS_64. */
10839 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10840 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10843 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10845 switch (elf_header
.e_machine
)
10848 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10850 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10852 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10854 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10856 return reloc_type
== 44; /* R_PPC64_REL64. */
10857 case EM_SPARC32PLUS
:
10860 return reloc_type
== 46; /* R_SPARC_DISP64. */
10864 return reloc_type
== 24; /* R_X86_64_PC64. */
10867 return reloc_type
== 23; /* R_S390_PC64. */
10869 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10875 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10876 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10879 is_24bit_abs_reloc (unsigned int reloc_type
)
10881 switch (elf_header
.e_machine
)
10883 case EM_CYGNUS_MN10200
:
10885 return reloc_type
== 4; /* R_MN10200_24. */
10891 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10892 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10895 is_16bit_abs_reloc (unsigned int reloc_type
)
10897 switch (elf_header
.e_machine
)
10901 return reloc_type
== 4; /* R_AVR_16. */
10902 case EM_ADAPTEVA_EPIPHANY
:
10903 return reloc_type
== 5;
10904 case EM_CYGNUS_D10V
:
10906 return reloc_type
== 3; /* R_D10V_16. */
10910 return reloc_type
== R_H8_DIR16
;
10913 return reloc_type
== 1; /* R_IP2K_16. */
10916 return reloc_type
== 1; /* R_M32C_16 */
10918 if (uses_msp430x_relocs ())
10919 return reloc_type
== 2; /* R_MSP430_ABS16. */
10920 case EM_MSP430_OLD
:
10921 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10923 return reloc_type
== 19; /* R_NDS32_RELA. */
10924 case EM_ALTERA_NIOS2
:
10925 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
10927 return reloc_type
== 9; /* R_NIOS_16. */
10929 return reloc_type
== 2; /* R_OR1K_16. */
10931 return reloc_type
== 2; /* R_C6000_ABS16. */
10934 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10935 case EM_CYGNUS_MN10200
:
10937 return reloc_type
== 2; /* R_MN10200_16. */
10938 case EM_CYGNUS_MN10300
:
10940 return reloc_type
== 2; /* R_MN10300_16. */
10942 return reloc_type
== 3; /* R_XGATE_16. */
10948 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10949 relocation entries (possibly formerly used for SHT_GROUP sections). */
10952 is_none_reloc (unsigned int reloc_type
)
10954 switch (elf_header
.e_machine
)
10956 case EM_68K
: /* R_68K_NONE. */
10957 case EM_386
: /* R_386_NONE. */
10958 case EM_SPARC32PLUS
:
10960 case EM_SPARC
: /* R_SPARC_NONE. */
10961 case EM_MIPS
: /* R_MIPS_NONE. */
10962 case EM_PARISC
: /* R_PARISC_NONE. */
10963 case EM_ALPHA
: /* R_ALPHA_NONE. */
10964 case EM_ADAPTEVA_EPIPHANY
:
10965 case EM_PPC
: /* R_PPC_NONE. */
10966 case EM_PPC64
: /* R_PPC64_NONE. */
10967 case EM_ARM
: /* R_ARM_NONE. */
10968 case EM_IA_64
: /* R_IA64_NONE. */
10969 case EM_SH
: /* R_SH_NONE. */
10971 case EM_S390
: /* R_390_NONE. */
10972 case EM_CRIS
: /* R_CRIS_NONE. */
10973 case EM_X86_64
: /* R_X86_64_NONE. */
10974 case EM_L1OM
: /* R_X86_64_NONE. */
10975 case EM_K1OM
: /* R_X86_64_NONE. */
10976 case EM_MN10300
: /* R_MN10300_NONE. */
10977 case EM_MOXIE
: /* R_MOXIE_NONE. */
10978 case EM_M32R
: /* R_M32R_NONE. */
10979 case EM_TI_C6000
:/* R_C6000_NONE. */
10980 case EM_TILEGX
: /* R_TILEGX_NONE. */
10981 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10983 case EM_C166
: /* R_XC16X_NONE. */
10984 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
10985 case EM_NIOS32
: /* R_NIOS_NONE. */
10986 case EM_OR1K
: /* R_OR1K_NONE. */
10987 return reloc_type
== 0;
10989 return reloc_type
== 0 || reloc_type
== 256;
10991 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10992 || reloc_type
== 204 /* R_NDS32_DIFF8. */
10993 || reloc_type
== 205 /* R_NDS32_DIFF16. */
10994 || reloc_type
== 206 /* R_NDS32_DIFF32. */
10995 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
10996 case EM_XTENSA_OLD
:
10998 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10999 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11000 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11001 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11003 return reloc_type
== 3; /* R_METAG_NONE. */
11008 /* Apply relocations to a section.
11009 Note: So far support has been added only for those relocations
11010 which can be found in debug sections.
11011 FIXME: Add support for more relocations ? */
11014 apply_relocations (void * file
,
11015 Elf_Internal_Shdr
* section
,
11016 unsigned char * start
)
11018 Elf_Internal_Shdr
* relsec
;
11019 unsigned char * end
= start
+ section
->sh_size
;
11021 if (elf_header
.e_type
!= ET_REL
)
11024 /* Find the reloc section associated with the section. */
11025 for (relsec
= section_headers
;
11026 relsec
< section_headers
+ elf_header
.e_shnum
;
11029 bfd_boolean is_rela
;
11030 unsigned long num_relocs
;
11031 Elf_Internal_Rela
* relocs
;
11032 Elf_Internal_Rela
* rp
;
11033 Elf_Internal_Shdr
* symsec
;
11034 Elf_Internal_Sym
* symtab
;
11035 unsigned long num_syms
;
11036 Elf_Internal_Sym
* sym
;
11038 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11039 || relsec
->sh_info
>= elf_header
.e_shnum
11040 || section_headers
+ relsec
->sh_info
!= section
11041 || relsec
->sh_size
== 0
11042 || relsec
->sh_link
>= elf_header
.e_shnum
)
11045 is_rela
= relsec
->sh_type
== SHT_RELA
;
11049 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11050 relsec
->sh_size
, & relocs
, & num_relocs
))
11055 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11056 relsec
->sh_size
, & relocs
, & num_relocs
))
11060 /* SH uses RELA but uses in place value instead of the addend field. */
11061 if (elf_header
.e_machine
== EM_SH
)
11064 symsec
= section_headers
+ relsec
->sh_link
;
11065 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11067 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11070 unsigned int reloc_type
;
11071 unsigned int reloc_size
;
11072 unsigned char * rloc
;
11073 unsigned long sym_index
;
11075 reloc_type
= get_reloc_type (rp
->r_info
);
11077 if (target_specific_reloc_handling (rp
, start
, symtab
))
11079 else if (is_none_reloc (reloc_type
))
11081 else if (is_32bit_abs_reloc (reloc_type
)
11082 || is_32bit_pcrel_reloc (reloc_type
))
11084 else if (is_64bit_abs_reloc (reloc_type
)
11085 || is_64bit_pcrel_reloc (reloc_type
))
11087 else if (is_24bit_abs_reloc (reloc_type
))
11089 else if (is_16bit_abs_reloc (reloc_type
))
11093 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11094 reloc_type
, printable_section_name (section
));
11098 rloc
= start
+ rp
->r_offset
;
11099 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11101 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11102 (unsigned long) rp
->r_offset
,
11103 printable_section_name (section
));
11107 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11108 if (sym_index
>= num_syms
)
11110 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11111 sym_index
, printable_section_name (section
));
11114 sym
= symtab
+ sym_index
;
11116 /* If the reloc has a symbol associated with it,
11117 make sure that it is of an appropriate type.
11119 Relocations against symbols without type can happen.
11120 Gcc -feliminate-dwarf2-dups may generate symbols
11121 without type for debug info.
11123 Icc generates relocations against function symbols
11124 instead of local labels.
11126 Relocations against object symbols can happen, eg when
11127 referencing a global array. For an example of this see
11128 the _clz.o binary in libgcc.a. */
11130 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11132 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11133 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11134 (long int)(rp
- relocs
),
11135 printable_section_name (relsec
));
11141 addend
+= rp
->r_addend
;
11142 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11143 partial_inplace. */
11145 || (elf_header
.e_machine
== EM_XTENSA
11146 && reloc_type
== 1)
11147 || ((elf_header
.e_machine
== EM_PJ
11148 || elf_header
.e_machine
== EM_PJ_OLD
)
11149 && reloc_type
== 1)
11150 || ((elf_header
.e_machine
== EM_D30V
11151 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11152 && reloc_type
== 12))
11153 addend
+= byte_get (rloc
, reloc_size
);
11155 if (is_32bit_pcrel_reloc (reloc_type
)
11156 || is_64bit_pcrel_reloc (reloc_type
))
11158 /* On HPPA, all pc-relative relocations are biased by 8. */
11159 if (elf_header
.e_machine
== EM_PARISC
)
11161 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11165 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11174 #ifdef SUPPORT_DISASSEMBLY
11176 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11178 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11180 /* FIXME: XXX -- to be done --- XXX */
11186 /* Reads in the contents of SECTION from FILE, returning a pointer
11187 to a malloc'ed buffer or NULL if something went wrong. */
11190 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
11192 bfd_size_type num_bytes
;
11194 num_bytes
= section
->sh_size
;
11196 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
11198 printf (_("\nSection '%s' has no data to dump.\n"),
11199 printable_section_name (section
));
11203 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
11204 _("section contents"));
11209 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
11211 Elf_Internal_Shdr
* relsec
;
11212 bfd_size_type num_bytes
;
11216 bfd_boolean some_strings_shown
;
11218 start
= get_section_contents (section
, file
);
11222 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
11224 /* If the section being dumped has relocations against it the user might
11225 be expecting these relocations to have been applied. Check for this
11226 case and issue a warning message in order to avoid confusion.
11227 FIXME: Maybe we ought to have an option that dumps a section with
11228 relocs applied ? */
11229 for (relsec
= section_headers
;
11230 relsec
< section_headers
+ elf_header
.e_shnum
;
11233 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11234 || relsec
->sh_info
>= elf_header
.e_shnum
11235 || section_headers
+ relsec
->sh_info
!= section
11236 || relsec
->sh_size
== 0
11237 || relsec
->sh_link
>= elf_header
.e_shnum
)
11240 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11244 num_bytes
= section
->sh_size
;
11246 end
= start
+ num_bytes
;
11247 some_strings_shown
= FALSE
;
11251 while (!ISPRINT (* data
))
11252 if (++ data
>= end
)
11258 /* PR 11128: Use two separate invocations in order to work
11259 around bugs in the Solaris 8 implementation of printf. */
11260 printf (" [%6tx] ", data
- start
);
11261 printf ("%s\n", data
);
11263 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
11265 data
+= strlen (data
);
11266 some_strings_shown
= TRUE
;
11270 if (! some_strings_shown
)
11271 printf (_(" No strings found in this section."));
11279 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
11281 bfd_boolean relocate
)
11283 Elf_Internal_Shdr
* relsec
;
11284 bfd_size_type bytes
;
11286 unsigned char * data
;
11287 unsigned char * start
;
11289 start
= (unsigned char *) get_section_contents (section
, file
);
11293 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
11297 apply_relocations (file
, section
, start
);
11301 /* If the section being dumped has relocations against it the user might
11302 be expecting these relocations to have been applied. Check for this
11303 case and issue a warning message in order to avoid confusion.
11304 FIXME: Maybe we ought to have an option that dumps a section with
11305 relocs applied ? */
11306 for (relsec
= section_headers
;
11307 relsec
< section_headers
+ elf_header
.e_shnum
;
11310 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11311 || relsec
->sh_info
>= elf_header
.e_shnum
11312 || section_headers
+ relsec
->sh_info
!= section
11313 || relsec
->sh_size
== 0
11314 || relsec
->sh_link
>= elf_header
.e_shnum
)
11317 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11322 addr
= section
->sh_addr
;
11323 bytes
= section
->sh_size
;
11332 lbytes
= (bytes
> 16 ? 16 : bytes
);
11334 printf (" 0x%8.8lx ", (unsigned long) addr
);
11336 for (j
= 0; j
< 16; j
++)
11339 printf ("%2.2x", data
[j
]);
11347 for (j
= 0; j
< lbytes
; j
++)
11350 if (k
>= ' ' && k
< 0x7f)
11368 /* Uncompresses a section that was compressed using zlib, in place. */
11371 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
11372 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
11374 #ifndef HAVE_ZLIB_H
11377 dwarf_size_type compressed_size
= *size
;
11378 unsigned char * compressed_buffer
= *buffer
;
11379 dwarf_size_type uncompressed_size
;
11380 unsigned char * uncompressed_buffer
;
11383 dwarf_size_type header_size
= 12;
11385 /* Read the zlib header. In this case, it should be "ZLIB" followed
11386 by the uncompressed section size, 8 bytes in big-endian order. */
11387 if (compressed_size
< header_size
11388 || ! streq ((char *) compressed_buffer
, "ZLIB"))
11391 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
11392 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
11393 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
11394 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
11395 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
11396 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
11397 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
11398 uncompressed_size
+= compressed_buffer
[11];
11400 /* It is possible the section consists of several compressed
11401 buffers concatenated together, so we uncompress in a loop. */
11402 strm
.zalloc
= NULL
;
11404 strm
.opaque
= NULL
;
11405 strm
.avail_in
= compressed_size
- header_size
;
11406 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
11407 strm
.avail_out
= uncompressed_size
;
11408 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
11410 rc
= inflateInit (& strm
);
11411 while (strm
.avail_in
> 0)
11415 strm
.next_out
= ((Bytef
*) uncompressed_buffer
11416 + (uncompressed_size
- strm
.avail_out
));
11417 rc
= inflate (&strm
, Z_FINISH
);
11418 if (rc
!= Z_STREAM_END
)
11420 rc
= inflateReset (& strm
);
11422 rc
= inflateEnd (& strm
);
11424 || strm
.avail_out
!= 0)
11427 free (compressed_buffer
);
11428 *buffer
= uncompressed_buffer
;
11429 *size
= uncompressed_size
;
11433 free (uncompressed_buffer
);
11434 /* Indicate decompression failure. */
11437 #endif /* HAVE_ZLIB_H */
11441 load_specific_debug_section (enum dwarf_section_display_enum debug
,
11442 Elf_Internal_Shdr
* sec
, void * file
)
11444 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11447 /* If it is already loaded, do nothing. */
11448 if (section
->start
!= NULL
)
11451 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
11452 section
->address
= sec
->sh_addr
;
11453 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
11455 sec
->sh_size
, buf
);
11456 if (section
->start
== NULL
)
11460 section
->size
= sec
->sh_size
;
11461 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
11462 sec
->sh_size
= section
->size
;
11465 if (section
->start
== NULL
)
11468 if (debug_displays
[debug
].relocate
)
11469 apply_relocations ((FILE *) file
, sec
, section
->start
);
11474 /* If this is not NULL, load_debug_section will only look for sections
11475 within the list of sections given here. */
11476 unsigned int *section_subset
= NULL
;
11479 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
11481 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11482 Elf_Internal_Shdr
* sec
;
11484 /* Locate the debug section. */
11485 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
11487 section
->name
= section
->uncompressed_name
;
11490 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
11492 section
->name
= section
->compressed_name
;
11497 /* If we're loading from a subset of sections, and we've loaded
11498 a section matching this name before, it's likely that it's a
11500 if (section_subset
!= NULL
)
11501 free_debug_section (debug
);
11503 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
11507 free_debug_section (enum dwarf_section_display_enum debug
)
11509 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
11511 if (section
->start
== NULL
)
11514 free ((char *) section
->start
);
11515 section
->start
= NULL
;
11516 section
->address
= 0;
11521 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
11523 char * name
= SECTION_NAME (section
);
11524 const char * print_name
= printable_section_name (section
);
11525 bfd_size_type length
;
11529 length
= section
->sh_size
;
11532 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
11535 if (section
->sh_type
== SHT_NOBITS
)
11537 /* There is no point in dumping the contents of a debugging section
11538 which has the NOBITS type - the bits in the file will be random.
11539 This can happen when a file containing a .eh_frame section is
11540 stripped with the --only-keep-debug command line option. */
11541 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
11546 if (const_strneq (name
, ".gnu.linkonce.wi."))
11547 name
= ".debug_info";
11549 /* See if we know how to display the contents of this section. */
11550 for (i
= 0; i
< max
; i
++)
11551 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
11552 || (i
== line
&& const_strneq (name
, ".debug_line."))
11553 || streq (debug_displays
[i
].section
.compressed_name
, name
))
11555 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
11556 int secondary
= (section
!= find_section (name
));
11559 free_debug_section ((enum dwarf_section_display_enum
) i
);
11561 if (i
== line
&& const_strneq (name
, ".debug_line."))
11563 else if (streq (sec
->uncompressed_name
, name
))
11564 sec
->name
= sec
->uncompressed_name
;
11566 sec
->name
= sec
->compressed_name
;
11567 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
11570 /* If this debug section is part of a CU/TU set in a .dwp file,
11571 restrict load_debug_section to the sections in that set. */
11572 section_subset
= find_cu_tu_set (file
, shndx
);
11574 result
&= debug_displays
[i
].display (sec
, file
);
11576 section_subset
= NULL
;
11578 if (secondary
|| (i
!= info
&& i
!= abbrev
))
11579 free_debug_section ((enum dwarf_section_display_enum
) i
);
11587 printf (_("Unrecognized debug section: %s\n"), print_name
);
11594 /* Set DUMP_SECTS for all sections where dumps were requested
11595 based on section name. */
11598 initialise_dumps_byname (void)
11600 struct dump_list_entry
* cur
;
11602 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11607 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11608 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11610 request_dump_bynumber (i
, cur
->type
);
11615 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11621 process_section_contents (FILE * file
)
11623 Elf_Internal_Shdr
* section
;
11629 initialise_dumps_byname ();
11631 for (i
= 0, section
= section_headers
;
11632 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11635 #ifdef SUPPORT_DISASSEMBLY
11636 if (dump_sects
[i
] & DISASS_DUMP
)
11637 disassemble_section (section
, file
);
11639 if (dump_sects
[i
] & HEX_DUMP
)
11640 dump_section_as_bytes (section
, file
, FALSE
);
11642 if (dump_sects
[i
] & RELOC_DUMP
)
11643 dump_section_as_bytes (section
, file
, TRUE
);
11645 if (dump_sects
[i
] & STRING_DUMP
)
11646 dump_section_as_strings (section
, file
);
11648 if (dump_sects
[i
] & DEBUG_DUMP
)
11649 display_debug_section (i
, section
, file
);
11652 /* Check to see if the user requested a
11653 dump of a section that does not exist. */
11654 while (i
++ < num_dump_sects
)
11656 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11660 process_mips_fpe_exception (int mask
)
11665 if (mask
& OEX_FPU_INEX
)
11666 fputs ("INEX", stdout
), first
= 0;
11667 if (mask
& OEX_FPU_UFLO
)
11668 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11669 if (mask
& OEX_FPU_OFLO
)
11670 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11671 if (mask
& OEX_FPU_DIV0
)
11672 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11673 if (mask
& OEX_FPU_INVAL
)
11674 printf ("%sINVAL", first
? "" : "|");
11677 fputs ("0", stdout
);
11680 /* Display's the value of TAG at location P. If TAG is
11681 greater than 0 it is assumed to be an unknown tag, and
11682 a message is printed to this effect. Otherwise it is
11683 assumed that a message has already been printed.
11685 If the bottom bit of TAG is set it assumed to have a
11686 string value, otherwise it is assumed to have an integer
11689 Returns an updated P pointing to the first unread byte
11690 beyond the end of TAG's value.
11692 Reads at or beyond END will not be made. */
11694 static unsigned char *
11695 display_tag_value (int tag
,
11697 const unsigned char * const end
)
11702 printf (" Tag_unknown_%d: ", tag
);
11706 warn (_("corrupt tag\n"));
11710 /* FIXME: we could read beyond END here. */
11711 printf ("\"%s\"\n", p
);
11712 p
+= strlen ((char *) p
) + 1;
11718 val
= read_uleb128 (p
, &len
, end
);
11720 printf ("%ld (0x%lx)\n", val
, val
);
11726 /* ARM EABI attributes section. */
11731 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11733 const char ** table
;
11734 } arm_attr_public_tag
;
11736 static const char * arm_attr_tag_CPU_arch
[] =
11737 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11738 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11739 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11740 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11741 {"No", "Thumb-1", "Thumb-2"};
11742 static const char * arm_attr_tag_FP_arch
[] =
11743 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11745 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11746 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11747 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11748 static const char * arm_attr_tag_PCS_config
[] =
11749 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11750 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11751 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11752 {"V6", "SB", "TLS", "Unused"};
11753 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11754 {"Absolute", "PC-relative", "SB-relative", "None"};
11755 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11756 {"Absolute", "PC-relative", "None"};
11757 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11758 {"None", "direct", "GOT-indirect"};
11759 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11760 {"None", "??? 1", "2", "??? 3", "4"};
11761 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11762 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11763 {"Unused", "Needed", "Sign only"};
11764 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11765 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11766 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11767 {"Unused", "Finite", "RTABI", "IEEE 754"};
11768 static const char * arm_attr_tag_ABI_enum_size
[] =
11769 {"Unused", "small", "int", "forced to int"};
11770 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11771 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11772 static const char * arm_attr_tag_ABI_VFP_args
[] =
11773 {"AAPCS", "VFP registers", "custom"};
11774 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11775 {"AAPCS", "WMMX registers", "custom"};
11776 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11777 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11778 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11779 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11780 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11781 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11782 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11783 static const char * arm_attr_tag_FP_HP_extension
[] =
11784 {"Not Allowed", "Allowed"};
11785 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11786 {"None", "IEEE 754", "Alternative Format"};
11787 static const char * arm_attr_tag_MPextension_use
[] =
11788 {"Not Allowed", "Allowed"};
11789 static const char * arm_attr_tag_DIV_use
[] =
11790 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11791 "Allowed in v7-A with integer division extension"};
11792 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11793 static const char * arm_attr_tag_Virtualization_use
[] =
11794 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11795 "TrustZone and Virtualization Extensions"};
11796 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11797 {"Not Allowed", "Allowed"};
11799 #define LOOKUP(id, name) \
11800 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11801 static arm_attr_public_tag arm_attr_public_tags
[] =
11803 {4, "CPU_raw_name", 1, NULL
},
11804 {5, "CPU_name", 1, NULL
},
11805 LOOKUP(6, CPU_arch
),
11806 {7, "CPU_arch_profile", 0, NULL
},
11807 LOOKUP(8, ARM_ISA_use
),
11808 LOOKUP(9, THUMB_ISA_use
),
11809 LOOKUP(10, FP_arch
),
11810 LOOKUP(11, WMMX_arch
),
11811 LOOKUP(12, Advanced_SIMD_arch
),
11812 LOOKUP(13, PCS_config
),
11813 LOOKUP(14, ABI_PCS_R9_use
),
11814 LOOKUP(15, ABI_PCS_RW_data
),
11815 LOOKUP(16, ABI_PCS_RO_data
),
11816 LOOKUP(17, ABI_PCS_GOT_use
),
11817 LOOKUP(18, ABI_PCS_wchar_t
),
11818 LOOKUP(19, ABI_FP_rounding
),
11819 LOOKUP(20, ABI_FP_denormal
),
11820 LOOKUP(21, ABI_FP_exceptions
),
11821 LOOKUP(22, ABI_FP_user_exceptions
),
11822 LOOKUP(23, ABI_FP_number_model
),
11823 {24, "ABI_align_needed", 0, NULL
},
11824 {25, "ABI_align_preserved", 0, NULL
},
11825 LOOKUP(26, ABI_enum_size
),
11826 LOOKUP(27, ABI_HardFP_use
),
11827 LOOKUP(28, ABI_VFP_args
),
11828 LOOKUP(29, ABI_WMMX_args
),
11829 LOOKUP(30, ABI_optimization_goals
),
11830 LOOKUP(31, ABI_FP_optimization_goals
),
11831 {32, "compatibility", 0, NULL
},
11832 LOOKUP(34, CPU_unaligned_access
),
11833 LOOKUP(36, FP_HP_extension
),
11834 LOOKUP(38, ABI_FP_16bit_format
),
11835 LOOKUP(42, MPextension_use
),
11836 LOOKUP(44, DIV_use
),
11837 {64, "nodefaults", 0, NULL
},
11838 {65, "also_compatible_with", 0, NULL
},
11839 LOOKUP(66, T2EE_use
),
11840 {67, "conformance", 1, NULL
},
11841 LOOKUP(68, Virtualization_use
),
11842 LOOKUP(70, MPextension_use_legacy
)
11846 static unsigned char *
11847 display_arm_attribute (unsigned char * p
,
11848 const unsigned char * const end
)
11853 arm_attr_public_tag
* attr
;
11857 tag
= read_uleb128 (p
, &len
, end
);
11860 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11862 if (arm_attr_public_tags
[i
].tag
== tag
)
11864 attr
= &arm_attr_public_tags
[i
];
11871 printf (" Tag_%s: ", attr
->name
);
11872 switch (attr
->type
)
11877 case 7: /* Tag_CPU_arch_profile. */
11878 val
= read_uleb128 (p
, &len
, end
);
11882 case 0: printf (_("None\n")); break;
11883 case 'A': printf (_("Application\n")); break;
11884 case 'R': printf (_("Realtime\n")); break;
11885 case 'M': printf (_("Microcontroller\n")); break;
11886 case 'S': printf (_("Application or Realtime\n")); break;
11887 default: printf ("??? (%d)\n", val
); break;
11891 case 24: /* Tag_align_needed. */
11892 val
= read_uleb128 (p
, &len
, end
);
11896 case 0: printf (_("None\n")); break;
11897 case 1: printf (_("8-byte\n")); break;
11898 case 2: printf (_("4-byte\n")); break;
11899 case 3: printf ("??? 3\n"); break;
11902 printf (_("8-byte and up to %d-byte extended\n"),
11905 printf ("??? (%d)\n", val
);
11910 case 25: /* Tag_align_preserved. */
11911 val
= read_uleb128 (p
, &len
, end
);
11915 case 0: printf (_("None\n")); break;
11916 case 1: printf (_("8-byte, except leaf SP\n")); break;
11917 case 2: printf (_("8-byte\n")); break;
11918 case 3: printf ("??? 3\n"); break;
11921 printf (_("8-byte and up to %d-byte extended\n"),
11924 printf ("??? (%d)\n", val
);
11929 case 32: /* Tag_compatibility. */
11930 val
= read_uleb128 (p
, &len
, end
);
11932 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11933 p
+= strlen ((char *) p
) + 1;
11936 case 64: /* Tag_nodefaults. */
11938 printf (_("True\n"));
11941 case 65: /* Tag_also_compatible_with. */
11942 val
= read_uleb128 (p
, &len
, end
);
11944 if (val
== 6 /* Tag_CPU_arch. */)
11946 val
= read_uleb128 (p
, &len
, end
);
11948 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11949 printf ("??? (%d)\n", val
);
11951 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11955 while (*(p
++) != '\0' /* NUL terminator. */);
11964 return display_tag_value (-1, p
, end
);
11966 return display_tag_value (0, p
, end
);
11969 assert (attr
->type
& 0x80);
11970 val
= read_uleb128 (p
, &len
, end
);
11972 type
= attr
->type
& 0x7f;
11974 printf ("??? (%d)\n", val
);
11976 printf ("%s\n", attr
->table
[val
]);
11981 return display_tag_value (tag
, p
, end
);
11984 static unsigned char *
11985 display_gnu_attribute (unsigned char * p
,
11986 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
11987 const unsigned char * const end
)
11993 tag
= read_uleb128 (p
, &len
, end
);
11996 /* Tag_compatibility is the only generic GNU attribute defined at
12000 val
= read_uleb128 (p
, &len
, end
);
12004 printf (_("flag = %d, vendor = <corrupt>\n"), val
);
12005 warn (_("corrupt vendor attribute\n"));
12009 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12010 p
+= strlen ((char *) p
) + 1;
12015 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
12016 return display_proc_gnu_attribute (p
, tag
, end
);
12018 return display_tag_value (tag
, p
, end
);
12021 static unsigned char *
12022 display_power_gnu_attribute (unsigned char * p
,
12024 const unsigned char * const end
)
12029 if (tag
== Tag_GNU_Power_ABI_FP
)
12031 val
= read_uleb128 (p
, &len
, end
);
12033 printf (" Tag_GNU_Power_ABI_FP: ");
12038 printf (_("Hard or soft float\n"));
12041 printf (_("Hard float\n"));
12044 printf (_("Soft float\n"));
12047 printf (_("Single-precision hard float\n"));
12050 printf ("??? (%d)\n", val
);
12056 if (tag
== Tag_GNU_Power_ABI_Vector
)
12058 val
= read_uleb128 (p
, &len
, end
);
12060 printf (" Tag_GNU_Power_ABI_Vector: ");
12064 printf (_("Any\n"));
12067 printf (_("Generic\n"));
12070 printf ("AltiVec\n");
12076 printf ("??? (%d)\n", val
);
12082 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
12086 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
12090 val
= read_uleb128 (p
, &len
, end
);
12092 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12096 printf (_("Any\n"));
12099 printf ("r3/r4\n");
12102 printf (_("Memory\n"));
12105 printf ("??? (%d)\n", val
);
12111 return display_tag_value (tag
& 1, p
, end
);
12115 display_sparc_hwcaps (int mask
)
12120 if (mask
& ELF_SPARC_HWCAP_MUL32
)
12121 fputs ("mul32", stdout
), first
= 0;
12122 if (mask
& ELF_SPARC_HWCAP_DIV32
)
12123 printf ("%sdiv32", first
? "" : "|"), first
= 0;
12124 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
12125 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
12126 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
12127 printf ("%sv8plus", first
? "" : "|"), first
= 0;
12128 if (mask
& ELF_SPARC_HWCAP_POPC
)
12129 printf ("%spopc", first
? "" : "|"), first
= 0;
12130 if (mask
& ELF_SPARC_HWCAP_VIS
)
12131 printf ("%svis", first
? "" : "|"), first
= 0;
12132 if (mask
& ELF_SPARC_HWCAP_VIS2
)
12133 printf ("%svis2", first
? "" : "|"), first
= 0;
12134 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
12135 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
12136 if (mask
& ELF_SPARC_HWCAP_FMAF
)
12137 printf ("%sfmaf", first
? "" : "|"), first
= 0;
12138 if (mask
& ELF_SPARC_HWCAP_VIS3
)
12139 printf ("%svis3", first
? "" : "|"), first
= 0;
12140 if (mask
& ELF_SPARC_HWCAP_HPC
)
12141 printf ("%shpc", first
? "" : "|"), first
= 0;
12142 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
12143 printf ("%srandom", first
? "" : "|"), first
= 0;
12144 if (mask
& ELF_SPARC_HWCAP_TRANS
)
12145 printf ("%strans", first
? "" : "|"), first
= 0;
12146 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
12147 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
12148 if (mask
& ELF_SPARC_HWCAP_IMA
)
12149 printf ("%sima", first
? "" : "|"), first
= 0;
12150 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
12151 printf ("%scspare", first
? "" : "|"), first
= 0;
12154 fputc('0', stdout
);
12155 fputc('\n', stdout
);
12159 display_sparc_hwcaps2 (int mask
)
12164 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
12165 fputs ("fjathplus", stdout
), first
= 0;
12166 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
12167 printf ("%svis3b", first
? "" : "|"), first
= 0;
12168 if (mask
& ELF_SPARC_HWCAP2_ADP
)
12169 printf ("%sadp", first
? "" : "|"), first
= 0;
12170 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
12171 printf ("%ssparc5", first
? "" : "|"), first
= 0;
12172 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
12173 printf ("%smwait", first
? "" : "|"), first
= 0;
12174 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
12175 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
12176 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
12177 printf ("%sxmont2", first
? "" : "|"), first
= 0;
12178 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
12179 printf ("%snsec", first
? "" : "|"), first
= 0;
12180 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
12181 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
12182 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
12183 printf ("%sfjdes", first
? "" : "|"), first
= 0;
12184 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
12185 printf ("%sfjaes", first
? "" : "|"), first
= 0;
12188 fputc('0', stdout
);
12189 fputc('\n', stdout
);
12192 static unsigned char *
12193 display_sparc_gnu_attribute (unsigned char * p
,
12195 const unsigned char * const end
)
12200 if (tag
== Tag_GNU_Sparc_HWCAPS
)
12202 val
= read_uleb128 (p
, &len
, end
);
12204 printf (" Tag_GNU_Sparc_HWCAPS: ");
12205 display_sparc_hwcaps (val
);
12208 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
12210 val
= read_uleb128 (p
, &len
, end
);
12212 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12213 display_sparc_hwcaps2 (val
);
12217 return display_tag_value (tag
, p
, end
);
12221 print_mips_fp_abi_value (int val
)
12225 case Val_GNU_MIPS_ABI_FP_ANY
:
12226 printf (_("Hard or soft float\n"));
12228 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
12229 printf (_("Hard float (double precision)\n"));
12231 case Val_GNU_MIPS_ABI_FP_SINGLE
:
12232 printf (_("Hard float (single precision)\n"));
12234 case Val_GNU_MIPS_ABI_FP_SOFT
:
12235 printf (_("Soft float\n"));
12237 case Val_GNU_MIPS_ABI_FP_OLD_64
:
12238 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12240 case Val_GNU_MIPS_ABI_FP_XX
:
12241 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12243 case Val_GNU_MIPS_ABI_FP_64
:
12244 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12246 case Val_GNU_MIPS_ABI_FP_64A
:
12247 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12250 printf ("??? (%d)\n", val
);
12255 static unsigned char *
12256 display_mips_gnu_attribute (unsigned char * p
,
12258 const unsigned char * const end
)
12260 if (tag
== Tag_GNU_MIPS_ABI_FP
)
12265 val
= read_uleb128 (p
, &len
, end
);
12267 printf (" Tag_GNU_MIPS_ABI_FP: ");
12269 print_mips_fp_abi_value (val
);
12274 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
12279 val
= read_uleb128 (p
, &len
, end
);
12281 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12285 case Val_GNU_MIPS_ABI_MSA_ANY
:
12286 printf (_("Any MSA or not\n"));
12288 case Val_GNU_MIPS_ABI_MSA_128
:
12289 printf (_("128-bit MSA\n"));
12292 printf ("??? (%d)\n", val
);
12298 return display_tag_value (tag
& 1, p
, end
);
12301 static unsigned char *
12302 display_tic6x_attribute (unsigned char * p
,
12303 const unsigned char * const end
)
12309 tag
= read_uleb128 (p
, &len
, end
);
12315 val
= read_uleb128 (p
, &len
, end
);
12317 printf (" Tag_ISA: ");
12321 case C6XABI_Tag_ISA_none
:
12322 printf (_("None\n"));
12324 case C6XABI_Tag_ISA_C62X
:
12327 case C6XABI_Tag_ISA_C67X
:
12330 case C6XABI_Tag_ISA_C67XP
:
12331 printf ("C67x+\n");
12333 case C6XABI_Tag_ISA_C64X
:
12336 case C6XABI_Tag_ISA_C64XP
:
12337 printf ("C64x+\n");
12339 case C6XABI_Tag_ISA_C674X
:
12340 printf ("C674x\n");
12343 printf ("??? (%d)\n", val
);
12348 case Tag_ABI_wchar_t
:
12349 val
= read_uleb128 (p
, &len
, end
);
12351 printf (" Tag_ABI_wchar_t: ");
12355 printf (_("Not used\n"));
12358 printf (_("2 bytes\n"));
12361 printf (_("4 bytes\n"));
12364 printf ("??? (%d)\n", val
);
12369 case Tag_ABI_stack_align_needed
:
12370 val
= read_uleb128 (p
, &len
, end
);
12372 printf (" Tag_ABI_stack_align_needed: ");
12376 printf (_("8-byte\n"));
12379 printf (_("16-byte\n"));
12382 printf ("??? (%d)\n", val
);
12387 case Tag_ABI_stack_align_preserved
:
12388 val
= read_uleb128 (p
, &len
, end
);
12390 printf (" Tag_ABI_stack_align_preserved: ");
12394 printf (_("8-byte\n"));
12397 printf (_("16-byte\n"));
12400 printf ("??? (%d)\n", val
);
12406 val
= read_uleb128 (p
, &len
, end
);
12408 printf (" Tag_ABI_DSBT: ");
12412 printf (_("DSBT addressing not used\n"));
12415 printf (_("DSBT addressing used\n"));
12418 printf ("??? (%d)\n", val
);
12424 val
= read_uleb128 (p
, &len
, end
);
12426 printf (" Tag_ABI_PID: ");
12430 printf (_("Data addressing position-dependent\n"));
12433 printf (_("Data addressing position-independent, GOT near DP\n"));
12436 printf (_("Data addressing position-independent, GOT far from DP\n"));
12439 printf ("??? (%d)\n", val
);
12445 val
= read_uleb128 (p
, &len
, end
);
12447 printf (" Tag_ABI_PIC: ");
12451 printf (_("Code addressing position-dependent\n"));
12454 printf (_("Code addressing position-independent\n"));
12457 printf ("??? (%d)\n", val
);
12462 case Tag_ABI_array_object_alignment
:
12463 val
= read_uleb128 (p
, &len
, end
);
12465 printf (" Tag_ABI_array_object_alignment: ");
12469 printf (_("8-byte\n"));
12472 printf (_("4-byte\n"));
12475 printf (_("16-byte\n"));
12478 printf ("??? (%d)\n", val
);
12483 case Tag_ABI_array_object_align_expected
:
12484 val
= read_uleb128 (p
, &len
, end
);
12486 printf (" Tag_ABI_array_object_align_expected: ");
12490 printf (_("8-byte\n"));
12493 printf (_("4-byte\n"));
12496 printf (_("16-byte\n"));
12499 printf ("??? (%d)\n", val
);
12504 case Tag_ABI_compatibility
:
12505 val
= read_uleb128 (p
, &len
, end
);
12507 printf (" Tag_ABI_compatibility: ");
12508 printf (_("flag = %d, vendor = %s\n"), val
, p
);
12509 p
+= strlen ((char *) p
) + 1;
12512 case Tag_ABI_conformance
:
12513 printf (" Tag_ABI_conformance: ");
12514 printf ("\"%s\"\n", p
);
12515 p
+= strlen ((char *) p
) + 1;
12519 return display_tag_value (tag
, p
, end
);
12523 display_raw_attribute (unsigned char * p
, unsigned char * end
)
12525 unsigned long addr
= 0;
12526 size_t bytes
= end
- p
;
12533 int lbytes
= (bytes
> 16 ? 16 : bytes
);
12535 printf (" 0x%8.8lx ", addr
);
12537 for (j
= 0; j
< 16; j
++)
12540 printf ("%2.2x", p
[j
]);
12548 for (j
= 0; j
< lbytes
; j
++)
12551 if (k
>= ' ' && k
< 0x7f)
12567 static unsigned char *
12568 display_msp430x_attribute (unsigned char * p
,
12569 const unsigned char * const end
)
12575 tag
= read_uleb128 (p
, & len
, end
);
12580 case OFBA_MSPABI_Tag_ISA
:
12581 val
= read_uleb128 (p
, &len
, end
);
12583 printf (" Tag_ISA: ");
12586 case 0: printf (_("None\n")); break;
12587 case 1: printf (_("MSP430\n")); break;
12588 case 2: printf (_("MSP430X\n")); break;
12589 default: printf ("??? (%d)\n", val
); break;
12593 case OFBA_MSPABI_Tag_Code_Model
:
12594 val
= read_uleb128 (p
, &len
, end
);
12596 printf (" Tag_Code_Model: ");
12599 case 0: printf (_("None\n")); break;
12600 case 1: printf (_("Small\n")); break;
12601 case 2: printf (_("Large\n")); break;
12602 default: printf ("??? (%d)\n", val
); break;
12606 case OFBA_MSPABI_Tag_Data_Model
:
12607 val
= read_uleb128 (p
, &len
, end
);
12609 printf (" Tag_Data_Model: ");
12612 case 0: printf (_("None\n")); break;
12613 case 1: printf (_("Small\n")); break;
12614 case 2: printf (_("Large\n")); break;
12615 case 3: printf (_("Restricted Large\n")); break;
12616 default: printf ("??? (%d)\n", val
); break;
12621 printf (_(" <unknown tag %d>: "), tag
);
12625 printf ("\"%s\"\n", p
);
12626 p
+= strlen ((char *) p
) + 1;
12630 val
= read_uleb128 (p
, &len
, end
);
12632 printf ("%d (0x%x)\n", val
, val
);
12641 process_attributes (FILE * file
,
12642 const char * public_name
,
12643 unsigned int proc_type
,
12644 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
12645 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
12647 Elf_Internal_Shdr
* sect
;
12648 unsigned char * contents
;
12650 unsigned char * end
;
12651 bfd_vma section_len
;
12655 /* Find the section header so that we get the size. */
12656 for (i
= 0, sect
= section_headers
;
12657 i
< elf_header
.e_shnum
;
12660 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
12663 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
12664 sect
->sh_size
, _("attributes"));
12665 if (contents
== NULL
)
12671 len
= sect
->sh_size
- 1;
12676 unsigned int namelen
;
12677 bfd_boolean public_section
;
12678 bfd_boolean gnu_section
;
12682 error (_("Tag section ends prematurely\n"));
12685 section_len
= byte_get (p
, 4);
12688 if (section_len
> len
)
12690 error (_("Length of attribute (%u) greater than length of section (%u)\n"),
12691 (unsigned) section_len
, (unsigned) len
);
12694 /* PR 17531: file: 001-101425-0.004 */
12695 else if (section_len
< 5)
12697 error (_("Attribute length of %u is too small\n"), (unsigned) section_len
);
12701 len
-= section_len
;
12704 namelen
= strnlen ((char *) p
, section_len
) + 1;
12705 if (namelen
== 0 || namelen
>= section_len
)
12707 error (_("Corrupt attribute section name\n"));
12711 printf (_("Attribute Section: %s\n"), p
);
12713 if (public_name
&& streq ((char *) p
, public_name
))
12714 public_section
= TRUE
;
12716 public_section
= FALSE
;
12718 if (streq ((char *) p
, "gnu"))
12719 gnu_section
= TRUE
;
12721 gnu_section
= FALSE
;
12724 section_len
-= namelen
;
12726 while (section_len
> 0)
12732 /* PR binutils/17531: Safe handling of corrupt files. */
12733 if (section_len
< 6)
12735 error (_("Unused bytes at end of section\n"));
12741 size
= byte_get (p
, 4);
12742 if (size
> section_len
)
12744 error (_("Bad subsection length (%u > %u)\n"),
12745 (unsigned) size
, (unsigned) section_len
);
12746 size
= section_len
;
12748 /* PR binutils/17531: Safe handling of corrupt files. */
12751 error (_("Bad subsection length (%u < 6)\n"),
12757 section_len
-= size
;
12758 end
= p
+ size
- 1;
12764 printf (_("File Attributes\n"));
12767 printf (_("Section Attributes:"));
12770 printf (_("Symbol Attributes:"));
12776 val
= read_uleb128 (p
, &j
, end
);
12780 printf (" %d", val
);
12785 printf (_("Unknown tag: %d\n"), tag
);
12786 public_section
= FALSE
;
12790 if (public_section
)
12793 p
= display_pub_attribute (p
, end
);
12795 else if (gnu_section
)
12798 p
= display_gnu_attribute (p
,
12799 display_proc_gnu_attribute
,
12804 printf (_(" Unknown section contexts\n"));
12805 display_raw_attribute (p
, end
);
12812 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
12820 process_arm_specific (FILE * file
)
12822 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12823 display_arm_attribute
, NULL
);
12827 process_power_specific (FILE * file
)
12829 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12830 display_power_gnu_attribute
);
12834 process_sparc_specific (FILE * file
)
12836 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12837 display_sparc_gnu_attribute
);
12841 process_tic6x_specific (FILE * file
)
12843 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12844 display_tic6x_attribute
, NULL
);
12848 process_msp430x_specific (FILE * file
)
12850 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
12851 display_msp430x_attribute
, NULL
);
12854 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12855 Print the Address, Access and Initial fields of an entry at VMA ADDR
12856 and return the VMA of the next entry. */
12859 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12862 print_vma (addr
, LONG_HEX
);
12864 if (addr
< pltgot
+ 0xfff0)
12865 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12867 printf ("%10s", "");
12870 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12875 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12876 print_vma (entry
, LONG_HEX
);
12878 return addr
+ (is_32bit_elf
? 4 : 8);
12881 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12882 PLTGOT. Print the Address and Initial fields of an entry at VMA
12883 ADDR and return the VMA of the next entry. */
12886 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12889 print_vma (addr
, LONG_HEX
);
12892 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12897 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12898 print_vma (entry
, LONG_HEX
);
12900 return addr
+ (is_32bit_elf
? 4 : 8);
12904 print_mips_ases (unsigned int mask
)
12906 if (mask
& AFL_ASE_DSP
)
12907 fputs ("\n\tDSP ASE", stdout
);
12908 if (mask
& AFL_ASE_DSPR2
)
12909 fputs ("\n\tDSP R2 ASE", stdout
);
12910 if (mask
& AFL_ASE_EVA
)
12911 fputs ("\n\tEnhanced VA Scheme", stdout
);
12912 if (mask
& AFL_ASE_MCU
)
12913 fputs ("\n\tMCU (MicroController) ASE", stdout
);
12914 if (mask
& AFL_ASE_MDMX
)
12915 fputs ("\n\tMDMX ASE", stdout
);
12916 if (mask
& AFL_ASE_MIPS3D
)
12917 fputs ("\n\tMIPS-3D ASE", stdout
);
12918 if (mask
& AFL_ASE_MT
)
12919 fputs ("\n\tMT ASE", stdout
);
12920 if (mask
& AFL_ASE_SMARTMIPS
)
12921 fputs ("\n\tSmartMIPS ASE", stdout
);
12922 if (mask
& AFL_ASE_VIRT
)
12923 fputs ("\n\tVZ ASE", stdout
);
12924 if (mask
& AFL_ASE_MSA
)
12925 fputs ("\n\tMSA ASE", stdout
);
12926 if (mask
& AFL_ASE_MIPS16
)
12927 fputs ("\n\tMIPS16 ASE", stdout
);
12928 if (mask
& AFL_ASE_MICROMIPS
)
12929 fputs ("\n\tMICROMIPS ASE", stdout
);
12930 if (mask
& AFL_ASE_XPA
)
12931 fputs ("\n\tXPA ASE", stdout
);
12933 fprintf (stdout
, "\n\t%s", _("None"));
12934 else if ((mask
& ~AFL_ASE_MASK
) != 0)
12935 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
12939 print_mips_isa_ext (unsigned int isa_ext
)
12944 fputs (_("None"), stdout
);
12947 fputs ("RMI XLR", stdout
);
12949 case AFL_EXT_OCTEON3
:
12950 fputs ("Cavium Networks Octeon3", stdout
);
12952 case AFL_EXT_OCTEON2
:
12953 fputs ("Cavium Networks Octeon2", stdout
);
12955 case AFL_EXT_OCTEONP
:
12956 fputs ("Cavium Networks OcteonP", stdout
);
12958 case AFL_EXT_LOONGSON_3A
:
12959 fputs ("Loongson 3A", stdout
);
12961 case AFL_EXT_OCTEON
:
12962 fputs ("Cavium Networks Octeon", stdout
);
12965 fputs ("Toshiba R5900", stdout
);
12968 fputs ("MIPS R4650", stdout
);
12971 fputs ("LSI R4010", stdout
);
12974 fputs ("NEC VR4100", stdout
);
12977 fputs ("Toshiba R3900", stdout
);
12979 case AFL_EXT_10000
:
12980 fputs ("MIPS R10000", stdout
);
12983 fputs ("Broadcom SB-1", stdout
);
12986 fputs ("NEC VR4111/VR4181", stdout
);
12989 fputs ("NEC VR4120", stdout
);
12992 fputs ("NEC VR5400", stdout
);
12995 fputs ("NEC VR5500", stdout
);
12997 case AFL_EXT_LOONGSON_2E
:
12998 fputs ("ST Microelectronics Loongson 2E", stdout
);
13000 case AFL_EXT_LOONGSON_2F
:
13001 fputs ("ST Microelectronics Loongson 2F", stdout
);
13004 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
13009 get_mips_reg_size (int reg_size
)
13011 return (reg_size
== AFL_REG_NONE
) ? 0
13012 : (reg_size
== AFL_REG_32
) ? 32
13013 : (reg_size
== AFL_REG_64
) ? 64
13014 : (reg_size
== AFL_REG_128
) ? 128
13019 process_mips_specific (FILE * file
)
13021 Elf_Internal_Dyn
* entry
;
13022 Elf_Internal_Shdr
*sect
= NULL
;
13023 size_t liblist_offset
= 0;
13024 size_t liblistno
= 0;
13025 size_t conflictsno
= 0;
13026 size_t options_offset
= 0;
13027 size_t conflicts_offset
= 0;
13028 size_t pltrelsz
= 0;
13030 bfd_vma pltgot
= 0;
13031 bfd_vma mips_pltgot
= 0;
13032 bfd_vma jmprel
= 0;
13033 bfd_vma local_gotno
= 0;
13034 bfd_vma gotsym
= 0;
13035 bfd_vma symtabno
= 0;
13037 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13038 display_mips_gnu_attribute
);
13040 sect
= find_section (".MIPS.abiflags");
13044 Elf_External_ABIFlags_v0
*abiflags_ext
;
13045 Elf_Internal_ABIFlags_v0 abiflags_in
;
13047 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
13048 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
13051 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13052 sect
->sh_size
, _("MIPS ABI Flags section"));
13055 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
13056 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
13057 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
13058 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
13059 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
13060 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
13061 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
13062 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
13063 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
13064 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
13065 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
13067 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
13068 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
13069 if (abiflags_in
.isa_rev
> 1)
13070 printf ("r%d", abiflags_in
.isa_rev
);
13071 printf ("\nGPR size: %d",
13072 get_mips_reg_size (abiflags_in
.gpr_size
));
13073 printf ("\nCPR1 size: %d",
13074 get_mips_reg_size (abiflags_in
.cpr1_size
));
13075 printf ("\nCPR2 size: %d",
13076 get_mips_reg_size (abiflags_in
.cpr2_size
));
13077 fputs ("\nFP ABI: ", stdout
);
13078 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
13079 fputs ("ISA Extension: ", stdout
);
13080 print_mips_isa_ext (abiflags_in
.isa_ext
);
13081 fputs ("\nASEs:", stdout
);
13082 print_mips_ases (abiflags_in
.ases
);
13083 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
13084 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
13085 fputc ('\n', stdout
);
13086 free (abiflags_ext
);
13091 /* We have a lot of special sections. Thanks SGI! */
13092 if (dynamic_section
== NULL
)
13093 /* No information available. */
13096 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
13097 switch (entry
->d_tag
)
13099 case DT_MIPS_LIBLIST
:
13101 = offset_from_vma (file
, entry
->d_un
.d_val
,
13102 liblistno
* sizeof (Elf32_External_Lib
));
13104 case DT_MIPS_LIBLISTNO
:
13105 liblistno
= entry
->d_un
.d_val
;
13107 case DT_MIPS_OPTIONS
:
13108 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
13110 case DT_MIPS_CONFLICT
:
13112 = offset_from_vma (file
, entry
->d_un
.d_val
,
13113 conflictsno
* sizeof (Elf32_External_Conflict
));
13115 case DT_MIPS_CONFLICTNO
:
13116 conflictsno
= entry
->d_un
.d_val
;
13119 pltgot
= entry
->d_un
.d_ptr
;
13121 case DT_MIPS_LOCAL_GOTNO
:
13122 local_gotno
= entry
->d_un
.d_val
;
13124 case DT_MIPS_GOTSYM
:
13125 gotsym
= entry
->d_un
.d_val
;
13127 case DT_MIPS_SYMTABNO
:
13128 symtabno
= entry
->d_un
.d_val
;
13130 case DT_MIPS_PLTGOT
:
13131 mips_pltgot
= entry
->d_un
.d_ptr
;
13134 pltrel
= entry
->d_un
.d_val
;
13137 pltrelsz
= entry
->d_un
.d_val
;
13140 jmprel
= entry
->d_un
.d_ptr
;
13146 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
13148 Elf32_External_Lib
* elib
;
13151 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
13153 sizeof (Elf32_External_Lib
),
13154 _("liblist section data"));
13157 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13158 (unsigned long) liblistno
);
13159 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13162 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
13169 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13170 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13171 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13172 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13173 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13175 tmp
= gmtime (&atime
);
13176 snprintf (timebuf
, sizeof (timebuf
),
13177 "%04u-%02u-%02uT%02u:%02u:%02u",
13178 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13179 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13181 printf ("%3lu: ", (unsigned long) cnt
);
13182 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
13183 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
13185 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
13186 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
13187 liblist
.l_version
);
13189 if (liblist
.l_flags
== 0)
13193 static const struct
13200 { " EXACT_MATCH", LL_EXACT_MATCH
},
13201 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
13202 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
13203 { " EXPORTS", LL_EXPORTS
},
13204 { " DELAY_LOAD", LL_DELAY_LOAD
},
13205 { " DELTA", LL_DELTA
}
13207 int flags
= liblist
.l_flags
;
13210 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
13211 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
13213 fputs (l_flags_vals
[fcnt
].name
, stdout
);
13214 flags
^= l_flags_vals
[fcnt
].bit
;
13217 printf (" %#x", (unsigned int) flags
);
13227 if (options_offset
!= 0)
13229 Elf_External_Options
* eopt
;
13230 Elf_Internal_Options
* iopt
;
13231 Elf_Internal_Options
* option
;
13234 sect
= section_headers
;
13236 /* Find the section header so that we get the size. */
13237 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
13240 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
13241 sect
->sh_size
, _("options"));
13244 iopt
= (Elf_Internal_Options
*)
13245 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
13248 error (_("Out of memory\n"));
13255 while (offset
< sect
->sh_size
)
13257 Elf_External_Options
* eoption
;
13259 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
13261 option
->kind
= BYTE_GET (eoption
->kind
);
13262 option
->size
= BYTE_GET (eoption
->size
);
13263 option
->section
= BYTE_GET (eoption
->section
);
13264 option
->info
= BYTE_GET (eoption
->info
);
13266 offset
+= option
->size
;
13272 printf (_("\nSection '%s' contains %d entries:\n"),
13273 printable_section_name (sect
), cnt
);
13281 switch (option
->kind
)
13284 /* This shouldn't happen. */
13285 printf (" NULL %d %lx", option
->section
, option
->info
);
13288 printf (" REGINFO ");
13289 if (elf_header
.e_machine
== EM_MIPS
)
13292 Elf32_External_RegInfo
* ereg
;
13293 Elf32_RegInfo reginfo
;
13295 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
13296 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13297 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13298 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13299 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13300 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13301 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13303 printf ("GPR %08lx GP 0x%lx\n",
13304 reginfo
.ri_gprmask
,
13305 (unsigned long) reginfo
.ri_gp_value
);
13306 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13307 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13308 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13313 Elf64_External_RegInfo
* ereg
;
13314 Elf64_Internal_RegInfo reginfo
;
13316 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
13317 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
13318 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
13319 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
13320 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
13321 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
13322 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
13324 printf ("GPR %08lx GP 0x",
13325 reginfo
.ri_gprmask
);
13326 printf_vma (reginfo
.ri_gp_value
);
13329 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13330 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
13331 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
13335 case ODK_EXCEPTIONS
:
13336 fputs (" EXCEPTIONS fpe_min(", stdout
);
13337 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
13338 fputs (") fpe_max(", stdout
);
13339 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
13340 fputs (")", stdout
);
13342 if (option
->info
& OEX_PAGE0
)
13343 fputs (" PAGE0", stdout
);
13344 if (option
->info
& OEX_SMM
)
13345 fputs (" SMM", stdout
);
13346 if (option
->info
& OEX_FPDBUG
)
13347 fputs (" FPDBUG", stdout
);
13348 if (option
->info
& OEX_DISMISS
)
13349 fputs (" DISMISS", stdout
);
13352 fputs (" PAD ", stdout
);
13353 if (option
->info
& OPAD_PREFIX
)
13354 fputs (" PREFIX", stdout
);
13355 if (option
->info
& OPAD_POSTFIX
)
13356 fputs (" POSTFIX", stdout
);
13357 if (option
->info
& OPAD_SYMBOL
)
13358 fputs (" SYMBOL", stdout
);
13361 fputs (" HWPATCH ", stdout
);
13362 if (option
->info
& OHW_R4KEOP
)
13363 fputs (" R4KEOP", stdout
);
13364 if (option
->info
& OHW_R8KPFETCH
)
13365 fputs (" R8KPFETCH", stdout
);
13366 if (option
->info
& OHW_R5KEOP
)
13367 fputs (" R5KEOP", stdout
);
13368 if (option
->info
& OHW_R5KCVTL
)
13369 fputs (" R5KCVTL", stdout
);
13372 fputs (" FILL ", stdout
);
13373 /* XXX Print content of info word? */
13376 fputs (" TAGS ", stdout
);
13377 /* XXX Print content of info word? */
13380 fputs (" HWAND ", stdout
);
13381 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13382 fputs (" R4KEOP_CHECKED", stdout
);
13383 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13384 fputs (" R4KEOP_CLEAN", stdout
);
13387 fputs (" HWOR ", stdout
);
13388 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
13389 fputs (" R4KEOP_CHECKED", stdout
);
13390 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
13391 fputs (" R4KEOP_CLEAN", stdout
);
13394 printf (" GP_GROUP %#06lx self-contained %#06lx",
13395 option
->info
& OGP_GROUP
,
13396 (option
->info
& OGP_SELF
) >> 16);
13399 printf (" IDENT %#06lx self-contained %#06lx",
13400 option
->info
& OGP_GROUP
,
13401 (option
->info
& OGP_SELF
) >> 16);
13404 /* This shouldn't happen. */
13405 printf (" %3d ??? %d %lx",
13406 option
->kind
, option
->section
, option
->info
);
13410 len
= sizeof (* eopt
);
13411 while (len
< option
->size
)
13412 if (((char *) option
)[len
] >= ' '
13413 && ((char *) option
)[len
] < 0x7f)
13414 printf ("%c", ((char *) option
)[len
++]);
13416 printf ("\\%03o", ((char *) option
)[len
++]);
13418 fputs ("\n", stdout
);
13426 if (conflicts_offset
!= 0 && conflictsno
!= 0)
13428 Elf32_Conflict
* iconf
;
13431 if (dynamic_symbols
== NULL
)
13433 error (_("conflict list found without a dynamic symbol table\n"));
13437 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
13440 error (_("Out of memory\n"));
13446 Elf32_External_Conflict
* econf32
;
13448 econf32
= (Elf32_External_Conflict
*)
13449 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13450 sizeof (* econf32
), _("conflict"));
13454 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13455 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
13461 Elf64_External_Conflict
* econf64
;
13463 econf64
= (Elf64_External_Conflict
*)
13464 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
13465 sizeof (* econf64
), _("conflict"));
13469 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13470 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
13475 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13476 (unsigned long) conflictsno
);
13477 puts (_(" Num: Index Value Name"));
13479 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
13481 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
13483 if (iconf
[cnt
] >= num_dynamic_syms
)
13484 printf (_("<corrupt symbol index>"));
13487 Elf_Internal_Sym
* psym
;
13489 psym
= & dynamic_symbols
[iconf
[cnt
]];
13490 print_vma (psym
->st_value
, FULL_HEX
);
13492 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13493 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
13495 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13503 if (pltgot
!= 0 && local_gotno
!= 0)
13505 bfd_vma ent
, local_end
, global_end
;
13507 unsigned char * data
;
13511 addr_size
= (is_32bit_elf
? 4 : 8);
13512 local_end
= pltgot
+ local_gotno
* addr_size
;
13514 /* PR binutils/17533 file: 012-111227-0.004 */
13515 if (symtabno
< gotsym
)
13517 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
13518 (long) gotsym
, (long) symtabno
);
13522 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
13523 assert (global_end
>= local_end
);
13524 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
13525 data
= (unsigned char *) get_data (NULL
, file
, offset
,
13526 global_end
- pltgot
, 1,
13527 _("Global Offset Table data"));
13531 printf (_("\nPrimary GOT:\n"));
13532 printf (_(" Canonical gp value: "));
13533 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
13536 printf (_(" Reserved entries:\n"));
13537 printf (_(" %*s %10s %*s Purpose\n"),
13538 addr_size
* 2, _("Address"), _("Access"),
13539 addr_size
* 2, _("Initial"));
13540 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13541 printf (_(" Lazy resolver\n"));
13543 && (byte_get (data
+ ent
- pltgot
, addr_size
)
13544 >> (addr_size
* 8 - 1)) != 0)
13546 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13547 printf (_(" Module pointer (GNU extension)\n"));
13551 if (ent
< local_end
)
13553 printf (_(" Local entries:\n"));
13554 printf (" %*s %10s %*s\n",
13555 addr_size
* 2, _("Address"), _("Access"),
13556 addr_size
* 2, _("Initial"));
13557 while (ent
< local_end
)
13559 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13565 if (gotsym
< symtabno
)
13569 printf (_(" Global entries:\n"));
13570 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13571 addr_size
* 2, _("Address"),
13573 addr_size
* 2, _("Initial"),
13574 addr_size
* 2, _("Sym.Val."),
13576 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13577 _("Ndx"), _("Name"));
13579 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
13581 for (i
= gotsym
; i
< symtabno
; i
++)
13583 ent
= print_mips_got_entry (data
, pltgot
, ent
);
13586 if (dynamic_symbols
== NULL
)
13587 printf (_("<no dynamic symbols>"));
13588 else if (i
< num_dynamic_syms
)
13590 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
13592 print_vma (psym
->st_value
, LONG_HEX
);
13593 printf (" %-7s %3s ",
13594 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13595 get_symbol_index_type (psym
->st_shndx
));
13597 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13598 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13600 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13603 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
13604 (unsigned long) i
);
13615 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
13618 size_t offset
, rel_offset
;
13619 unsigned long count
, i
;
13620 unsigned char * data
;
13621 int addr_size
, sym_width
;
13622 Elf_Internal_Rela
* rels
;
13624 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
13625 if (pltrel
== DT_RELA
)
13627 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13632 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
13637 addr_size
= (is_32bit_elf
? 4 : 8);
13638 end
= mips_pltgot
+ (2 + count
) * addr_size
;
13640 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
13641 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
13642 1, _("Procedure Linkage Table data"));
13646 printf ("\nPLT GOT:\n\n");
13647 printf (_(" Reserved entries:\n"));
13648 printf (_(" %*s %*s Purpose\n"),
13649 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
13650 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13651 printf (_(" PLT lazy resolver\n"));
13652 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13653 printf (_(" Module pointer\n"));
13656 printf (_(" Entries:\n"));
13657 printf (" %*s %*s %*s %-7s %3s %s\n",
13658 addr_size
* 2, _("Address"),
13659 addr_size
* 2, _("Initial"),
13660 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13661 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
13662 for (i
= 0; i
< count
; i
++)
13664 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
13666 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
13669 if (idx
>= num_dynamic_syms
)
13670 printf (_("<corrupt symbol index: %lu>"), idx
);
13673 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
13675 print_vma (psym
->st_value
, LONG_HEX
);
13676 printf (" %-7s %3s ",
13677 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
13678 get_symbol_index_type (psym
->st_shndx
));
13679 if (VALID_DYNAMIC_NAME (psym
->st_name
))
13680 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
13682 printf (_("<corrupt: %14ld>"), psym
->st_name
);
13697 process_nds32_specific (FILE * file
)
13699 Elf_Internal_Shdr
*sect
= NULL
;
13701 sect
= find_section (".nds32_e_flags");
13704 unsigned int *flag
;
13706 printf ("\nNDS32 elf flags section:\n");
13707 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
13708 sect
->sh_size
, _("NDS32 elf flags section"));
13710 switch ((*flag
) & 0x3)
13713 printf ("(VEC_SIZE):\tNo entry.\n");
13716 printf ("(VEC_SIZE):\t4 bytes\n");
13719 printf ("(VEC_SIZE):\t16 bytes\n");
13722 printf ("(VEC_SIZE):\treserved\n");
13731 process_gnu_liblist (FILE * file
)
13733 Elf_Internal_Shdr
* section
;
13734 Elf_Internal_Shdr
* string_sec
;
13735 Elf32_External_Lib
* elib
;
13737 size_t strtab_size
;
13744 for (i
= 0, section
= section_headers
;
13745 i
< elf_header
.e_shnum
;
13748 switch (section
->sh_type
)
13750 case SHT_GNU_LIBLIST
:
13751 if (section
->sh_link
>= elf_header
.e_shnum
)
13754 elib
= (Elf32_External_Lib
*)
13755 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
13756 _("liblist section data"));
13760 string_sec
= section_headers
+ section
->sh_link
;
13762 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
13763 string_sec
->sh_size
,
13764 _("liblist string table"));
13766 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
13772 strtab_size
= string_sec
->sh_size
;
13774 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13775 printable_section_name (section
),
13776 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
13778 puts (_(" Library Time Stamp Checksum Version Flags"));
13780 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
13788 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
13789 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
13790 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
13791 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
13792 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
13794 tmp
= gmtime (&atime
);
13795 snprintf (timebuf
, sizeof (timebuf
),
13796 "%04u-%02u-%02uT%02u:%02u:%02u",
13797 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
13798 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
13800 printf ("%3lu: ", (unsigned long) cnt
);
13802 printf ("%-20s", liblist
.l_name
< strtab_size
13803 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13805 printf ("%-20.20s", liblist
.l_name
< strtab_size
13806 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
13807 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
13808 liblist
.l_version
, liblist
.l_flags
);
13819 static const char *
13820 get_note_type (unsigned e_type
)
13822 static char buff
[64];
13824 if (elf_header
.e_type
== ET_CORE
)
13828 return _("NT_AUXV (auxiliary vector)");
13830 return _("NT_PRSTATUS (prstatus structure)");
13832 return _("NT_FPREGSET (floating point registers)");
13834 return _("NT_PRPSINFO (prpsinfo structure)");
13835 case NT_TASKSTRUCT
:
13836 return _("NT_TASKSTRUCT (task structure)");
13838 return _("NT_PRXFPREG (user_xfpregs structure)");
13840 return _("NT_PPC_VMX (ppc Altivec registers)");
13842 return _("NT_PPC_VSX (ppc VSX registers)");
13844 return _("NT_386_TLS (x86 TLS information)");
13845 case NT_386_IOPERM
:
13846 return _("NT_386_IOPERM (x86 I/O permissions)");
13847 case NT_X86_XSTATE
:
13848 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13849 case NT_S390_HIGH_GPRS
:
13850 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13851 case NT_S390_TIMER
:
13852 return _("NT_S390_TIMER (s390 timer register)");
13853 case NT_S390_TODCMP
:
13854 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13855 case NT_S390_TODPREG
:
13856 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13858 return _("NT_S390_CTRS (s390 control registers)");
13859 case NT_S390_PREFIX
:
13860 return _("NT_S390_PREFIX (s390 prefix register)");
13861 case NT_S390_LAST_BREAK
:
13862 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13863 case NT_S390_SYSTEM_CALL
:
13864 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13866 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13868 return _("NT_ARM_VFP (arm VFP registers)");
13870 return _("NT_ARM_TLS (AArch TLS registers)");
13871 case NT_ARM_HW_BREAK
:
13872 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13873 case NT_ARM_HW_WATCH
:
13874 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13876 return _("NT_PSTATUS (pstatus structure)");
13878 return _("NT_FPREGS (floating point registers)");
13880 return _("NT_PSINFO (psinfo structure)");
13882 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13884 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13885 case NT_WIN32PSTATUS
:
13886 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13888 return _("NT_SIGINFO (siginfo_t data)");
13890 return _("NT_FILE (mapped files)");
13898 return _("NT_VERSION (version)");
13900 return _("NT_ARCH (architecture)");
13905 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13910 print_core_note (Elf_Internal_Note
*pnote
)
13912 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
13913 bfd_vma count
, page_size
;
13914 unsigned char *descdata
, *filenames
, *descend
;
13916 if (pnote
->type
!= NT_FILE
)
13922 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13923 /* Still "successful". */
13928 if (pnote
->descsz
< 2 * addr_size
)
13930 printf (_(" Malformed note - too short for header\n"));
13934 descdata
= (unsigned char *) pnote
->descdata
;
13935 descend
= descdata
+ pnote
->descsz
;
13937 if (descdata
[pnote
->descsz
- 1] != '\0')
13939 printf (_(" Malformed note - does not end with \\0\n"));
13943 count
= byte_get (descdata
, addr_size
);
13944 descdata
+= addr_size
;
13946 page_size
= byte_get (descdata
, addr_size
);
13947 descdata
+= addr_size
;
13949 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
13951 printf (_(" Malformed note - too short for supplied file count\n"));
13955 printf (_(" Page size: "));
13956 print_vma (page_size
, DEC
);
13959 printf (_(" %*s%*s%*s\n"),
13960 (int) (2 + 2 * addr_size
), _("Start"),
13961 (int) (4 + 2 * addr_size
), _("End"),
13962 (int) (4 + 2 * addr_size
), _("Page Offset"));
13963 filenames
= descdata
+ count
* 3 * addr_size
;
13964 while (--count
> 0)
13966 bfd_vma start
, end
, file_ofs
;
13968 if (filenames
== descend
)
13970 printf (_(" Malformed note - filenames end too early\n"));
13974 start
= byte_get (descdata
, addr_size
);
13975 descdata
+= addr_size
;
13976 end
= byte_get (descdata
, addr_size
);
13977 descdata
+= addr_size
;
13978 file_ofs
= byte_get (descdata
, addr_size
);
13979 descdata
+= addr_size
;
13982 print_vma (start
, FULL_HEX
);
13984 print_vma (end
, FULL_HEX
);
13986 print_vma (file_ofs
, FULL_HEX
);
13987 printf ("\n %s\n", filenames
);
13989 filenames
+= 1 + strlen ((char *) filenames
);
13995 static const char *
13996 get_gnu_elf_note_type (unsigned e_type
)
13998 static char buff
[64];
14002 case NT_GNU_ABI_TAG
:
14003 return _("NT_GNU_ABI_TAG (ABI version tag)");
14005 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14006 case NT_GNU_BUILD_ID
:
14007 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14008 case NT_GNU_GOLD_VERSION
:
14009 return _("NT_GNU_GOLD_VERSION (gold version)");
14014 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14019 print_gnu_note (Elf_Internal_Note
*pnote
)
14021 switch (pnote
->type
)
14023 case NT_GNU_BUILD_ID
:
14027 printf (_(" Build ID: "));
14028 for (i
= 0; i
< pnote
->descsz
; ++i
)
14029 printf ("%02x", pnote
->descdata
[i
] & 0xff);
14034 case NT_GNU_ABI_TAG
:
14036 unsigned long os
, major
, minor
, subminor
;
14037 const char *osname
;
14039 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
14040 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
14041 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
14042 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
14046 case GNU_ABI_TAG_LINUX
:
14049 case GNU_ABI_TAG_HURD
:
14052 case GNU_ABI_TAG_SOLARIS
:
14053 osname
= "Solaris";
14055 case GNU_ABI_TAG_FREEBSD
:
14056 osname
= "FreeBSD";
14058 case GNU_ABI_TAG_NETBSD
:
14062 osname
= "Unknown";
14066 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
14067 major
, minor
, subminor
);
14071 case NT_GNU_GOLD_VERSION
:
14075 printf (_(" Version: "));
14076 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
14077 printf ("%c", pnote
->descdata
[i
]);
14086 static const char *
14087 get_netbsd_elfcore_note_type (unsigned e_type
)
14089 static char buff
[64];
14091 if (e_type
== NT_NETBSDCORE_PROCINFO
)
14093 /* NetBSD core "procinfo" structure. */
14094 return _("NetBSD procinfo structure");
14097 /* As of Jan 2002 there are no other machine-independent notes
14098 defined for NetBSD core files. If the note type is less
14099 than the start of the machine-dependent note types, we don't
14102 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
14104 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14108 switch (elf_header
.e_machine
)
14110 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14111 and PT_GETFPREGS == mach+2. */
14116 case EM_SPARC32PLUS
:
14120 case NT_NETBSDCORE_FIRSTMACH
+ 0:
14121 return _("PT_GETREGS (reg structure)");
14122 case NT_NETBSDCORE_FIRSTMACH
+ 2:
14123 return _("PT_GETFPREGS (fpreg structure)");
14129 /* On all other arch's, PT_GETREGS == mach+1 and
14130 PT_GETFPREGS == mach+3. */
14134 case NT_NETBSDCORE_FIRSTMACH
+ 1:
14135 return _("PT_GETREGS (reg structure)");
14136 case NT_NETBSDCORE_FIRSTMACH
+ 3:
14137 return _("PT_GETFPREGS (fpreg structure)");
14143 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
14144 e_type
- NT_NETBSDCORE_FIRSTMACH
);
14148 static const char *
14149 get_stapsdt_note_type (unsigned e_type
)
14151 static char buff
[64];
14156 return _("NT_STAPSDT (SystemTap probe descriptors)");
14162 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14167 print_stapsdt_note (Elf_Internal_Note
*pnote
)
14169 int addr_size
= is_32bit_elf
? 4 : 8;
14170 char *data
= pnote
->descdata
;
14171 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
14172 bfd_vma pc
, base_addr
, semaphore
;
14173 char *provider
, *probe
, *arg_fmt
;
14175 pc
= byte_get ((unsigned char *) data
, addr_size
);
14177 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
14179 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
14183 data
+= strlen (data
) + 1;
14185 data
+= strlen (data
) + 1;
14187 data
+= strlen (data
) + 1;
14189 printf (_(" Provider: %s\n"), provider
);
14190 printf (_(" Name: %s\n"), probe
);
14191 printf (_(" Location: "));
14192 print_vma (pc
, FULL_HEX
);
14193 printf (_(", Base: "));
14194 print_vma (base_addr
, FULL_HEX
);
14195 printf (_(", Semaphore: "));
14196 print_vma (semaphore
, FULL_HEX
);
14198 printf (_(" Arguments: %s\n"), arg_fmt
);
14200 return data
== data_end
;
14203 static const char *
14204 get_ia64_vms_note_type (unsigned e_type
)
14206 static char buff
[64];
14211 return _("NT_VMS_MHD (module header)");
14213 return _("NT_VMS_LNM (language name)");
14215 return _("NT_VMS_SRC (source files)");
14217 return "NT_VMS_TITLE";
14219 return _("NT_VMS_EIDC (consistency check)");
14220 case NT_VMS_FPMODE
:
14221 return _("NT_VMS_FPMODE (FP mode)");
14222 case NT_VMS_LINKTIME
:
14223 return "NT_VMS_LINKTIME";
14224 case NT_VMS_IMGNAM
:
14225 return _("NT_VMS_IMGNAM (image name)");
14227 return _("NT_VMS_IMGID (image id)");
14228 case NT_VMS_LINKID
:
14229 return _("NT_VMS_LINKID (link id)");
14230 case NT_VMS_IMGBID
:
14231 return _("NT_VMS_IMGBID (build id)");
14232 case NT_VMS_GSTNAM
:
14233 return _("NT_VMS_GSTNAM (sym table name)");
14234 case NT_VMS_ORIG_DYN
:
14235 return "NT_VMS_ORIG_DYN";
14236 case NT_VMS_PATCHTIME
:
14237 return "NT_VMS_PATCHTIME";
14239 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
14245 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
14247 switch (pnote
->type
)
14250 if (pnote
->descsz
> 36)
14252 size_t l
= strlen (pnote
->descdata
+ 34);
14253 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
14254 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
14255 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
14256 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
14259 printf (_(" Invalid size\n"));
14262 printf (_(" Language: %s\n"), pnote
->descdata
);
14265 case NT_VMS_FPMODE
:
14266 printf (_(" Floating Point mode: "));
14267 printf ("0x%016" BFD_VMA_FMT
"x\n",
14268 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
14270 case NT_VMS_LINKTIME
:
14271 printf (_(" Link time: "));
14273 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14276 case NT_VMS_PATCHTIME
:
14277 printf (_(" Patch time: "));
14279 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
14282 case NT_VMS_ORIG_DYN
:
14283 printf (_(" Major id: %u, minor id: %u\n"),
14284 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
14285 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
14286 printf (_(" Last modified : "));
14288 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
14289 printf (_("\n Link flags : "));
14290 printf ("0x%016" BFD_VMA_FMT
"x\n",
14291 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
14292 printf (_(" Header flags: 0x%08x\n"),
14293 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
14294 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
14297 case NT_VMS_IMGNAM
:
14298 printf (_(" Image name: %s\n"), pnote
->descdata
);
14300 case NT_VMS_GSTNAM
:
14301 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
14304 printf (_(" Image id: %s\n"), pnote
->descdata
);
14306 case NT_VMS_LINKID
:
14307 printf (_(" Linker id: %s\n"), pnote
->descdata
);
14315 /* Note that by the ELF standard, the name field is already null byte
14316 terminated, and namesz includes the terminating null byte.
14317 I.E. the value of namesz for the name "FSF" is 4.
14319 If the value of namesz is zero, there is no name present. */
14321 process_note (Elf_Internal_Note
* pnote
)
14323 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
14326 if (pnote
->namesz
== 0)
14327 /* If there is no note name, then use the default set of
14328 note type strings. */
14329 nt
= get_note_type (pnote
->type
);
14331 else if (const_strneq (pnote
->namedata
, "GNU"))
14332 /* GNU-specific object file notes. */
14333 nt
= get_gnu_elf_note_type (pnote
->type
);
14335 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
14336 /* NetBSD-specific core file notes. */
14337 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
14339 else if (strneq (pnote
->namedata
, "SPU/", 4))
14341 /* SPU-specific core file notes. */
14342 nt
= pnote
->namedata
+ 4;
14346 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14347 /* VMS/ia64-specific file notes. */
14348 nt
= get_ia64_vms_note_type (pnote
->type
);
14350 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14351 nt
= get_stapsdt_note_type (pnote
->type
);
14354 /* Don't recognize this note name; just use the default set of
14355 note type strings. */
14356 nt
= get_note_type (pnote
->type
);
14358 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
14360 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
14361 return print_ia64_vms_note (pnote
);
14362 else if (const_strneq (pnote
->namedata
, "GNU"))
14363 return print_gnu_note (pnote
);
14364 else if (const_strneq (pnote
->namedata
, "stapsdt"))
14365 return print_stapsdt_note (pnote
);
14366 else if (const_strneq (pnote
->namedata
, "CORE"))
14367 return print_core_note (pnote
);
14374 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
14376 Elf_External_Note
* pnotes
;
14377 Elf_External_Note
* external
;
14383 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
14385 if (pnotes
== NULL
)
14390 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
14391 (unsigned long) offset
, (unsigned long) length
);
14392 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
14394 while ((char *) external
< (char *) pnotes
+ length
)
14396 Elf_Internal_Note inote
;
14399 char * temp
= NULL
;
14400 size_t data_remaining
= ((char *) pnotes
+ length
) - (char *) external
;
14402 if (!is_ia64_vms ())
14404 /* PR binutils/15191
14405 Make sure that there is enough data to read. */
14406 min_notesz
= offsetof (Elf_External_Note
, name
);
14407 if (data_remaining
< min_notesz
)
14409 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14410 (int) data_remaining
);
14413 inote
.type
= BYTE_GET (external
->type
);
14414 inote
.namesz
= BYTE_GET (external
->namesz
);
14415 inote
.namedata
= external
->name
;
14416 inote
.descsz
= BYTE_GET (external
->descsz
);
14417 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
14418 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14419 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
14423 Elf64_External_VMS_Note
*vms_external
;
14425 /* PR binutils/15191
14426 Make sure that there is enough data to read. */
14427 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14428 if (data_remaining
< min_notesz
)
14430 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
14431 (int) data_remaining
);
14435 vms_external
= (Elf64_External_VMS_Note
*) external
;
14436 inote
.type
= BYTE_GET (vms_external
->type
);
14437 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
14438 inote
.namedata
= vms_external
->name
;
14439 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
14440 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14441 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
14442 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14445 if (inote
.descdata
< (char *) external
+ min_notesz
14446 || next
< (char *) external
+ min_notesz
14447 || data_remaining
< (size_t)(next
- (char *) external
))
14449 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
14450 (unsigned long) ((char *) external
- (char *) pnotes
));
14451 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
14452 inote
.type
, inote
.namesz
, inote
.descsz
);
14456 external
= (Elf_External_Note
*) next
;
14458 /* Verify that name is null terminated. It appears that at least
14459 one version of Linux (RedHat 6.0) generates corefiles that don't
14460 comply with the ELF spec by failing to include the null byte in
14462 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
14464 temp
= (char *) malloc (inote
.namesz
+ 1);
14468 error (_("Out of memory\n"));
14473 strncpy (temp
, inote
.namedata
, inote
.namesz
);
14474 temp
[inote
.namesz
] = 0;
14476 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
14477 inote
.namedata
= temp
;
14480 res
&= process_note (& inote
);
14495 process_corefile_note_segments (FILE * file
)
14497 Elf_Internal_Phdr
* segment
;
14501 if (! get_program_headers (file
))
14504 for (i
= 0, segment
= program_headers
;
14505 i
< elf_header
.e_phnum
;
14508 if (segment
->p_type
== PT_NOTE
)
14509 res
&= process_corefile_note_segment (file
,
14510 (bfd_vma
) segment
->p_offset
,
14511 (bfd_vma
) segment
->p_filesz
);
14518 process_note_sections (FILE * file
)
14520 Elf_Internal_Shdr
* section
;
14525 for (i
= 0, section
= section_headers
;
14526 i
< elf_header
.e_shnum
&& section
!= NULL
;
14528 if (section
->sh_type
== SHT_NOTE
)
14530 res
&= process_corefile_note_segment (file
,
14531 (bfd_vma
) section
->sh_offset
,
14532 (bfd_vma
) section
->sh_size
);
14537 /* Try processing NOTE segments instead. */
14538 return process_corefile_note_segments (file
);
14544 process_notes (FILE * file
)
14546 /* If we have not been asked to display the notes then do nothing. */
14550 if (elf_header
.e_type
!= ET_CORE
)
14551 return process_note_sections (file
);
14553 /* No program headers means no NOTE segment. */
14554 if (elf_header
.e_phnum
> 0)
14555 return process_corefile_note_segments (file
);
14557 printf (_("No note segments present in the core file.\n"));
14562 process_arch_specific (FILE * file
)
14567 switch (elf_header
.e_machine
)
14570 return process_arm_specific (file
);
14572 case EM_MIPS_RS3_LE
:
14573 return process_mips_specific (file
);
14576 return process_nds32_specific (file
);
14579 return process_power_specific (file
);
14582 case EM_SPARC32PLUS
:
14584 return process_sparc_specific (file
);
14587 return process_tic6x_specific (file
);
14590 return process_msp430x_specific (file
);
14598 get_file_header (FILE * file
)
14600 /* Read in the identity array. */
14601 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
14604 /* Determine how to read the rest of the header. */
14605 switch (elf_header
.e_ident
[EI_DATA
])
14607 default: /* fall through */
14608 case ELFDATANONE
: /* fall through */
14610 byte_get
= byte_get_little_endian
;
14611 byte_put
= byte_put_little_endian
;
14614 byte_get
= byte_get_big_endian
;
14615 byte_put
= byte_put_big_endian
;
14619 /* For now we only support 32 bit and 64 bit ELF files. */
14620 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
14622 /* Read in the rest of the header. */
14625 Elf32_External_Ehdr ehdr32
;
14627 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
14630 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
14631 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
14632 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
14633 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
14634 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
14635 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
14636 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
14637 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
14638 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
14639 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
14640 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
14641 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
14642 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
14646 Elf64_External_Ehdr ehdr64
;
14648 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14649 we will not be able to cope with the 64bit data found in
14650 64 ELF files. Detect this now and abort before we start
14651 overwriting things. */
14652 if (sizeof (bfd_vma
) < 8)
14654 error (_("This instance of readelf has been built without support for a\n\
14655 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14659 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
14662 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
14663 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
14664 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
14665 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
14666 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
14667 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
14668 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
14669 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
14670 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
14671 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
14672 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
14673 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
14674 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
14677 if (elf_header
.e_shoff
)
14679 /* There may be some extensions in the first section header. Don't
14680 bomb if we can't read it. */
14682 get_32bit_section_headers (file
, TRUE
);
14684 get_64bit_section_headers (file
, TRUE
);
14690 /* Process one ELF object file according to the command line options.
14691 This file may actually be stored in an archive. The file is
14692 positioned at the start of the ELF object. */
14695 process_object (char * file_name
, FILE * file
)
14699 if (! get_file_header (file
))
14701 error (_("%s: Failed to read file header\n"), file_name
);
14705 /* Initialise per file variables. */
14706 for (i
= ARRAY_SIZE (version_info
); i
--;)
14707 version_info
[i
] = 0;
14709 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
14710 dynamic_info
[i
] = 0;
14711 dynamic_info_DT_GNU_HASH
= 0;
14713 /* Process the file. */
14715 printf (_("\nFile: %s\n"), file_name
);
14717 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14718 Note we do this even if cmdline_dump_sects is empty because we
14719 must make sure that the dump_sets array is zeroed out before each
14720 object file is processed. */
14721 if (num_dump_sects
> num_cmdline_dump_sects
)
14722 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
14724 if (num_cmdline_dump_sects
> 0)
14726 if (num_dump_sects
== 0)
14727 /* A sneaky way of allocating the dump_sects array. */
14728 request_dump_bynumber (num_cmdline_dump_sects
, 0);
14730 assert (num_dump_sects
>= num_cmdline_dump_sects
);
14731 memcpy (dump_sects
, cmdline_dump_sects
,
14732 num_cmdline_dump_sects
* sizeof (* dump_sects
));
14735 if (! process_file_header ())
14738 if (! process_section_headers (file
))
14740 /* Without loaded section headers we cannot process lots of
14742 do_unwind
= do_version
= do_dump
= do_arch
= 0;
14744 if (! do_using_dynamic
)
14745 do_syms
= do_dyn_syms
= do_reloc
= 0;
14748 if (! process_section_groups (file
))
14750 /* Without loaded section groups we cannot process unwind. */
14754 if (process_program_headers (file
))
14755 process_dynamic_section (file
);
14757 process_relocs (file
);
14759 process_unwind (file
);
14761 process_symbol_table (file
);
14763 process_syminfo (file
);
14765 process_version_sections (file
);
14767 process_section_contents (file
);
14769 process_notes (file
);
14771 process_gnu_liblist (file
);
14773 process_arch_specific (file
);
14775 if (program_headers
)
14777 free (program_headers
);
14778 program_headers
= NULL
;
14781 if (section_headers
)
14783 free (section_headers
);
14784 section_headers
= NULL
;
14789 free (string_table
);
14790 string_table
= NULL
;
14791 string_table_length
= 0;
14794 if (dynamic_strings
)
14796 free (dynamic_strings
);
14797 dynamic_strings
= NULL
;
14798 dynamic_strings_length
= 0;
14801 if (dynamic_symbols
)
14803 free (dynamic_symbols
);
14804 dynamic_symbols
= NULL
;
14805 num_dynamic_syms
= 0;
14808 if (dynamic_syminfo
)
14810 free (dynamic_syminfo
);
14811 dynamic_syminfo
= NULL
;
14814 if (dynamic_section
)
14816 free (dynamic_section
);
14817 dynamic_section
= NULL
;
14820 if (section_headers_groups
)
14822 free (section_headers_groups
);
14823 section_headers_groups
= NULL
;
14826 if (section_groups
)
14828 struct group_list
* g
;
14829 struct group_list
* next
;
14831 for (i
= 0; i
< group_count
; i
++)
14833 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
14840 free (section_groups
);
14841 section_groups
= NULL
;
14844 free_debug_memory ();
14849 /* Process an ELF archive.
14850 On entry the file is positioned just after the ARMAG string. */
14853 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
14855 struct archive_info arch
;
14856 struct archive_info nested_arch
;
14862 /* The ARCH structure is used to hold information about this archive. */
14863 arch
.file_name
= NULL
;
14865 arch
.index_array
= NULL
;
14866 arch
.sym_table
= NULL
;
14867 arch
.longnames
= NULL
;
14869 /* The NESTED_ARCH structure is used as a single-item cache of information
14870 about a nested archive (when members of a thin archive reside within
14871 another regular archive file). */
14872 nested_arch
.file_name
= NULL
;
14873 nested_arch
.file
= NULL
;
14874 nested_arch
.index_array
= NULL
;
14875 nested_arch
.sym_table
= NULL
;
14876 nested_arch
.longnames
= NULL
;
14878 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
14884 if (do_archive_index
)
14886 if (arch
.sym_table
== NULL
)
14887 error (_("%s: unable to dump the index as none was found\n"), file_name
);
14891 unsigned long current_pos
;
14893 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14894 file_name
, (long) arch
.index_num
, arch
.sym_size
);
14895 current_pos
= ftell (file
);
14897 for (i
= l
= 0; i
< arch
.index_num
; i
++)
14899 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
14901 char * member_name
;
14903 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
14905 if (member_name
!= NULL
)
14907 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
14909 if (qualified_name
!= NULL
)
14911 printf (_("Contents of binary %s at offset "), qualified_name
);
14912 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
14914 free (qualified_name
);
14919 if (l
>= arch
.sym_size
)
14921 error (_("%s: end of the symbol table reached before the end of the index\n"),
14925 printf ("\t%s\n", arch
.sym_table
+ l
);
14926 l
+= strlen (arch
.sym_table
+ l
) + 1;
14929 if (arch
.uses_64bit_indicies
)
14934 if (l
< arch
.sym_size
)
14935 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14936 file_name
, arch
.sym_size
- l
);
14938 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
14940 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
14946 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
14947 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
14948 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
14949 && !do_section_groups
&& !do_dyn_syms
)
14951 ret
= 0; /* Archive index only. */
14962 char * qualified_name
;
14964 /* Read the next archive header. */
14965 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
14967 error (_("%s: failed to seek to next archive header\n"), file_name
);
14970 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
14971 if (got
!= sizeof arch
.arhdr
)
14975 error (_("%s: failed to read archive header\n"), file_name
);
14979 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
14981 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
14986 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
14988 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
14989 if (archive_file_size
& 01)
14990 ++archive_file_size
;
14992 name
= get_archive_member_name (&arch
, &nested_arch
);
14995 error (_("%s: bad archive file name\n"), file_name
);
14999 namelen
= strlen (name
);
15001 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
15002 if (qualified_name
== NULL
)
15004 error (_("%s: bad archive file name\n"), file_name
);
15009 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
15011 /* This is a proxy for an external member of a thin archive. */
15012 FILE * member_file
;
15013 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
15014 if (member_file_name
== NULL
)
15020 member_file
= fopen (member_file_name
, "rb");
15021 if (member_file
== NULL
)
15023 error (_("Input file '%s' is not readable.\n"), member_file_name
);
15024 free (member_file_name
);
15029 archive_file_offset
= arch
.nested_member_origin
;
15031 ret
|= process_object (qualified_name
, member_file
);
15033 fclose (member_file
);
15034 free (member_file_name
);
15036 else if (is_thin_archive
)
15038 /* PR 15140: Allow for corrupt thin archives. */
15039 if (nested_arch
.file
== NULL
)
15041 error (_("%s: contains corrupt thin archive: %s\n"),
15047 /* This is a proxy for a member of a nested archive. */
15048 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
15050 /* The nested archive file will have been opened and setup by
15051 get_archive_member_name. */
15052 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
15054 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
15059 ret
|= process_object (qualified_name
, nested_arch
.file
);
15063 archive_file_offset
= arch
.next_arhdr_offset
;
15064 arch
.next_arhdr_offset
+= archive_file_size
;
15066 ret
|= process_object (qualified_name
, file
);
15069 if (dump_sects
!= NULL
)
15073 num_dump_sects
= 0;
15076 free (qualified_name
);
15080 if (nested_arch
.file
!= NULL
)
15081 fclose (nested_arch
.file
);
15082 release_archive (&nested_arch
);
15083 release_archive (&arch
);
15089 process_file (char * file_name
)
15092 struct stat statbuf
;
15093 char armag
[SARMAG
];
15096 if (stat (file_name
, &statbuf
) < 0)
15098 if (errno
== ENOENT
)
15099 error (_("'%s': No such file\n"), file_name
);
15101 error (_("Could not locate '%s'. System error message: %s\n"),
15102 file_name
, strerror (errno
));
15106 if (! S_ISREG (statbuf
.st_mode
))
15108 error (_("'%s' is not an ordinary file\n"), file_name
);
15112 file
= fopen (file_name
, "rb");
15115 error (_("Input file '%s' is not readable.\n"), file_name
);
15119 if (fread (armag
, SARMAG
, 1, file
) != 1)
15121 error (_("%s: Failed to read file's magic number\n"), file_name
);
15126 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
15128 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
15129 ret
= process_archive (file_name
, file
, FALSE
);
15130 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
15131 ret
= process_archive (file_name
, file
, TRUE
);
15134 if (do_archive_index
)
15135 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15139 archive_file_size
= archive_file_offset
= 0;
15140 ret
= process_object (file_name
, file
);
15145 current_file_size
= 0;
15149 #ifdef SUPPORT_DISASSEMBLY
15150 /* Needed by the i386 disassembler. For extra credit, someone could
15151 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15155 print_address (unsigned int addr
, FILE * outfile
)
15157 fprintf (outfile
,"0x%8.8x", addr
);
15160 /* Needed by the i386 disassembler. */
15162 db_task_printsym (unsigned int addr
)
15164 print_address (addr
, stderr
);
15169 main (int argc
, char ** argv
)
15173 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15174 setlocale (LC_MESSAGES
, "");
15176 #if defined (HAVE_SETLOCALE)
15177 setlocale (LC_CTYPE
, "");
15179 bindtextdomain (PACKAGE
, LOCALEDIR
);
15180 textdomain (PACKAGE
);
15182 expandargv (&argc
, &argv
);
15184 parse_args (argc
, argv
);
15186 if (num_dump_sects
> 0)
15188 /* Make a copy of the dump_sects array. */
15189 cmdline_dump_sects
= (dump_type
*)
15190 malloc (num_dump_sects
* sizeof (* dump_sects
));
15191 if (cmdline_dump_sects
== NULL
)
15192 error (_("Out of memory allocating dump request table.\n"));
15195 memcpy (cmdline_dump_sects
, dump_sects
,
15196 num_dump_sects
* sizeof (* dump_sects
));
15197 num_cmdline_dump_sects
= num_dump_sects
;
15201 if (optind
< (argc
- 1))
15205 while (optind
< argc
)
15206 err
|= process_file (argv
[optind
++]);
15208 if (dump_sects
!= NULL
)
15210 if (cmdline_dump_sects
!= NULL
)
15211 free (cmdline_dump_sects
);