1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998-2013 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/or32.h"
137 #include "elf/ppc64.h"
138 #include "elf/rl78.h"
140 #include "elf/s390.h"
141 #include "elf/score.h"
143 #include "elf/sparc.h"
145 #include "elf/tic6x.h"
146 #include "elf/tilegx.h"
147 #include "elf/tilepro.h"
148 #include "elf/v850.h"
150 #include "elf/x86-64.h"
151 #include "elf/xc16x.h"
152 #include "elf/xgate.h"
153 #include "elf/xstormy16.h"
154 #include "elf/xtensa.h"
157 #include "libiberty.h"
158 #include "safe-ctype.h"
159 #include "filenames.h"
161 char * program_name
= "readelf";
162 static long archive_file_offset
;
163 static unsigned long archive_file_size
;
164 static unsigned long dynamic_addr
;
165 static bfd_size_type dynamic_size
;
166 static unsigned int dynamic_nent
;
167 static char * dynamic_strings
;
168 static unsigned long dynamic_strings_length
;
169 static char * string_table
;
170 static unsigned long string_table_length
;
171 static unsigned long num_dynamic_syms
;
172 static Elf_Internal_Sym
* dynamic_symbols
;
173 static Elf_Internal_Syminfo
* dynamic_syminfo
;
174 static unsigned long dynamic_syminfo_offset
;
175 static unsigned int dynamic_syminfo_nent
;
176 static char program_interpreter
[PATH_MAX
];
177 static bfd_vma dynamic_info
[DT_ENCODING
];
178 static bfd_vma dynamic_info_DT_GNU_HASH
;
179 static bfd_vma version_info
[16];
180 static Elf_Internal_Ehdr elf_header
;
181 static Elf_Internal_Shdr
* section_headers
;
182 static Elf_Internal_Phdr
* program_headers
;
183 static Elf_Internal_Dyn
* dynamic_section
;
184 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
185 static int show_name
;
186 static int do_dynamic
;
188 static int do_dyn_syms
;
190 static int do_sections
;
191 static int do_section_groups
;
192 static int do_section_details
;
193 static int do_segments
;
194 static int do_unwind
;
195 static int do_using_dynamic
;
196 static int do_header
;
198 static int do_version
;
199 static int do_histogram
;
200 static int do_debugging
;
203 static int do_archive_index
;
204 static int is_32bit_elf
;
208 struct group_list
* next
;
209 unsigned int section_index
;
214 struct group_list
* root
;
215 unsigned int group_index
;
218 static size_t group_count
;
219 static struct group
* section_groups
;
220 static struct group
** section_headers_groups
;
223 /* Flag bits indicating particular types of dump. */
224 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
225 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
226 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
227 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
228 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
230 typedef unsigned char dump_type
;
232 /* A linked list of the section names for which dumps were requested. */
233 struct dump_list_entry
237 struct dump_list_entry
* next
;
239 static struct dump_list_entry
* dump_sects_byname
;
241 /* A dynamic array of flags indicating for which sections a dump
242 has been requested via command line switches. */
243 static dump_type
* cmdline_dump_sects
= NULL
;
244 static unsigned int num_cmdline_dump_sects
= 0;
246 /* A dynamic array of flags indicating for which sections a dump of
247 some kind has been requested. It is reset on a per-object file
248 basis and then initialised from the cmdline_dump_sects array,
249 the results of interpreting the -w switch, and the
250 dump_sects_byname list. */
251 static dump_type
* dump_sects
= NULL
;
252 static unsigned int num_dump_sects
= 0;
255 /* How to print a vma value. */
256 typedef enum print_mode
270 #define SECTION_NAME(X) \
271 ((X) == NULL ? _("<none>") \
272 : string_table == NULL ? _("<no-name>") \
273 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
274 : string_table + (X)->sh_name))
276 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
278 #define GET_ELF_SYMBOLS(file, section, sym_count) \
279 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
280 : get_64bit_elf_symbols (file, section, sym_count))
282 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
283 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
284 already been called and verified that the string exists. */
285 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
287 #define REMOVE_ARCH_BITS(ADDR) \
290 if (elf_header.e_machine == EM_ARM) \
295 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
296 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
297 using malloc and fill that. In either case return the pointer to the start of
298 the retrieved data or NULL if something went wrong. If something does go wrong
299 emit an error message using REASON as part of the context. */
302 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
307 if (size
== 0 || nmemb
== 0)
310 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
312 error (_("Unable to seek to 0x%lx for %s\n"),
313 (unsigned long) archive_file_offset
+ offset
, reason
);
320 /* Check for overflow. */
321 if (nmemb
< (~(size_t) 0 - 1) / size
)
322 /* + 1 so that we can '\0' terminate invalid string table sections. */
323 mvar
= malloc (size
* nmemb
+ 1);
327 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
328 (unsigned long)(size
* nmemb
), reason
);
332 ((char *) mvar
)[size
* nmemb
] = '\0';
335 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
337 error (_("Unable to read in 0x%lx bytes of %s\n"),
338 (unsigned long)(size
* nmemb
), reason
);
347 /* Print a VMA value. */
350 print_vma (bfd_vma vma
, print_mode mode
)
363 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
370 return printf ("%5" BFD_VMA_FMT
"d", vma
);
378 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
381 return printf ("%" BFD_VMA_FMT
"d", vma
);
384 return printf ("%" BFD_VMA_FMT
"u", vma
);
389 /* Display a symbol on stdout. Handles the display of control characters and
390 multibye characters (assuming the host environment supports them).
392 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
394 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
395 padding as necessary.
397 Returns the number of emitted characters. */
400 print_symbol (int width
, const char *symbol
)
402 bfd_boolean extra_padding
= FALSE
;
404 #ifdef HAVE_MBSTATE_T
411 /* Keep the width positive. This also helps. */
413 extra_padding
= TRUE
;
417 /* Set the remaining width to a very large value.
418 This simplifies the code below. */
419 width_remaining
= INT_MAX
;
421 width_remaining
= width
;
423 #ifdef HAVE_MBSTATE_T
424 /* Initialise the multibyte conversion state. */
425 memset (& state
, 0, sizeof (state
));
428 while (width_remaining
)
431 const char c
= *symbol
++;
436 /* Do not print control characters directly as they can affect terminal
437 settings. Such characters usually appear in the names generated
438 by the assembler for local labels. */
441 if (width_remaining
< 2)
444 printf ("^%c", c
+ 0x40);
445 width_remaining
-= 2;
448 else if (ISPRINT (c
))
456 #ifdef HAVE_MBSTATE_T
459 /* Let printf do the hard work of displaying multibyte characters. */
460 printf ("%.1s", symbol
- 1);
464 #ifdef HAVE_MBSTATE_T
465 /* Try to find out how many bytes made up the character that was
466 just printed. Advance the symbol pointer past the bytes that
468 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
472 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
477 if (extra_padding
&& num_printed
< width
)
479 /* Fill in the remaining spaces. */
480 printf ("%-*s", width
- num_printed
, " ");
487 /* Return a pointer to section NAME, or NULL if no such section exists. */
489 static Elf_Internal_Shdr
*
490 find_section (const char * name
)
494 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
495 if (streq (SECTION_NAME (section_headers
+ i
), name
))
496 return section_headers
+ i
;
501 /* Return a pointer to a section containing ADDR, or NULL if no such
504 static Elf_Internal_Shdr
*
505 find_section_by_address (bfd_vma addr
)
509 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
511 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
512 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
519 /* Return a pointer to section NAME, or NULL if no such section exists,
520 restricted to the list of sections given in SET. */
522 static Elf_Internal_Shdr
*
523 find_section_in_set (const char * name
, unsigned int * set
)
529 while ((i
= *set
++) > 0)
530 if (streq (SECTION_NAME (section_headers
+ i
), name
))
531 return section_headers
+ i
;
534 return find_section (name
);
537 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
541 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
543 return read_leb128 (data
, length_return
, 0);
546 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
547 This OS has so many departures from the ELF standard that we test it at
553 return elf_header
.e_machine
== EM_IA_64
554 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
557 /* Guess the relocation size commonly used by the specific machines. */
560 guess_is_rela (unsigned int e_machine
)
564 /* Targets that use REL relocations. */
581 /* Targets that use RELA relocations. */
585 case EM_ADAPTEVA_EPIPHANY
:
587 case EM_ALTERA_NIOS2
:
606 case EM_LATTICEMICO32
:
615 case EM_CYGNUS_MN10200
:
617 case EM_CYGNUS_MN10300
:
648 case EM_MICROBLAZE_OLD
:
669 warn (_("Don't know about relocations on this machine architecture\n"));
675 slurp_rela_relocs (FILE * file
,
676 unsigned long rel_offset
,
677 unsigned long rel_size
,
678 Elf_Internal_Rela
** relasp
,
679 unsigned long * nrelasp
)
681 Elf_Internal_Rela
* relas
;
682 unsigned long nrelas
;
687 Elf32_External_Rela
* erelas
;
689 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
690 rel_size
, _("32-bit relocation data"));
694 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
696 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
697 sizeof (Elf_Internal_Rela
));
702 error (_("out of memory parsing relocs\n"));
706 for (i
= 0; i
< nrelas
; i
++)
708 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
709 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
710 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
717 Elf64_External_Rela
* erelas
;
719 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
720 rel_size
, _("64-bit relocation data"));
724 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
726 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
727 sizeof (Elf_Internal_Rela
));
732 error (_("out of memory parsing relocs\n"));
736 for (i
= 0; i
< nrelas
; i
++)
738 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
739 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
740 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
742 /* The #ifdef BFD64 below is to prevent a compile time
743 warning. We know that if we do not have a 64 bit data
744 type that we will never execute this code anyway. */
746 if (elf_header
.e_machine
== EM_MIPS
747 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
749 /* In little-endian objects, r_info isn't really a
750 64-bit little-endian value: it has a 32-bit
751 little-endian symbol index followed by four
752 individual byte fields. Reorder INFO
754 bfd_vma inf
= relas
[i
].r_info
;
755 inf
= (((inf
& 0xffffffff) << 32)
756 | ((inf
>> 56) & 0xff)
757 | ((inf
>> 40) & 0xff00)
758 | ((inf
>> 24) & 0xff0000)
759 | ((inf
>> 8) & 0xff000000));
760 relas
[i
].r_info
= inf
;
773 slurp_rel_relocs (FILE * file
,
774 unsigned long rel_offset
,
775 unsigned long rel_size
,
776 Elf_Internal_Rela
** relsp
,
777 unsigned long * nrelsp
)
779 Elf_Internal_Rela
* rels
;
785 Elf32_External_Rel
* erels
;
787 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
788 rel_size
, _("32-bit relocation data"));
792 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
794 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
799 error (_("out of memory parsing relocs\n"));
803 for (i
= 0; i
< nrels
; i
++)
805 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
806 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
807 rels
[i
].r_addend
= 0;
814 Elf64_External_Rel
* erels
;
816 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
817 rel_size
, _("64-bit relocation data"));
821 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
823 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
828 error (_("out of memory parsing relocs\n"));
832 for (i
= 0; i
< nrels
; i
++)
834 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
835 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
836 rels
[i
].r_addend
= 0;
838 /* The #ifdef BFD64 below is to prevent a compile time
839 warning. We know that if we do not have a 64 bit data
840 type that we will never execute this code anyway. */
842 if (elf_header
.e_machine
== EM_MIPS
843 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
845 /* In little-endian objects, r_info isn't really a
846 64-bit little-endian value: it has a 32-bit
847 little-endian symbol index followed by four
848 individual byte fields. Reorder INFO
850 bfd_vma inf
= rels
[i
].r_info
;
851 inf
= (((inf
& 0xffffffff) << 32)
852 | ((inf
>> 56) & 0xff)
853 | ((inf
>> 40) & 0xff00)
854 | ((inf
>> 24) & 0xff0000)
855 | ((inf
>> 8) & 0xff000000));
856 rels
[i
].r_info
= inf
;
868 /* Returns the reloc type extracted from the reloc info field. */
871 get_reloc_type (bfd_vma reloc_info
)
874 return ELF32_R_TYPE (reloc_info
);
876 switch (elf_header
.e_machine
)
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info
);
883 return ELF64_R_TYPE_ID (reloc_info
);
886 return ELF64_R_TYPE (reloc_info
);
890 /* Return the symbol index extracted from the reloc info field. */
893 get_reloc_symindex (bfd_vma reloc_info
)
895 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
898 /* Display the contents of the relocation data found at the specified
902 dump_relocations (FILE * file
,
903 unsigned long rel_offset
,
904 unsigned long rel_size
,
905 Elf_Internal_Sym
* symtab
,
908 unsigned long strtablen
,
912 Elf_Internal_Rela
* rels
;
914 if (is_rela
== UNKNOWN
)
915 is_rela
= guess_is_rela (elf_header
.e_machine
);
919 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
924 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
963 for (i
= 0; i
< rel_size
; i
++)
968 bfd_vma symtab_index
;
971 offset
= rels
[i
].r_offset
;
972 inf
= rels
[i
].r_info
;
974 type
= get_reloc_type (inf
);
975 symtab_index
= get_reloc_symindex (inf
);
979 printf ("%8.8lx %8.8lx ",
980 (unsigned long) offset
& 0xffffffff,
981 (unsigned long) inf
& 0xffffffff);
985 #if BFD_HOST_64BIT_LONG
987 ? "%16.16lx %16.16lx "
988 : "%12.12lx %12.12lx ",
990 #elif BFD_HOST_64BIT_LONG_LONG
993 ? "%16.16llx %16.16llx "
994 : "%12.12llx %12.12llx ",
998 ? "%16.16I64x %16.16I64x "
999 : "%12.12I64x %12.12I64x ",
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset
),
1007 _bfd_int64_low (offset
),
1008 _bfd_int64_high (inf
),
1009 _bfd_int64_low (inf
));
1013 switch (elf_header
.e_machine
)
1020 rtype
= elf_aarch64_reloc_type (type
);
1024 case EM_CYGNUS_M32R
:
1025 rtype
= elf_m32r_reloc_type (type
);
1030 rtype
= elf_i386_reloc_type (type
);
1035 rtype
= elf_m68hc11_reloc_type (type
);
1039 rtype
= elf_m68k_reloc_type (type
);
1043 rtype
= elf_i960_reloc_type (type
);
1048 rtype
= elf_avr_reloc_type (type
);
1051 case EM_OLD_SPARCV9
:
1052 case EM_SPARC32PLUS
:
1055 rtype
= elf_sparc_reloc_type (type
);
1059 rtype
= elf_spu_reloc_type (type
);
1063 rtype
= v800_reloc_type (type
);
1066 case EM_CYGNUS_V850
:
1067 rtype
= v850_reloc_type (type
);
1071 case EM_CYGNUS_D10V
:
1072 rtype
= elf_d10v_reloc_type (type
);
1076 case EM_CYGNUS_D30V
:
1077 rtype
= elf_d30v_reloc_type (type
);
1081 rtype
= elf_dlx_reloc_type (type
);
1085 rtype
= elf_sh_reloc_type (type
);
1089 case EM_CYGNUS_MN10300
:
1090 rtype
= elf_mn10300_reloc_type (type
);
1094 case EM_CYGNUS_MN10200
:
1095 rtype
= elf_mn10200_reloc_type (type
);
1099 case EM_CYGNUS_FR30
:
1100 rtype
= elf_fr30_reloc_type (type
);
1104 rtype
= elf_frv_reloc_type (type
);
1108 rtype
= elf_mcore_reloc_type (type
);
1112 rtype
= elf_mmix_reloc_type (type
);
1116 rtype
= elf_moxie_reloc_type (type
);
1121 rtype
= elf_msp430_reloc_type (type
);
1125 rtype
= elf_ppc_reloc_type (type
);
1129 rtype
= elf_ppc64_reloc_type (type
);
1133 case EM_MIPS_RS3_LE
:
1134 rtype
= elf_mips_reloc_type (type
);
1138 rtype
= elf_alpha_reloc_type (type
);
1142 rtype
= elf_arm_reloc_type (type
);
1146 rtype
= elf_arc_reloc_type (type
);
1150 rtype
= elf_hppa_reloc_type (type
);
1156 rtype
= elf_h8_reloc_type (type
);
1161 rtype
= elf_or32_reloc_type (type
);
1166 rtype
= elf_pj_reloc_type (type
);
1169 rtype
= elf_ia64_reloc_type (type
);
1173 rtype
= elf_cris_reloc_type (type
);
1177 rtype
= elf_i860_reloc_type (type
);
1183 rtype
= elf_x86_64_reloc_type (type
);
1187 rtype
= i370_reloc_type (type
);
1192 rtype
= elf_s390_reloc_type (type
);
1196 rtype
= elf_score_reloc_type (type
);
1200 rtype
= elf_xstormy16_reloc_type (type
);
1204 rtype
= elf_crx_reloc_type (type
);
1208 rtype
= elf_vax_reloc_type (type
);
1211 case EM_ADAPTEVA_EPIPHANY
:
1212 rtype
= elf_epiphany_reloc_type (type
);
1217 rtype
= elf_ip2k_reloc_type (type
);
1221 rtype
= elf_iq2000_reloc_type (type
);
1226 rtype
= elf_xtensa_reloc_type (type
);
1229 case EM_LATTICEMICO32
:
1230 rtype
= elf_lm32_reloc_type (type
);
1235 rtype
= elf_m32c_reloc_type (type
);
1239 rtype
= elf_mt_reloc_type (type
);
1243 rtype
= elf_bfin_reloc_type (type
);
1247 rtype
= elf_mep_reloc_type (type
);
1251 rtype
= elf_cr16_reloc_type (type
);
1255 case EM_MICROBLAZE_OLD
:
1256 rtype
= elf_microblaze_reloc_type (type
);
1260 rtype
= elf_rl78_reloc_type (type
);
1264 rtype
= elf_rx_reloc_type (type
);
1268 rtype
= elf_metag_reloc_type (type
);
1273 rtype
= elf_xc16x_reloc_type (type
);
1277 rtype
= elf_tic6x_reloc_type (type
);
1281 rtype
= elf_tilegx_reloc_type (type
);
1285 rtype
= elf_tilepro_reloc_type (type
);
1289 rtype
= elf_xgate_reloc_type (type
);
1294 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1296 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1298 if (elf_header
.e_machine
== EM_ALPHA
1300 && streq (rtype
, "R_ALPHA_LITUSE")
1303 switch (rels
[i
].r_addend
)
1305 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1306 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1307 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1308 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1309 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1310 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1311 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1312 default: rtype
= NULL
;
1315 printf (" (%s)", rtype
);
1319 printf (_("<unknown addend: %lx>"),
1320 (unsigned long) rels
[i
].r_addend
);
1323 else if (symtab_index
)
1325 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1326 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1329 Elf_Internal_Sym
* psym
;
1331 psym
= symtab
+ symtab_index
;
1335 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1339 unsigned int width
= is_32bit_elf
? 8 : 14;
1341 /* Relocations against GNU_IFUNC symbols do not use the value
1342 of the symbol as the address to relocate against. Instead
1343 they invoke the function named by the symbol and use its
1344 result as the address for relocation.
1346 To indicate this to the user, do not display the value of
1347 the symbol in the "Symbols's Value" field. Instead show
1348 its name followed by () as a hint that the symbol is
1352 || psym
->st_name
== 0
1353 || psym
->st_name
>= strtablen
)
1356 name
= strtab
+ psym
->st_name
;
1358 len
= print_symbol (width
, name
);
1359 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1363 print_vma (psym
->st_value
, LONG_HEX
);
1365 printf (is_32bit_elf
? " " : " ");
1368 if (psym
->st_name
== 0)
1370 const char * sec_name
= "<null>";
1373 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1375 if (psym
->st_shndx
< elf_header
.e_shnum
)
1377 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1378 else if (psym
->st_shndx
== SHN_ABS
)
1380 else if (psym
->st_shndx
== SHN_COMMON
)
1381 sec_name
= "COMMON";
1382 else if ((elf_header
.e_machine
== EM_MIPS
1383 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1384 || (elf_header
.e_machine
== EM_TI_C6000
1385 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1386 sec_name
= "SCOMMON";
1387 else if (elf_header
.e_machine
== EM_MIPS
1388 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1389 sec_name
= "SUNDEF";
1390 else if ((elf_header
.e_machine
== EM_X86_64
1391 || elf_header
.e_machine
== EM_L1OM
1392 || elf_header
.e_machine
== EM_K1OM
)
1393 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1394 sec_name
= "LARGE_COMMON";
1395 else if (elf_header
.e_machine
== EM_IA_64
1396 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1397 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1398 sec_name
= "ANSI_COM";
1399 else if (is_ia64_vms ()
1400 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1401 sec_name
= "VMS_SYMVEC";
1404 sprintf (name_buf
, "<section 0x%x>",
1405 (unsigned int) psym
->st_shndx
);
1406 sec_name
= name_buf
;
1409 print_symbol (22, sec_name
);
1411 else if (strtab
== NULL
)
1412 printf (_("<string table index: %3ld>"), psym
->st_name
);
1413 else if (psym
->st_name
>= strtablen
)
1414 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1416 print_symbol (22, strtab
+ psym
->st_name
);
1420 bfd_signed_vma off
= rels
[i
].r_addend
;
1423 printf (" - %" BFD_VMA_FMT
"x", - off
);
1425 printf (" + %" BFD_VMA_FMT
"x", off
);
1431 bfd_signed_vma off
= rels
[i
].r_addend
;
1433 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1435 printf ("-%" BFD_VMA_FMT
"x", - off
);
1437 printf ("%" BFD_VMA_FMT
"x", off
);
1440 if (elf_header
.e_machine
== EM_SPARCV9
1442 && streq (rtype
, "R_SPARC_OLO10"))
1443 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1448 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1450 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1451 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1452 const char * rtype2
= elf_mips_reloc_type (type2
);
1453 const char * rtype3
= elf_mips_reloc_type (type3
);
1455 printf (" Type2: ");
1458 printf (_("unrecognized: %-7lx"),
1459 (unsigned long) type2
& 0xffffffff);
1461 printf ("%-17.17s", rtype2
);
1463 printf ("\n Type3: ");
1466 printf (_("unrecognized: %-7lx"),
1467 (unsigned long) type3
& 0xffffffff);
1469 printf ("%-17.17s", rtype3
);
1480 get_mips_dynamic_type (unsigned long type
)
1484 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1485 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1486 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1487 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1488 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1489 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1490 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1491 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1492 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1493 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1494 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1495 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1496 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1497 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1498 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1499 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1500 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1501 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1502 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1503 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1504 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1505 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1506 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1507 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1508 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1509 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1510 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1511 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1512 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1513 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1514 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1515 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1516 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1517 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1518 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1519 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1520 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1521 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1522 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1523 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1524 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1525 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1526 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1527 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1528 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1535 get_sparc64_dynamic_type (unsigned long type
)
1539 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1546 get_ppc_dynamic_type (unsigned long type
)
1550 case DT_PPC_GOT
: return "PPC_GOT";
1551 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1558 get_ppc64_dynamic_type (unsigned long type
)
1562 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1563 case DT_PPC64_OPD
: return "PPC64_OPD";
1564 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1565 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1572 get_parisc_dynamic_type (unsigned long type
)
1576 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1577 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1578 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1579 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1580 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1581 case DT_HP_PREINIT
: return "HP_PREINIT";
1582 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1583 case DT_HP_NEEDED
: return "HP_NEEDED";
1584 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1585 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1586 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1587 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1588 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1589 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1590 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1591 case DT_HP_FILTERED
: return "HP_FILTERED";
1592 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1593 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1594 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1595 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1596 case DT_PLT
: return "PLT";
1597 case DT_PLT_SIZE
: return "PLT_SIZE";
1598 case DT_DLT
: return "DLT";
1599 case DT_DLT_SIZE
: return "DLT_SIZE";
1606 get_ia64_dynamic_type (unsigned long type
)
1610 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1611 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1612 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1613 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1614 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1615 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1616 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1617 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1618 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1619 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1620 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1621 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1622 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1623 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1624 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1625 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1626 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1627 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1628 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1629 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1630 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1631 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1632 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1633 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1634 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1635 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1636 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1637 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1638 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1639 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1640 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1647 get_alpha_dynamic_type (unsigned long type
)
1651 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1658 get_score_dynamic_type (unsigned long type
)
1662 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1663 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1664 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1665 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1666 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1667 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1674 get_tic6x_dynamic_type (unsigned long type
)
1678 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1679 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1680 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1681 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1682 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1683 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1690 get_dynamic_type (unsigned long type
)
1692 static char buff
[64];
1696 case DT_NULL
: return "NULL";
1697 case DT_NEEDED
: return "NEEDED";
1698 case DT_PLTRELSZ
: return "PLTRELSZ";
1699 case DT_PLTGOT
: return "PLTGOT";
1700 case DT_HASH
: return "HASH";
1701 case DT_STRTAB
: return "STRTAB";
1702 case DT_SYMTAB
: return "SYMTAB";
1703 case DT_RELA
: return "RELA";
1704 case DT_RELASZ
: return "RELASZ";
1705 case DT_RELAENT
: return "RELAENT";
1706 case DT_STRSZ
: return "STRSZ";
1707 case DT_SYMENT
: return "SYMENT";
1708 case DT_INIT
: return "INIT";
1709 case DT_FINI
: return "FINI";
1710 case DT_SONAME
: return "SONAME";
1711 case DT_RPATH
: return "RPATH";
1712 case DT_SYMBOLIC
: return "SYMBOLIC";
1713 case DT_REL
: return "REL";
1714 case DT_RELSZ
: return "RELSZ";
1715 case DT_RELENT
: return "RELENT";
1716 case DT_PLTREL
: return "PLTREL";
1717 case DT_DEBUG
: return "DEBUG";
1718 case DT_TEXTREL
: return "TEXTREL";
1719 case DT_JMPREL
: return "JMPREL";
1720 case DT_BIND_NOW
: return "BIND_NOW";
1721 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1722 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1723 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1724 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1725 case DT_RUNPATH
: return "RUNPATH";
1726 case DT_FLAGS
: return "FLAGS";
1728 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1729 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1731 case DT_CHECKSUM
: return "CHECKSUM";
1732 case DT_PLTPADSZ
: return "PLTPADSZ";
1733 case DT_MOVEENT
: return "MOVEENT";
1734 case DT_MOVESZ
: return "MOVESZ";
1735 case DT_FEATURE
: return "FEATURE";
1736 case DT_POSFLAG_1
: return "POSFLAG_1";
1737 case DT_SYMINSZ
: return "SYMINSZ";
1738 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1740 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1741 case DT_CONFIG
: return "CONFIG";
1742 case DT_DEPAUDIT
: return "DEPAUDIT";
1743 case DT_AUDIT
: return "AUDIT";
1744 case DT_PLTPAD
: return "PLTPAD";
1745 case DT_MOVETAB
: return "MOVETAB";
1746 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1748 case DT_VERSYM
: return "VERSYM";
1750 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1751 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1752 case DT_RELACOUNT
: return "RELACOUNT";
1753 case DT_RELCOUNT
: return "RELCOUNT";
1754 case DT_FLAGS_1
: return "FLAGS_1";
1755 case DT_VERDEF
: return "VERDEF";
1756 case DT_VERDEFNUM
: return "VERDEFNUM";
1757 case DT_VERNEED
: return "VERNEED";
1758 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1760 case DT_AUXILIARY
: return "AUXILIARY";
1761 case DT_USED
: return "USED";
1762 case DT_FILTER
: return "FILTER";
1764 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1765 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1766 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1767 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1768 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1769 case DT_GNU_HASH
: return "GNU_HASH";
1772 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1774 const char * result
;
1776 switch (elf_header
.e_machine
)
1779 case EM_MIPS_RS3_LE
:
1780 result
= get_mips_dynamic_type (type
);
1783 result
= get_sparc64_dynamic_type (type
);
1786 result
= get_ppc_dynamic_type (type
);
1789 result
= get_ppc64_dynamic_type (type
);
1792 result
= get_ia64_dynamic_type (type
);
1795 result
= get_alpha_dynamic_type (type
);
1798 result
= get_score_dynamic_type (type
);
1801 result
= get_tic6x_dynamic_type (type
);
1811 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1813 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1814 || (elf_header
.e_machine
== EM_PARISC
1815 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1817 const char * result
;
1819 switch (elf_header
.e_machine
)
1822 result
= get_parisc_dynamic_type (type
);
1825 result
= get_ia64_dynamic_type (type
);
1835 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1839 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1846 get_file_type (unsigned e_type
)
1848 static char buff
[32];
1852 case ET_NONE
: return _("NONE (None)");
1853 case ET_REL
: return _("REL (Relocatable file)");
1854 case ET_EXEC
: return _("EXEC (Executable file)");
1855 case ET_DYN
: return _("DYN (Shared object file)");
1856 case ET_CORE
: return _("CORE (Core file)");
1859 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1860 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1861 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1862 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1864 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1870 get_machine_name (unsigned e_machine
)
1872 static char buff
[64]; /* XXX */
1876 case EM_NONE
: return _("None");
1877 case EM_AARCH64
: return "AArch64";
1878 case EM_M32
: return "WE32100";
1879 case EM_SPARC
: return "Sparc";
1880 case EM_SPU
: return "SPU";
1881 case EM_386
: return "Intel 80386";
1882 case EM_68K
: return "MC68000";
1883 case EM_88K
: return "MC88000";
1884 case EM_486
: return "Intel 80486";
1885 case EM_860
: return "Intel 80860";
1886 case EM_MIPS
: return "MIPS R3000";
1887 case EM_S370
: return "IBM System/370";
1888 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1889 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1890 case EM_PARISC
: return "HPPA";
1891 case EM_PPC_OLD
: return "Power PC (old)";
1892 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1893 case EM_960
: return "Intel 90860";
1894 case EM_PPC
: return "PowerPC";
1895 case EM_PPC64
: return "PowerPC64";
1896 case EM_FR20
: return "Fujitsu FR20";
1897 case EM_RH32
: return "TRW RH32";
1898 case EM_MCORE
: return "MCORE";
1899 case EM_ARM
: return "ARM";
1900 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1901 case EM_SH
: return "Renesas / SuperH SH";
1902 case EM_SPARCV9
: return "Sparc v9";
1903 case EM_TRICORE
: return "Siemens Tricore";
1904 case EM_ARC
: return "ARC";
1905 case EM_H8_300
: return "Renesas H8/300";
1906 case EM_H8_300H
: return "Renesas H8/300H";
1907 case EM_H8S
: return "Renesas H8S";
1908 case EM_H8_500
: return "Renesas H8/500";
1909 case EM_IA_64
: return "Intel IA-64";
1910 case EM_MIPS_X
: return "Stanford MIPS-X";
1911 case EM_COLDFIRE
: return "Motorola Coldfire";
1912 case EM_ALPHA
: return "Alpha";
1913 case EM_CYGNUS_D10V
:
1914 case EM_D10V
: return "d10v";
1915 case EM_CYGNUS_D30V
:
1916 case EM_D30V
: return "d30v";
1917 case EM_CYGNUS_M32R
:
1918 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1919 case EM_CYGNUS_V850
:
1920 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1921 case EM_V850
: return "Renesas V850";
1922 case EM_CYGNUS_MN10300
:
1923 case EM_MN10300
: return "mn10300";
1924 case EM_CYGNUS_MN10200
:
1925 case EM_MN10200
: return "mn10200";
1926 case EM_MOXIE
: return "Moxie";
1927 case EM_CYGNUS_FR30
:
1928 case EM_FR30
: return "Fujitsu FR30";
1929 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1931 case EM_PJ
: return "picoJava";
1932 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1933 case EM_PCP
: return "Siemens PCP";
1934 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1935 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1936 case EM_STARCORE
: return "Motorola Star*Core processor";
1937 case EM_ME16
: return "Toyota ME16 processor";
1938 case EM_ST100
: return "STMicroelectronics ST100 processor";
1939 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1940 case EM_PDSP
: return "Sony DSP processor";
1941 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1942 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1943 case EM_FX66
: return "Siemens FX66 microcontroller";
1944 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1945 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1946 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1947 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1948 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1949 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1950 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1951 case EM_SVX
: return "Silicon Graphics SVx";
1952 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1953 case EM_VAX
: return "Digital VAX";
1955 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1956 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1957 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1958 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1959 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1960 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1961 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1962 case EM_PRISM
: return "Vitesse Prism";
1963 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1964 case EM_L1OM
: return "Intel L1OM";
1965 case EM_K1OM
: return "Intel K1OM";
1967 case EM_S390
: return "IBM S/390";
1968 case EM_SCORE
: return "SUNPLUS S+Core";
1969 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1971 case EM_OR32
: return "OpenRISC";
1972 case EM_ARC_A5
: return "ARC International ARCompact processor";
1973 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1974 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
1975 case EM_DLX
: return "OpenDLX";
1977 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1978 case EM_IQ2000
: return "Vitesse IQ2000";
1980 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1981 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1982 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1983 case EM_NS32K
: return "National Semiconductor 32000 series";
1984 case EM_TPC
: return "Tenor Network TPC processor";
1985 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1986 case EM_MAX
: return "MAX Processor";
1987 case EM_CR
: return "National Semiconductor CompactRISC";
1988 case EM_F2MC16
: return "Fujitsu F2MC16";
1989 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1990 case EM_LATTICEMICO32
: return "Lattice Mico32";
1992 case EM_M32C
: return "Renesas M32c";
1993 case EM_MT
: return "Morpho Techologies MT processor";
1994 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1995 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1996 case EM_SEP
: return "Sharp embedded microprocessor";
1997 case EM_ARCA
: return "Arca RISC microprocessor";
1998 case EM_UNICORE
: return "Unicore";
1999 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2000 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2001 case EM_NIOS32
: return "Altera Nios";
2002 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2004 case EM_XC16X
: return "Infineon Technologies xc16x";
2005 case EM_M16C
: return "Renesas M16C series microprocessors";
2006 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2007 case EM_CE
: return "Freescale Communication Engine RISC core";
2008 case EM_TSK3000
: return "Altium TSK3000 core";
2009 case EM_RS08
: return "Freescale RS08 embedded processor";
2010 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2011 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2012 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2013 case EM_SE_C17
: return "Seiko Epson C17 family";
2014 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2015 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2016 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2017 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2018 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2019 case EM_R32C
: return "Renesas R32C series microprocessors";
2020 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2021 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2022 case EM_8051
: return "Intel 8051 and variants";
2023 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2024 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2025 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2026 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2027 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2028 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2029 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2030 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2033 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2034 case EM_RL78
: return "Renesas RL78";
2035 case EM_RX
: return "Renesas RX";
2036 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2037 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2038 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2039 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2040 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2041 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2042 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2043 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2044 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2045 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2046 case EM_CUDA
: return "NVIDIA CUDA architecture";
2047 case EM_XGATE
: return "Motorola XGATE embedded processor";
2049 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2055 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2060 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2061 e_flags
&= ~ EF_ARM_EABIMASK
;
2063 /* Handle "generic" ARM flags. */
2064 if (e_flags
& EF_ARM_RELEXEC
)
2066 strcat (buf
, ", relocatable executable");
2067 e_flags
&= ~ EF_ARM_RELEXEC
;
2070 if (e_flags
& EF_ARM_HASENTRY
)
2072 strcat (buf
, ", has entry point");
2073 e_flags
&= ~ EF_ARM_HASENTRY
;
2076 /* Now handle EABI specific flags. */
2080 strcat (buf
, ", <unrecognized EABI>");
2085 case EF_ARM_EABI_VER1
:
2086 strcat (buf
, ", Version1 EABI");
2091 /* Process flags one bit at a time. */
2092 flag
= e_flags
& - e_flags
;
2097 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2098 strcat (buf
, ", sorted symbol tables");
2108 case EF_ARM_EABI_VER2
:
2109 strcat (buf
, ", Version2 EABI");
2114 /* Process flags one bit at a time. */
2115 flag
= e_flags
& - e_flags
;
2120 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2121 strcat (buf
, ", sorted symbol tables");
2124 case EF_ARM_DYNSYMSUSESEGIDX
:
2125 strcat (buf
, ", dynamic symbols use segment index");
2128 case EF_ARM_MAPSYMSFIRST
:
2129 strcat (buf
, ", mapping symbols precede others");
2139 case EF_ARM_EABI_VER3
:
2140 strcat (buf
, ", Version3 EABI");
2143 case EF_ARM_EABI_VER4
:
2144 strcat (buf
, ", Version4 EABI");
2149 /* Process flags one bit at a time. */
2150 flag
= e_flags
& - e_flags
;
2156 strcat (buf
, ", BE8");
2160 strcat (buf
, ", LE8");
2171 case EF_ARM_EABI_VER5
:
2172 strcat (buf
, ", Version5 EABI");
2177 /* Process flags one bit at a time. */
2178 flag
= e_flags
& - e_flags
;
2184 strcat (buf
, ", BE8");
2188 strcat (buf
, ", LE8");
2191 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2192 strcat (buf
, ", soft-float ABI");
2195 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2196 strcat (buf
, ", hard-float ABI");
2206 case EF_ARM_EABI_UNKNOWN
:
2207 strcat (buf
, ", GNU EABI");
2212 /* Process flags one bit at a time. */
2213 flag
= e_flags
& - e_flags
;
2218 case EF_ARM_INTERWORK
:
2219 strcat (buf
, ", interworking enabled");
2222 case EF_ARM_APCS_26
:
2223 strcat (buf
, ", uses APCS/26");
2226 case EF_ARM_APCS_FLOAT
:
2227 strcat (buf
, ", uses APCS/float");
2231 strcat (buf
, ", position independent");
2235 strcat (buf
, ", 8 bit structure alignment");
2238 case EF_ARM_NEW_ABI
:
2239 strcat (buf
, ", uses new ABI");
2242 case EF_ARM_OLD_ABI
:
2243 strcat (buf
, ", uses old ABI");
2246 case EF_ARM_SOFT_FLOAT
:
2247 strcat (buf
, ", software FP");
2250 case EF_ARM_VFP_FLOAT
:
2251 strcat (buf
, ", VFP");
2254 case EF_ARM_MAVERICK_FLOAT
:
2255 strcat (buf
, ", Maverick FP");
2266 strcat (buf
,_(", <unknown>"));
2270 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2272 static char buf
[1024];
2284 decode_ARM_machine_flags (e_flags
, buf
);
2288 if (e_flags
& EF_BFIN_PIC
)
2289 strcat (buf
, ", PIC");
2291 if (e_flags
& EF_BFIN_FDPIC
)
2292 strcat (buf
, ", FDPIC");
2294 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2295 strcat (buf
, ", code in L1");
2297 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2298 strcat (buf
, ", data in L1");
2303 switch (e_flags
& EF_FRV_CPU_MASK
)
2305 case EF_FRV_CPU_GENERIC
:
2309 strcat (buf
, ", fr???");
2312 case EF_FRV_CPU_FR300
:
2313 strcat (buf
, ", fr300");
2316 case EF_FRV_CPU_FR400
:
2317 strcat (buf
, ", fr400");
2319 case EF_FRV_CPU_FR405
:
2320 strcat (buf
, ", fr405");
2323 case EF_FRV_CPU_FR450
:
2324 strcat (buf
, ", fr450");
2327 case EF_FRV_CPU_FR500
:
2328 strcat (buf
, ", fr500");
2330 case EF_FRV_CPU_FR550
:
2331 strcat (buf
, ", fr550");
2334 case EF_FRV_CPU_SIMPLE
:
2335 strcat (buf
, ", simple");
2337 case EF_FRV_CPU_TOMCAT
:
2338 strcat (buf
, ", tomcat");
2344 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2345 strcat (buf
, ", m68000");
2346 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2347 strcat (buf
, ", cpu32");
2348 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2349 strcat (buf
, ", fido_a");
2352 char const * isa
= _("unknown");
2353 char const * mac
= _("unknown mac");
2354 char const * additional
= NULL
;
2356 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2358 case EF_M68K_CF_ISA_A_NODIV
:
2360 additional
= ", nodiv";
2362 case EF_M68K_CF_ISA_A
:
2365 case EF_M68K_CF_ISA_A_PLUS
:
2368 case EF_M68K_CF_ISA_B_NOUSP
:
2370 additional
= ", nousp";
2372 case EF_M68K_CF_ISA_B
:
2375 case EF_M68K_CF_ISA_C
:
2378 case EF_M68K_CF_ISA_C_NODIV
:
2380 additional
= ", nodiv";
2383 strcat (buf
, ", cf, isa ");
2386 strcat (buf
, additional
);
2387 if (e_flags
& EF_M68K_CF_FLOAT
)
2388 strcat (buf
, ", float");
2389 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2394 case EF_M68K_CF_MAC
:
2397 case EF_M68K_CF_EMAC
:
2400 case EF_M68K_CF_EMAC_B
:
2413 if (e_flags
& EF_PPC_EMB
)
2414 strcat (buf
, ", emb");
2416 if (e_flags
& EF_PPC_RELOCATABLE
)
2417 strcat (buf
, _(", relocatable"));
2419 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2420 strcat (buf
, _(", relocatable-lib"));
2424 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2425 strcat (buf
, ", RH850 ABI");
2427 if (e_flags
& EF_V800_850E3
)
2428 strcat (buf
, ", V3 architecture");
2430 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2431 strcat (buf
, ", FPU not used");
2433 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2434 strcat (buf
, ", regmode: COMMON");
2436 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2437 strcat (buf
, ", r4 not used");
2439 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2440 strcat (buf
, ", r30 not used");
2442 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2443 strcat (buf
, ", r5 not used");
2445 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2446 strcat (buf
, ", r2 not used");
2448 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2450 switch (e_flags
& - e_flags
)
2452 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2453 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2454 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2455 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2456 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2457 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2458 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2459 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2460 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2461 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2462 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2463 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2464 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2465 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2466 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2467 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2474 case EM_CYGNUS_V850
:
2475 switch (e_flags
& EF_V850_ARCH
)
2477 case E_V850E3V5_ARCH
:
2478 strcat (buf
, ", v850e3v5");
2480 case E_V850E2V3_ARCH
:
2481 strcat (buf
, ", v850e2v3");
2484 strcat (buf
, ", v850e2");
2487 strcat (buf
, ", v850e1");
2490 strcat (buf
, ", v850e");
2493 strcat (buf
, ", v850");
2496 strcat (buf
, _(", unknown v850 architecture variant"));
2502 case EM_CYGNUS_M32R
:
2503 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2504 strcat (buf
, ", m32r");
2508 case EM_MIPS_RS3_LE
:
2509 if (e_flags
& EF_MIPS_NOREORDER
)
2510 strcat (buf
, ", noreorder");
2512 if (e_flags
& EF_MIPS_PIC
)
2513 strcat (buf
, ", pic");
2515 if (e_flags
& EF_MIPS_CPIC
)
2516 strcat (buf
, ", cpic");
2518 if (e_flags
& EF_MIPS_UCODE
)
2519 strcat (buf
, ", ugen_reserved");
2521 if (e_flags
& EF_MIPS_ABI2
)
2522 strcat (buf
, ", abi2");
2524 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2525 strcat (buf
, ", odk first");
2527 if (e_flags
& EF_MIPS_32BITMODE
)
2528 strcat (buf
, ", 32bitmode");
2530 switch ((e_flags
& EF_MIPS_MACH
))
2532 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2533 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2534 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2535 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2536 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2537 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2538 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2539 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2540 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2541 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2542 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2543 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2544 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2545 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2546 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2547 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2549 /* We simply ignore the field in this case to avoid confusion:
2550 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2553 default: strcat (buf
, _(", unknown CPU")); break;
2556 switch ((e_flags
& EF_MIPS_ABI
))
2558 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2559 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2560 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2561 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2563 /* We simply ignore the field in this case to avoid confusion:
2564 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2565 This means it is likely to be an o32 file, but not for
2568 default: strcat (buf
, _(", unknown ABI")); break;
2571 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2572 strcat (buf
, ", mdmx");
2574 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2575 strcat (buf
, ", mips16");
2577 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2578 strcat (buf
, ", micromips");
2580 switch ((e_flags
& EF_MIPS_ARCH
))
2582 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2583 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2584 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2585 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2586 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2587 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2588 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2589 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2590 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2591 default: strcat (buf
, _(", unknown ISA")); break;
2596 switch ((e_flags
& EF_SH_MACH_MASK
))
2598 case EF_SH1
: strcat (buf
, ", sh1"); break;
2599 case EF_SH2
: strcat (buf
, ", sh2"); break;
2600 case EF_SH3
: strcat (buf
, ", sh3"); break;
2601 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2602 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2603 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2604 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2605 case EF_SH4
: strcat (buf
, ", sh4"); break;
2606 case EF_SH5
: strcat (buf
, ", sh5"); break;
2607 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2608 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2609 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2610 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2611 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2612 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2613 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2614 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2615 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2616 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2617 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2618 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2619 default: strcat (buf
, _(", unknown ISA")); break;
2622 if (e_flags
& EF_SH_PIC
)
2623 strcat (buf
, ", pic");
2625 if (e_flags
& EF_SH_FDPIC
)
2626 strcat (buf
, ", fdpic");
2630 if (e_flags
& EF_SPARC_32PLUS
)
2631 strcat (buf
, ", v8+");
2633 if (e_flags
& EF_SPARC_SUN_US1
)
2634 strcat (buf
, ", ultrasparcI");
2636 if (e_flags
& EF_SPARC_SUN_US3
)
2637 strcat (buf
, ", ultrasparcIII");
2639 if (e_flags
& EF_SPARC_HAL_R1
)
2640 strcat (buf
, ", halr1");
2642 if (e_flags
& EF_SPARC_LEDATA
)
2643 strcat (buf
, ", ledata");
2645 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2646 strcat (buf
, ", tso");
2648 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2649 strcat (buf
, ", pso");
2651 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2652 strcat (buf
, ", rmo");
2656 switch (e_flags
& EF_PARISC_ARCH
)
2658 case EFA_PARISC_1_0
:
2659 strcpy (buf
, ", PA-RISC 1.0");
2661 case EFA_PARISC_1_1
:
2662 strcpy (buf
, ", PA-RISC 1.1");
2664 case EFA_PARISC_2_0
:
2665 strcpy (buf
, ", PA-RISC 2.0");
2670 if (e_flags
& EF_PARISC_TRAPNIL
)
2671 strcat (buf
, ", trapnil");
2672 if (e_flags
& EF_PARISC_EXT
)
2673 strcat (buf
, ", ext");
2674 if (e_flags
& EF_PARISC_LSB
)
2675 strcat (buf
, ", lsb");
2676 if (e_flags
& EF_PARISC_WIDE
)
2677 strcat (buf
, ", wide");
2678 if (e_flags
& EF_PARISC_NO_KABP
)
2679 strcat (buf
, ", no kabp");
2680 if (e_flags
& EF_PARISC_LAZYSWAP
)
2681 strcat (buf
, ", lazyswap");
2686 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2687 strcat (buf
, ", new calling convention");
2689 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2690 strcat (buf
, ", gnu calling convention");
2694 if ((e_flags
& EF_IA_64_ABI64
))
2695 strcat (buf
, ", 64-bit");
2697 strcat (buf
, ", 32-bit");
2698 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2699 strcat (buf
, ", reduced fp model");
2700 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2701 strcat (buf
, ", no function descriptors, constant gp");
2702 else if ((e_flags
& EF_IA_64_CONS_GP
))
2703 strcat (buf
, ", constant gp");
2704 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2705 strcat (buf
, ", absolute");
2706 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2708 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2709 strcat (buf
, ", vms_linkages");
2710 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2712 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2714 case EF_IA_64_VMS_COMCOD_WARNING
:
2715 strcat (buf
, ", warning");
2717 case EF_IA_64_VMS_COMCOD_ERROR
:
2718 strcat (buf
, ", error");
2720 case EF_IA_64_VMS_COMCOD_ABORT
:
2721 strcat (buf
, ", abort");
2730 if ((e_flags
& EF_VAX_NONPIC
))
2731 strcat (buf
, ", non-PIC");
2732 if ((e_flags
& EF_VAX_DFLOAT
))
2733 strcat (buf
, ", D-Float");
2734 if ((e_flags
& EF_VAX_GFLOAT
))
2735 strcat (buf
, ", G-Float");
2739 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2740 strcat (buf
, ", 64-bit doubles");
2741 if (e_flags
& E_FLAG_RX_DSP
)
2742 strcat (buf
, ", dsp");
2743 if (e_flags
& E_FLAG_RX_PID
)
2744 strcat (buf
, ", pid");
2745 if (e_flags
& E_FLAG_RX_ABI
)
2746 strcat (buf
, ", RX ABI");
2750 if (e_flags
& EF_S390_HIGH_GPRS
)
2751 strcat (buf
, ", highgprs");
2755 if ((e_flags
& EF_C6000_REL
))
2756 strcat (buf
, ", relocatable module");
2765 get_osabi_name (unsigned int osabi
)
2767 static char buff
[32];
2771 case ELFOSABI_NONE
: return "UNIX - System V";
2772 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2773 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2774 case ELFOSABI_GNU
: return "UNIX - GNU";
2775 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2776 case ELFOSABI_AIX
: return "UNIX - AIX";
2777 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2778 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2779 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2780 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2781 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2782 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2783 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2784 case ELFOSABI_AROS
: return "AROS";
2785 case ELFOSABI_FENIXOS
: return "FenixOS";
2788 switch (elf_header
.e_machine
)
2793 case ELFOSABI_ARM
: return "ARM";
2803 case ELFOSABI_STANDALONE
: return _("Standalone App");
2812 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2813 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2822 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2828 get_aarch64_segment_type (unsigned long type
)
2832 case PT_AARCH64_ARCHEXT
:
2833 return "AARCH64_ARCHEXT";
2842 get_arm_segment_type (unsigned long type
)
2856 get_mips_segment_type (unsigned long type
)
2860 case PT_MIPS_REGINFO
:
2862 case PT_MIPS_RTPROC
:
2864 case PT_MIPS_OPTIONS
:
2874 get_parisc_segment_type (unsigned long type
)
2878 case PT_HP_TLS
: return "HP_TLS";
2879 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2880 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2881 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2882 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2883 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2884 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2885 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2886 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2887 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2888 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2889 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2890 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2891 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2892 case PT_HP_STACK
: return "HP_STACK";
2893 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2894 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2895 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2896 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2905 get_ia64_segment_type (unsigned long type
)
2909 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2910 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2911 case PT_HP_TLS
: return "HP_TLS";
2912 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2913 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2914 case PT_IA_64_HP_STACK
: return "HP_STACK";
2923 get_tic6x_segment_type (unsigned long type
)
2927 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2936 get_segment_type (unsigned long p_type
)
2938 static char buff
[32];
2942 case PT_NULL
: return "NULL";
2943 case PT_LOAD
: return "LOAD";
2944 case PT_DYNAMIC
: return "DYNAMIC";
2945 case PT_INTERP
: return "INTERP";
2946 case PT_NOTE
: return "NOTE";
2947 case PT_SHLIB
: return "SHLIB";
2948 case PT_PHDR
: return "PHDR";
2949 case PT_TLS
: return "TLS";
2951 case PT_GNU_EH_FRAME
:
2952 return "GNU_EH_FRAME";
2953 case PT_GNU_STACK
: return "GNU_STACK";
2954 case PT_GNU_RELRO
: return "GNU_RELRO";
2957 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2959 const char * result
;
2961 switch (elf_header
.e_machine
)
2964 result
= get_aarch64_segment_type (p_type
);
2967 result
= get_arm_segment_type (p_type
);
2970 case EM_MIPS_RS3_LE
:
2971 result
= get_mips_segment_type (p_type
);
2974 result
= get_parisc_segment_type (p_type
);
2977 result
= get_ia64_segment_type (p_type
);
2980 result
= get_tic6x_segment_type (p_type
);
2990 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2992 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2994 const char * result
;
2996 switch (elf_header
.e_machine
)
2999 result
= get_parisc_segment_type (p_type
);
3002 result
= get_ia64_segment_type (p_type
);
3012 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3015 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3022 get_mips_section_type_name (unsigned int sh_type
)
3026 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3027 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3028 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3029 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3030 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3031 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3032 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3033 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3034 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3035 case SHT_MIPS_RELD
: return "MIPS_RELD";
3036 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3037 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3038 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3039 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3040 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3041 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3042 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3043 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3044 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3045 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3046 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3047 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3048 case SHT_MIPS_LINE
: return "MIPS_LINE";
3049 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3050 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3051 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3052 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3053 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3054 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3055 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3056 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3057 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3058 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3059 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3060 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3061 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3062 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3063 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3064 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3072 get_parisc_section_type_name (unsigned int sh_type
)
3076 case SHT_PARISC_EXT
: return "PARISC_EXT";
3077 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3078 case SHT_PARISC_DOC
: return "PARISC_DOC";
3079 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3080 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3081 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3082 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3090 get_ia64_section_type_name (unsigned int sh_type
)
3092 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3093 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3094 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3098 case SHT_IA_64_EXT
: return "IA_64_EXT";
3099 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3100 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3101 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3102 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3103 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3104 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3105 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3106 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3107 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3115 get_x86_64_section_type_name (unsigned int sh_type
)
3119 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3127 get_aarch64_section_type_name (unsigned int sh_type
)
3131 case SHT_AARCH64_ATTRIBUTES
:
3132 return "AARCH64_ATTRIBUTES";
3140 get_arm_section_type_name (unsigned int sh_type
)
3144 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3145 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3146 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3147 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3148 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3156 get_tic6x_section_type_name (unsigned int sh_type
)
3160 case SHT_C6000_UNWIND
:
3161 return "C6000_UNWIND";
3162 case SHT_C6000_PREEMPTMAP
:
3163 return "C6000_PREEMPTMAP";
3164 case SHT_C6000_ATTRIBUTES
:
3165 return "C6000_ATTRIBUTES";
3170 case SHT_TI_HANDLER
:
3171 return "TI_HANDLER";
3172 case SHT_TI_INITINFO
:
3173 return "TI_INITINFO";
3174 case SHT_TI_PHATTRS
:
3175 return "TI_PHATTRS";
3183 get_section_type_name (unsigned int sh_type
)
3185 static char buff
[32];
3189 case SHT_NULL
: return "NULL";
3190 case SHT_PROGBITS
: return "PROGBITS";
3191 case SHT_SYMTAB
: return "SYMTAB";
3192 case SHT_STRTAB
: return "STRTAB";
3193 case SHT_RELA
: return "RELA";
3194 case SHT_HASH
: return "HASH";
3195 case SHT_DYNAMIC
: return "DYNAMIC";
3196 case SHT_NOTE
: return "NOTE";
3197 case SHT_NOBITS
: return "NOBITS";
3198 case SHT_REL
: return "REL";
3199 case SHT_SHLIB
: return "SHLIB";
3200 case SHT_DYNSYM
: return "DYNSYM";
3201 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3202 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3203 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3204 case SHT_GNU_HASH
: return "GNU_HASH";
3205 case SHT_GROUP
: return "GROUP";
3206 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3207 case SHT_GNU_verdef
: return "VERDEF";
3208 case SHT_GNU_verneed
: return "VERNEED";
3209 case SHT_GNU_versym
: return "VERSYM";
3210 case 0x6ffffff0: return "VERSYM";
3211 case 0x6ffffffc: return "VERDEF";
3212 case 0x7ffffffd: return "AUXILIARY";
3213 case 0x7fffffff: return "FILTER";
3214 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3217 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3219 const char * result
;
3221 switch (elf_header
.e_machine
)
3224 case EM_MIPS_RS3_LE
:
3225 result
= get_mips_section_type_name (sh_type
);
3228 result
= get_parisc_section_type_name (sh_type
);
3231 result
= get_ia64_section_type_name (sh_type
);
3236 result
= get_x86_64_section_type_name (sh_type
);
3239 result
= get_aarch64_section_type_name (sh_type
);
3242 result
= get_arm_section_type_name (sh_type
);
3245 result
= get_tic6x_section_type_name (sh_type
);
3255 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3257 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3259 const char * result
;
3261 switch (elf_header
.e_machine
)
3264 result
= get_ia64_section_type_name (sh_type
);
3274 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3276 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3277 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3279 /* This message is probably going to be displayed in a 15
3280 character wide field, so put the hex value first. */
3281 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3287 #define OPTION_DEBUG_DUMP 512
3288 #define OPTION_DYN_SYMS 513
3289 #define OPTION_DWARF_DEPTH 514
3290 #define OPTION_DWARF_START 515
3291 #define OPTION_DWARF_CHECK 516
3293 static struct option options
[] =
3295 {"all", no_argument
, 0, 'a'},
3296 {"file-header", no_argument
, 0, 'h'},
3297 {"program-headers", no_argument
, 0, 'l'},
3298 {"headers", no_argument
, 0, 'e'},
3299 {"histogram", no_argument
, 0, 'I'},
3300 {"segments", no_argument
, 0, 'l'},
3301 {"sections", no_argument
, 0, 'S'},
3302 {"section-headers", no_argument
, 0, 'S'},
3303 {"section-groups", no_argument
, 0, 'g'},
3304 {"section-details", no_argument
, 0, 't'},
3305 {"full-section-name",no_argument
, 0, 'N'},
3306 {"symbols", no_argument
, 0, 's'},
3307 {"syms", no_argument
, 0, 's'},
3308 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3309 {"relocs", no_argument
, 0, 'r'},
3310 {"notes", no_argument
, 0, 'n'},
3311 {"dynamic", no_argument
, 0, 'd'},
3312 {"arch-specific", no_argument
, 0, 'A'},
3313 {"version-info", no_argument
, 0, 'V'},
3314 {"use-dynamic", no_argument
, 0, 'D'},
3315 {"unwind", no_argument
, 0, 'u'},
3316 {"archive-index", no_argument
, 0, 'c'},
3317 {"hex-dump", required_argument
, 0, 'x'},
3318 {"relocated-dump", required_argument
, 0, 'R'},
3319 {"string-dump", required_argument
, 0, 'p'},
3320 #ifdef SUPPORT_DISASSEMBLY
3321 {"instruction-dump", required_argument
, 0, 'i'},
3323 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3325 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3326 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3327 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3329 {"version", no_argument
, 0, 'v'},
3330 {"wide", no_argument
, 0, 'W'},
3331 {"help", no_argument
, 0, 'H'},
3332 {0, no_argument
, 0, 0}
3336 usage (FILE * stream
)
3338 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3339 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3340 fprintf (stream
, _(" Options are:\n\
3341 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3342 -h --file-header Display the ELF file header\n\
3343 -l --program-headers Display the program headers\n\
3344 --segments An alias for --program-headers\n\
3345 -S --section-headers Display the sections' header\n\
3346 --sections An alias for --section-headers\n\
3347 -g --section-groups Display the section groups\n\
3348 -t --section-details Display the section details\n\
3349 -e --headers Equivalent to: -h -l -S\n\
3350 -s --syms Display the symbol table\n\
3351 --symbols An alias for --syms\n\
3352 --dyn-syms Display the dynamic symbol table\n\
3353 -n --notes Display the core notes (if present)\n\
3354 -r --relocs Display the relocations (if present)\n\
3355 -u --unwind Display the unwind info (if present)\n\
3356 -d --dynamic Display the dynamic section (if present)\n\
3357 -V --version-info Display the version sections (if present)\n\
3358 -A --arch-specific Display architecture specific information (if any)\n\
3359 -c --archive-index Display the symbol/file index in an archive\n\
3360 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3361 -x --hex-dump=<number|name>\n\
3362 Dump the contents of section <number|name> as bytes\n\
3363 -p --string-dump=<number|name>\n\
3364 Dump the contents of section <number|name> as strings\n\
3365 -R --relocated-dump=<number|name>\n\
3366 Dump the contents of section <number|name> as relocated bytes\n\
3367 -w[lLiaprmfFsoRt] or\n\
3368 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3369 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3370 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3372 Display the contents of DWARF2 debug sections\n"));
3373 fprintf (stream
, _("\
3374 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3375 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3377 #ifdef SUPPORT_DISASSEMBLY
3378 fprintf (stream
, _("\
3379 -i --instruction-dump=<number|name>\n\
3380 Disassemble the contents of section <number|name>\n"));
3382 fprintf (stream
, _("\
3383 -I --histogram Display histogram of bucket list lengths\n\
3384 -W --wide Allow output width to exceed 80 characters\n\
3385 @<file> Read options from <file>\n\
3386 -H --help Display this information\n\
3387 -v --version Display the version number of readelf\n"));
3389 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3390 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3392 exit (stream
== stdout
? 0 : 1);
3395 /* Record the fact that the user wants the contents of section number
3396 SECTION to be displayed using the method(s) encoded as flags bits
3397 in TYPE. Note, TYPE can be zero if we are creating the array for
3401 request_dump_bynumber (unsigned int section
, dump_type type
)
3403 if (section
>= num_dump_sects
)
3405 dump_type
* new_dump_sects
;
3407 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3408 sizeof (* dump_sects
));
3410 if (new_dump_sects
== NULL
)
3411 error (_("Out of memory allocating dump request table.\n"));
3414 /* Copy current flag settings. */
3415 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3419 dump_sects
= new_dump_sects
;
3420 num_dump_sects
= section
+ 1;
3425 dump_sects
[section
] |= type
;
3430 /* Request a dump by section name. */
3433 request_dump_byname (const char * section
, dump_type type
)
3435 struct dump_list_entry
* new_request
;
3437 new_request
= (struct dump_list_entry
*)
3438 malloc (sizeof (struct dump_list_entry
));
3440 error (_("Out of memory allocating dump request table.\n"));
3442 new_request
->name
= strdup (section
);
3443 if (!new_request
->name
)
3444 error (_("Out of memory allocating dump request table.\n"));
3446 new_request
->type
= type
;
3448 new_request
->next
= dump_sects_byname
;
3449 dump_sects_byname
= new_request
;
3453 request_dump (dump_type type
)
3459 section
= strtoul (optarg
, & cp
, 0);
3461 if (! *cp
&& section
>= 0)
3462 request_dump_bynumber (section
, type
);
3464 request_dump_byname (optarg
, type
);
3469 parse_args (int argc
, char ** argv
)
3476 while ((c
= getopt_long
3477 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3495 do_section_groups
++;
3503 do_section_groups
++;
3508 do_section_details
++;
3552 request_dump (HEX_DUMP
);
3555 request_dump (STRING_DUMP
);
3558 request_dump (RELOC_DUMP
);
3565 dwarf_select_sections_all ();
3570 dwarf_select_sections_by_letters (optarg
);
3573 case OPTION_DEBUG_DUMP
:
3580 dwarf_select_sections_by_names (optarg
);
3583 case OPTION_DWARF_DEPTH
:
3587 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3590 case OPTION_DWARF_START
:
3594 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3597 case OPTION_DWARF_CHECK
:
3600 case OPTION_DYN_SYMS
:
3603 #ifdef SUPPORT_DISASSEMBLY
3605 request_dump (DISASS_DUMP
);
3609 print_version (program_name
);
3618 /* xgettext:c-format */
3619 error (_("Invalid option '-%c'\n"), c
);
3626 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3627 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3628 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3629 && !do_section_groups
&& !do_archive_index
3634 warn (_("Nothing to do.\n"));
3640 get_elf_class (unsigned int elf_class
)
3642 static char buff
[32];
3646 case ELFCLASSNONE
: return _("none");
3647 case ELFCLASS32
: return "ELF32";
3648 case ELFCLASS64
: return "ELF64";
3650 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3656 get_data_encoding (unsigned int encoding
)
3658 static char buff
[32];
3662 case ELFDATANONE
: return _("none");
3663 case ELFDATA2LSB
: return _("2's complement, little endian");
3664 case ELFDATA2MSB
: return _("2's complement, big endian");
3666 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3671 /* Decode the data held in 'elf_header'. */
3674 process_file_header (void)
3676 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3677 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3678 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3679 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3682 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3686 init_dwarf_regnames (elf_header
.e_machine
);
3692 printf (_("ELF Header:\n"));
3693 printf (_(" Magic: "));
3694 for (i
= 0; i
< EI_NIDENT
; i
++)
3695 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3697 printf (_(" Class: %s\n"),
3698 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3699 printf (_(" Data: %s\n"),
3700 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3701 printf (_(" Version: %d %s\n"),
3702 elf_header
.e_ident
[EI_VERSION
],
3703 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3705 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3706 ? _("<unknown: %lx>")
3708 printf (_(" OS/ABI: %s\n"),
3709 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3710 printf (_(" ABI Version: %d\n"),
3711 elf_header
.e_ident
[EI_ABIVERSION
]);
3712 printf (_(" Type: %s\n"),
3713 get_file_type (elf_header
.e_type
));
3714 printf (_(" Machine: %s\n"),
3715 get_machine_name (elf_header
.e_machine
));
3716 printf (_(" Version: 0x%lx\n"),
3717 (unsigned long) elf_header
.e_version
);
3719 printf (_(" Entry point address: "));
3720 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3721 printf (_("\n Start of program headers: "));
3722 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3723 printf (_(" (bytes into file)\n Start of section headers: "));
3724 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3725 printf (_(" (bytes into file)\n"));
3727 printf (_(" Flags: 0x%lx%s\n"),
3728 (unsigned long) elf_header
.e_flags
,
3729 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3730 printf (_(" Size of this header: %ld (bytes)\n"),
3731 (long) elf_header
.e_ehsize
);
3732 printf (_(" Size of program headers: %ld (bytes)\n"),
3733 (long) elf_header
.e_phentsize
);
3734 printf (_(" Number of program headers: %ld"),
3735 (long) elf_header
.e_phnum
);
3736 if (section_headers
!= NULL
3737 && elf_header
.e_phnum
== PN_XNUM
3738 && section_headers
[0].sh_info
!= 0)
3739 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3740 putc ('\n', stdout
);
3741 printf (_(" Size of section headers: %ld (bytes)\n"),
3742 (long) elf_header
.e_shentsize
);
3743 printf (_(" Number of section headers: %ld"),
3744 (long) elf_header
.e_shnum
);
3745 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3746 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3747 putc ('\n', stdout
);
3748 printf (_(" Section header string table index: %ld"),
3749 (long) elf_header
.e_shstrndx
);
3750 if (section_headers
!= NULL
3751 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3752 printf (" (%u)", section_headers
[0].sh_link
);
3753 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3754 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3755 printf (_(" <corrupt: out of range>"));
3756 putc ('\n', stdout
);
3759 if (section_headers
!= NULL
)
3761 if (elf_header
.e_phnum
== PN_XNUM
3762 && section_headers
[0].sh_info
!= 0)
3763 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3764 if (elf_header
.e_shnum
== SHN_UNDEF
)
3765 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3766 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3767 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3768 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3769 elf_header
.e_shstrndx
= SHN_UNDEF
;
3770 free (section_headers
);
3771 section_headers
= NULL
;
3779 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3781 Elf32_External_Phdr
* phdrs
;
3782 Elf32_External_Phdr
* external
;
3783 Elf_Internal_Phdr
* internal
;
3786 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3787 elf_header
.e_phentsize
,
3789 _("program headers"));
3793 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3794 i
< elf_header
.e_phnum
;
3795 i
++, internal
++, external
++)
3797 internal
->p_type
= BYTE_GET (external
->p_type
);
3798 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3799 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3800 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3801 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3802 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3803 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3804 internal
->p_align
= BYTE_GET (external
->p_align
);
3813 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3815 Elf64_External_Phdr
* phdrs
;
3816 Elf64_External_Phdr
* external
;
3817 Elf_Internal_Phdr
* internal
;
3820 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3821 elf_header
.e_phentsize
,
3823 _("program headers"));
3827 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3828 i
< elf_header
.e_phnum
;
3829 i
++, internal
++, external
++)
3831 internal
->p_type
= BYTE_GET (external
->p_type
);
3832 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3833 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3834 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3835 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3836 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3837 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3838 internal
->p_align
= BYTE_GET (external
->p_align
);
3846 /* Returns 1 if the program headers were read into `program_headers'. */
3849 get_program_headers (FILE * file
)
3851 Elf_Internal_Phdr
* phdrs
;
3853 /* Check cache of prior read. */
3854 if (program_headers
!= NULL
)
3857 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3858 sizeof (Elf_Internal_Phdr
));
3862 error (_("Out of memory\n"));
3867 ? get_32bit_program_headers (file
, phdrs
)
3868 : get_64bit_program_headers (file
, phdrs
))
3870 program_headers
= phdrs
;
3878 /* Returns 1 if the program headers were loaded. */
3881 process_program_headers (FILE * file
)
3883 Elf_Internal_Phdr
* segment
;
3886 if (elf_header
.e_phnum
== 0)
3888 /* PR binutils/12467. */
3889 if (elf_header
.e_phoff
!= 0)
3890 warn (_("possibly corrupt ELF header - it has a non-zero program"
3891 " header offset, but no program headers"));
3892 else if (do_segments
)
3893 printf (_("\nThere are no program headers in this file.\n"));
3897 if (do_segments
&& !do_header
)
3899 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3900 printf (_("Entry point "));
3901 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3902 printf (_("\nThere are %d program headers, starting at offset "),
3903 elf_header
.e_phnum
);
3904 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3908 if (! get_program_headers (file
))
3913 if (elf_header
.e_phnum
> 1)
3914 printf (_("\nProgram Headers:\n"));
3916 printf (_("\nProgram Headers:\n"));
3920 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3923 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3927 (_(" Type Offset VirtAddr PhysAddr\n"));
3929 (_(" FileSiz MemSiz Flags Align\n"));
3936 for (i
= 0, segment
= program_headers
;
3937 i
< elf_header
.e_phnum
;
3942 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3946 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3947 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3948 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3949 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3950 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3952 (segment
->p_flags
& PF_R
? 'R' : ' '),
3953 (segment
->p_flags
& PF_W
? 'W' : ' '),
3954 (segment
->p_flags
& PF_X
? 'E' : ' '));
3955 printf ("%#lx", (unsigned long) segment
->p_align
);
3959 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3960 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3963 print_vma (segment
->p_offset
, FULL_HEX
);
3967 print_vma (segment
->p_vaddr
, FULL_HEX
);
3969 print_vma (segment
->p_paddr
, FULL_HEX
);
3972 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3973 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3976 print_vma (segment
->p_filesz
, FULL_HEX
);
3980 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3981 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3984 print_vma (segment
->p_memsz
, FULL_HEX
);
3988 (segment
->p_flags
& PF_R
? 'R' : ' '),
3989 (segment
->p_flags
& PF_W
? 'W' : ' '),
3990 (segment
->p_flags
& PF_X
? 'E' : ' '));
3992 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3993 printf ("%#lx", (unsigned long) segment
->p_align
);
3996 print_vma (segment
->p_align
, PREFIX_HEX
);
4001 print_vma (segment
->p_offset
, FULL_HEX
);
4003 print_vma (segment
->p_vaddr
, FULL_HEX
);
4005 print_vma (segment
->p_paddr
, FULL_HEX
);
4007 print_vma (segment
->p_filesz
, FULL_HEX
);
4009 print_vma (segment
->p_memsz
, FULL_HEX
);
4011 (segment
->p_flags
& PF_R
? 'R' : ' '),
4012 (segment
->p_flags
& PF_W
? 'W' : ' '),
4013 (segment
->p_flags
& PF_X
? 'E' : ' '));
4014 print_vma (segment
->p_align
, HEX
);
4018 switch (segment
->p_type
)
4022 error (_("more than one dynamic segment\n"));
4024 /* By default, assume that the .dynamic section is the first
4025 section in the DYNAMIC segment. */
4026 dynamic_addr
= segment
->p_offset
;
4027 dynamic_size
= segment
->p_filesz
;
4029 /* Try to locate the .dynamic section. If there is
4030 a section header table, we can easily locate it. */
4031 if (section_headers
!= NULL
)
4033 Elf_Internal_Shdr
* sec
;
4035 sec
= find_section (".dynamic");
4036 if (sec
== NULL
|| sec
->sh_size
== 0)
4038 /* A corresponding .dynamic section is expected, but on
4039 IA-64/OpenVMS it is OK for it to be missing. */
4040 if (!is_ia64_vms ())
4041 error (_("no .dynamic section in the dynamic segment\n"));
4045 if (sec
->sh_type
== SHT_NOBITS
)
4051 dynamic_addr
= sec
->sh_offset
;
4052 dynamic_size
= sec
->sh_size
;
4054 if (dynamic_addr
< segment
->p_offset
4055 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4056 warn (_("the .dynamic section is not contained"
4057 " within the dynamic segment\n"));
4058 else if (dynamic_addr
> segment
->p_offset
)
4059 warn (_("the .dynamic section is not the first section"
4060 " in the dynamic segment.\n"));
4065 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4067 error (_("Unable to find program interpreter name\n"));
4071 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4073 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4074 error (_("Internal error: failed to create format string to display program interpreter\n"));
4076 program_interpreter
[0] = 0;
4077 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4078 error (_("Unable to read program interpreter name\n"));
4081 printf (_("\n [Requesting program interpreter: %s]"),
4082 program_interpreter
);
4088 putc ('\n', stdout
);
4091 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4093 printf (_("\n Section to Segment mapping:\n"));
4094 printf (_(" Segment Sections...\n"));
4096 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4099 Elf_Internal_Shdr
* section
;
4101 segment
= program_headers
+ i
;
4102 section
= section_headers
+ 1;
4104 printf (" %2.2d ", i
);
4106 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4108 if (!ELF_TBSS_SPECIAL (section
, segment
)
4109 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4110 printf ("%s ", SECTION_NAME (section
));
4121 /* Find the file offset corresponding to VMA by using the program headers. */
4124 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4126 Elf_Internal_Phdr
* seg
;
4128 if (! get_program_headers (file
))
4130 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4134 for (seg
= program_headers
;
4135 seg
< program_headers
+ elf_header
.e_phnum
;
4138 if (seg
->p_type
!= PT_LOAD
)
4141 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4142 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4143 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4146 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4147 (unsigned long) vma
);
4153 get_32bit_section_headers (FILE * file
, unsigned int num
)
4155 Elf32_External_Shdr
* shdrs
;
4156 Elf_Internal_Shdr
* internal
;
4159 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4160 elf_header
.e_shentsize
, num
,
4161 _("section headers"));
4165 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4166 sizeof (Elf_Internal_Shdr
));
4168 if (section_headers
== NULL
)
4170 error (_("Out of memory\n"));
4174 for (i
= 0, internal
= section_headers
;
4178 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4179 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4180 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4181 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4182 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4183 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4184 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4185 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4186 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4187 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4196 get_64bit_section_headers (FILE * file
, unsigned int num
)
4198 Elf64_External_Shdr
* shdrs
;
4199 Elf_Internal_Shdr
* internal
;
4202 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4203 elf_header
.e_shentsize
, num
,
4204 _("section headers"));
4208 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4209 sizeof (Elf_Internal_Shdr
));
4211 if (section_headers
== NULL
)
4213 error (_("Out of memory\n"));
4217 for (i
= 0, internal
= section_headers
;
4221 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4222 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4223 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4224 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4225 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4226 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4227 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4228 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4229 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4230 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4238 static Elf_Internal_Sym
*
4239 get_32bit_elf_symbols (FILE * file
,
4240 Elf_Internal_Shdr
* section
,
4241 unsigned long * num_syms_return
)
4243 unsigned long number
= 0;
4244 Elf32_External_Sym
* esyms
= NULL
;
4245 Elf_External_Sym_Shndx
* shndx
= NULL
;
4246 Elf_Internal_Sym
* isyms
= NULL
;
4247 Elf_Internal_Sym
* psym
;
4250 /* Run some sanity checks first. */
4251 if (section
->sh_entsize
== 0)
4253 error (_("sh_entsize is zero\n"));
4257 number
= section
->sh_size
/ section
->sh_entsize
;
4259 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4261 error (_("Invalid sh_entsize\n"));
4265 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4266 section
->sh_size
, _("symbols"));
4271 if (symtab_shndx_hdr
!= NULL
4272 && (symtab_shndx_hdr
->sh_link
4273 == (unsigned long) (section
- section_headers
)))
4275 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4276 symtab_shndx_hdr
->sh_offset
,
4277 1, symtab_shndx_hdr
->sh_size
,
4278 _("symbol table section indicies"));
4283 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4287 error (_("Out of memory\n"));
4291 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4293 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4294 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4295 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4296 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4297 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4299 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4300 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4301 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4302 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4303 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4312 if (num_syms_return
!= NULL
)
4313 * num_syms_return
= isyms
== NULL
? 0 : number
;
4318 static Elf_Internal_Sym
*
4319 get_64bit_elf_symbols (FILE * file
,
4320 Elf_Internal_Shdr
* section
,
4321 unsigned long * num_syms_return
)
4323 unsigned long number
= 0;
4324 Elf64_External_Sym
* esyms
= NULL
;
4325 Elf_External_Sym_Shndx
* shndx
= NULL
;
4326 Elf_Internal_Sym
* isyms
= NULL
;
4327 Elf_Internal_Sym
* psym
;
4330 /* Run some sanity checks first. */
4331 if (section
->sh_entsize
== 0)
4333 error (_("sh_entsize is zero\n"));
4337 number
= section
->sh_size
/ section
->sh_entsize
;
4339 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4341 error (_("Invalid sh_entsize\n"));
4345 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4346 section
->sh_size
, _("symbols"));
4350 if (symtab_shndx_hdr
!= NULL
4351 && (symtab_shndx_hdr
->sh_link
4352 == (unsigned long) (section
- section_headers
)))
4354 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4355 symtab_shndx_hdr
->sh_offset
,
4356 1, symtab_shndx_hdr
->sh_size
,
4357 _("symbol table section indicies"));
4362 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4366 error (_("Out of memory\n"));
4370 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4372 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4373 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4374 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4375 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4377 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4379 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4380 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4381 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4383 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4384 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4393 if (num_syms_return
!= NULL
)
4394 * num_syms_return
= isyms
== NULL
? 0 : number
;
4400 get_elf_section_flags (bfd_vma sh_flags
)
4402 static char buff
[1024];
4404 int field_size
= is_32bit_elf
? 8 : 16;
4406 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4407 bfd_vma os_flags
= 0;
4408 bfd_vma proc_flags
= 0;
4409 bfd_vma unknown_flags
= 0;
4417 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4418 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4419 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4420 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4421 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4422 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4423 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4424 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4425 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4426 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4427 /* IA-64 specific. */
4428 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4429 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4430 /* IA-64 OpenVMS specific. */
4431 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4432 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4433 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4434 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4435 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4436 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4438 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4439 /* SPARC specific. */
4440 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4443 if (do_section_details
)
4445 sprintf (buff
, "[%*.*lx]: ",
4446 field_size
, field_size
, (unsigned long) sh_flags
);
4447 p
+= field_size
+ 4;
4454 flag
= sh_flags
& - sh_flags
;
4457 if (do_section_details
)
4461 case SHF_WRITE
: sindex
= 0; break;
4462 case SHF_ALLOC
: sindex
= 1; break;
4463 case SHF_EXECINSTR
: sindex
= 2; break;
4464 case SHF_MERGE
: sindex
= 3; break;
4465 case SHF_STRINGS
: sindex
= 4; break;
4466 case SHF_INFO_LINK
: sindex
= 5; break;
4467 case SHF_LINK_ORDER
: sindex
= 6; break;
4468 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4469 case SHF_GROUP
: sindex
= 8; break;
4470 case SHF_TLS
: sindex
= 9; break;
4471 case SHF_EXCLUDE
: sindex
= 18; break;
4475 switch (elf_header
.e_machine
)
4478 if (flag
== SHF_IA_64_SHORT
)
4480 else if (flag
== SHF_IA_64_NORECOV
)
4483 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4486 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4487 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4488 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4489 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4490 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4491 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4502 case EM_OLD_SPARCV9
:
4503 case EM_SPARC32PLUS
:
4506 if (flag
== SHF_ORDERED
)
4516 if (p
!= buff
+ field_size
+ 4)
4518 if (size
< (10 + 2))
4525 size
-= flags
[sindex
].len
;
4526 p
= stpcpy (p
, flags
[sindex
].str
);
4528 else if (flag
& SHF_MASKOS
)
4530 else if (flag
& SHF_MASKPROC
)
4533 unknown_flags
|= flag
;
4539 case SHF_WRITE
: *p
= 'W'; break;
4540 case SHF_ALLOC
: *p
= 'A'; break;
4541 case SHF_EXECINSTR
: *p
= 'X'; break;
4542 case SHF_MERGE
: *p
= 'M'; break;
4543 case SHF_STRINGS
: *p
= 'S'; break;
4544 case SHF_INFO_LINK
: *p
= 'I'; break;
4545 case SHF_LINK_ORDER
: *p
= 'L'; break;
4546 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4547 case SHF_GROUP
: *p
= 'G'; break;
4548 case SHF_TLS
: *p
= 'T'; break;
4549 case SHF_EXCLUDE
: *p
= 'E'; break;
4552 if ((elf_header
.e_machine
== EM_X86_64
4553 || elf_header
.e_machine
== EM_L1OM
4554 || elf_header
.e_machine
== EM_K1OM
)
4555 && flag
== SHF_X86_64_LARGE
)
4557 else if (flag
& SHF_MASKOS
)
4560 sh_flags
&= ~ SHF_MASKOS
;
4562 else if (flag
& SHF_MASKPROC
)
4565 sh_flags
&= ~ SHF_MASKPROC
;
4575 if (do_section_details
)
4579 size
-= 5 + field_size
;
4580 if (p
!= buff
+ field_size
+ 4)
4588 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4589 (unsigned long) os_flags
);
4590 p
+= 5 + field_size
;
4594 size
-= 7 + field_size
;
4595 if (p
!= buff
+ field_size
+ 4)
4603 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4604 (unsigned long) proc_flags
);
4605 p
+= 7 + field_size
;
4609 size
-= 10 + field_size
;
4610 if (p
!= buff
+ field_size
+ 4)
4618 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4619 (unsigned long) unknown_flags
);
4620 p
+= 10 + field_size
;
4629 process_section_headers (FILE * file
)
4631 Elf_Internal_Shdr
* section
;
4634 section_headers
= NULL
;
4636 if (elf_header
.e_shnum
== 0)
4638 /* PR binutils/12467. */
4639 if (elf_header
.e_shoff
!= 0)
4640 warn (_("possibly corrupt ELF file header - it has a non-zero"
4641 " section header offset, but no section headers\n"));
4642 else if (do_sections
)
4643 printf (_("\nThere are no sections in this file.\n"));
4648 if (do_sections
&& !do_header
)
4649 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4650 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4654 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4657 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4660 /* Read in the string table, so that we have names to display. */
4661 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4662 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4664 section
= section_headers
+ elf_header
.e_shstrndx
;
4666 if (section
->sh_size
!= 0)
4668 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4669 1, section
->sh_size
,
4672 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4676 /* Scan the sections for the dynamic symbol table
4677 and dynamic string table and debug sections. */
4678 dynamic_symbols
= NULL
;
4679 dynamic_strings
= NULL
;
4680 dynamic_syminfo
= NULL
;
4681 symtab_shndx_hdr
= NULL
;
4683 eh_addr_size
= is_32bit_elf
? 4 : 8;
4684 switch (elf_header
.e_machine
)
4687 case EM_MIPS_RS3_LE
:
4688 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4689 FDE addresses. However, the ABI also has a semi-official ILP32
4690 variant for which the normal FDE address size rules apply.
4692 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4693 section, where XX is the size of longs in bits. Unfortunately,
4694 earlier compilers provided no way of distinguishing ILP32 objects
4695 from LP64 objects, so if there's any doubt, we should assume that
4696 the official LP64 form is being used. */
4697 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4698 && find_section (".gcc_compiled_long32") == NULL
)
4704 switch (elf_header
.e_flags
& EF_H8_MACH
)
4706 case E_H8_MACH_H8300
:
4707 case E_H8_MACH_H8300HN
:
4708 case E_H8_MACH_H8300SN
:
4709 case E_H8_MACH_H8300SXN
:
4712 case E_H8_MACH_H8300H
:
4713 case E_H8_MACH_H8300S
:
4714 case E_H8_MACH_H8300SX
:
4722 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4724 case EF_M32C_CPU_M16C
:
4731 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4734 size_t expected_entsize \
4735 = is_32bit_elf ? size32 : size64; \
4736 if (section->sh_entsize != expected_entsize) \
4737 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4738 i, (unsigned long int) section->sh_entsize, \
4739 (unsigned long int) expected_entsize); \
4740 section->sh_entsize = expected_entsize; \
4743 #define CHECK_ENTSIZE(section, i, type) \
4744 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4745 sizeof (Elf64_External_##type))
4747 for (i
= 0, section
= section_headers
;
4748 i
< elf_header
.e_shnum
;
4751 char * name
= SECTION_NAME (section
);
4753 if (section
->sh_type
== SHT_DYNSYM
)
4755 if (dynamic_symbols
!= NULL
)
4757 error (_("File contains multiple dynamic symbol tables\n"));
4761 CHECK_ENTSIZE (section
, i
, Sym
);
4762 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4764 else if (section
->sh_type
== SHT_STRTAB
4765 && streq (name
, ".dynstr"))
4767 if (dynamic_strings
!= NULL
)
4769 error (_("File contains multiple dynamic string tables\n"));
4773 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4774 1, section
->sh_size
,
4775 _("dynamic strings"));
4776 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4778 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4780 if (symtab_shndx_hdr
!= NULL
)
4782 error (_("File contains multiple symtab shndx tables\n"));
4785 symtab_shndx_hdr
= section
;
4787 else if (section
->sh_type
== SHT_SYMTAB
)
4788 CHECK_ENTSIZE (section
, i
, Sym
);
4789 else if (section
->sh_type
== SHT_GROUP
)
4790 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4791 else if (section
->sh_type
== SHT_REL
)
4792 CHECK_ENTSIZE (section
, i
, Rel
);
4793 else if (section
->sh_type
== SHT_RELA
)
4794 CHECK_ENTSIZE (section
, i
, Rela
);
4795 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4796 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4797 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4798 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4799 || do_debug_addr
|| do_debug_cu_index
)
4800 && (const_strneq (name
, ".debug_")
4801 || const_strneq (name
, ".zdebug_")))
4804 name
+= sizeof (".zdebug_") - 1;
4806 name
+= sizeof (".debug_") - 1;
4809 || (do_debug_info
&& const_strneq (name
, "info"))
4810 || (do_debug_info
&& const_strneq (name
, "types"))
4811 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4812 || (do_debug_lines
&& const_strneq (name
, "line"))
4813 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4814 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4815 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4816 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4817 || (do_debug_frames
&& const_strneq (name
, "frame"))
4818 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4819 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4820 || (do_debug_str
&& const_strneq (name
, "str"))
4821 || (do_debug_loc
&& const_strneq (name
, "loc"))
4822 || (do_debug_addr
&& const_strneq (name
, "addr"))
4823 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4824 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4826 request_dump_bynumber (i
, DEBUG_DUMP
);
4828 /* Linkonce section to be combined with .debug_info at link time. */
4829 else if ((do_debugging
|| do_debug_info
)
4830 && const_strneq (name
, ".gnu.linkonce.wi."))
4831 request_dump_bynumber (i
, DEBUG_DUMP
);
4832 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4833 request_dump_bynumber (i
, DEBUG_DUMP
);
4834 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4835 request_dump_bynumber (i
, DEBUG_DUMP
);
4836 /* Trace sections for Itanium VMS. */
4837 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4838 || do_trace_aranges
)
4839 && const_strneq (name
, ".trace_"))
4841 name
+= sizeof (".trace_") - 1;
4844 || (do_trace_info
&& streq (name
, "info"))
4845 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4846 || (do_trace_aranges
&& streq (name
, "aranges"))
4848 request_dump_bynumber (i
, DEBUG_DUMP
);
4856 if (elf_header
.e_shnum
> 1)
4857 printf (_("\nSection Headers:\n"));
4859 printf (_("\nSection Header:\n"));
4863 if (do_section_details
)
4865 printf (_(" [Nr] Name\n"));
4866 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4870 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4874 if (do_section_details
)
4876 printf (_(" [Nr] Name\n"));
4877 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4881 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4885 if (do_section_details
)
4887 printf (_(" [Nr] Name\n"));
4888 printf (_(" Type Address Offset Link\n"));
4889 printf (_(" Size EntSize Info Align\n"));
4893 printf (_(" [Nr] Name Type Address Offset\n"));
4894 printf (_(" Size EntSize Flags Link Info Align\n"));
4898 if (do_section_details
)
4899 printf (_(" Flags\n"));
4901 for (i
= 0, section
= section_headers
;
4902 i
< elf_header
.e_shnum
;
4905 printf (" [%2u] ", i
);
4906 if (do_section_details
)
4908 print_symbol (INT_MAX
, SECTION_NAME (section
));
4913 print_symbol (-17, SECTION_NAME (section
));
4916 printf (do_wide
? " %-15s " : " %-15.15s ",
4917 get_section_type_name (section
->sh_type
));
4921 const char * link_too_big
= NULL
;
4923 print_vma (section
->sh_addr
, LONG_HEX
);
4925 printf ( " %6.6lx %6.6lx %2.2lx",
4926 (unsigned long) section
->sh_offset
,
4927 (unsigned long) section
->sh_size
,
4928 (unsigned long) section
->sh_entsize
);
4930 if (do_section_details
)
4931 fputs (" ", stdout
);
4933 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4935 if (section
->sh_link
>= elf_header
.e_shnum
)
4938 /* The sh_link value is out of range. Normally this indicates
4939 an error but it can have special values in Solaris binaries. */
4940 switch (elf_header
.e_machine
)
4947 case EM_OLD_SPARCV9
:
4948 case EM_SPARC32PLUS
:
4951 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4952 link_too_big
= "BEFORE";
4953 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4954 link_too_big
= "AFTER";
4961 if (do_section_details
)
4963 if (link_too_big
!= NULL
&& * link_too_big
)
4964 printf ("<%s> ", link_too_big
);
4966 printf ("%2u ", section
->sh_link
);
4967 printf ("%3u %2lu\n", section
->sh_info
,
4968 (unsigned long) section
->sh_addralign
);
4971 printf ("%2u %3u %2lu\n",
4974 (unsigned long) section
->sh_addralign
);
4976 if (link_too_big
&& ! * link_too_big
)
4977 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4978 i
, section
->sh_link
);
4982 print_vma (section
->sh_addr
, LONG_HEX
);
4984 if ((long) section
->sh_offset
== section
->sh_offset
)
4985 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4989 print_vma (section
->sh_offset
, LONG_HEX
);
4992 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4993 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4997 print_vma (section
->sh_size
, LONG_HEX
);
5000 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5001 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5005 print_vma (section
->sh_entsize
, LONG_HEX
);
5008 if (do_section_details
)
5009 fputs (" ", stdout
);
5011 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5013 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5015 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5016 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5019 print_vma (section
->sh_addralign
, DEC
);
5023 else if (do_section_details
)
5025 printf (" %-15.15s ",
5026 get_section_type_name (section
->sh_type
));
5027 print_vma (section
->sh_addr
, LONG_HEX
);
5028 if ((long) section
->sh_offset
== section
->sh_offset
)
5029 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5033 print_vma (section
->sh_offset
, LONG_HEX
);
5035 printf (" %u\n ", section
->sh_link
);
5036 print_vma (section
->sh_size
, LONG_HEX
);
5038 print_vma (section
->sh_entsize
, LONG_HEX
);
5040 printf (" %-16u %lu\n",
5042 (unsigned long) section
->sh_addralign
);
5047 print_vma (section
->sh_addr
, LONG_HEX
);
5048 if ((long) section
->sh_offset
== section
->sh_offset
)
5049 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5053 print_vma (section
->sh_offset
, LONG_HEX
);
5056 print_vma (section
->sh_size
, LONG_HEX
);
5058 print_vma (section
->sh_entsize
, LONG_HEX
);
5060 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5062 printf (" %2u %3u %lu\n",
5065 (unsigned long) section
->sh_addralign
);
5068 if (do_section_details
)
5069 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5072 if (!do_section_details
)
5074 if (elf_header
.e_machine
== EM_X86_64
5075 || elf_header
.e_machine
== EM_L1OM
5076 || elf_header
.e_machine
== EM_K1OM
)
5077 printf (_("Key to Flags:\n\
5078 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5079 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5080 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5082 printf (_("Key to Flags:\n\
5083 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5084 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5085 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5092 get_group_flags (unsigned int flags
)
5094 static char buff
[32];
5104 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5111 process_section_groups (FILE * file
)
5113 Elf_Internal_Shdr
* section
;
5115 struct group
* group
;
5116 Elf_Internal_Shdr
* symtab_sec
;
5117 Elf_Internal_Shdr
* strtab_sec
;
5118 Elf_Internal_Sym
* symtab
;
5119 unsigned long num_syms
;
5123 /* Don't process section groups unless needed. */
5124 if (!do_unwind
&& !do_section_groups
)
5127 if (elf_header
.e_shnum
== 0)
5129 if (do_section_groups
)
5130 printf (_("\nThere are no sections to group in this file.\n"));
5135 if (section_headers
== NULL
)
5137 error (_("Section headers are not available!\n"));
5138 /* PR 13622: This can happen with a corrupt ELF header. */
5142 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5143 sizeof (struct group
*));
5145 if (section_headers_groups
== NULL
)
5147 error (_("Out of memory\n"));
5151 /* Scan the sections for the group section. */
5153 for (i
= 0, section
= section_headers
;
5154 i
< elf_header
.e_shnum
;
5156 if (section
->sh_type
== SHT_GROUP
)
5159 if (group_count
== 0)
5161 if (do_section_groups
)
5162 printf (_("\nThere are no section groups in this file.\n"));
5167 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5169 if (section_groups
== NULL
)
5171 error (_("Out of memory\n"));
5181 for (i
= 0, section
= section_headers
, group
= section_groups
;
5182 i
< elf_header
.e_shnum
;
5185 if (section
->sh_type
== SHT_GROUP
)
5187 char * name
= SECTION_NAME (section
);
5189 unsigned char * start
;
5190 unsigned char * indices
;
5191 unsigned int entry
, j
, size
;
5192 Elf_Internal_Shdr
* sec
;
5193 Elf_Internal_Sym
* sym
;
5195 /* Get the symbol table. */
5196 if (section
->sh_link
>= elf_header
.e_shnum
5197 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5200 error (_("Bad sh_link in group section `%s'\n"), name
);
5204 if (symtab_sec
!= sec
)
5209 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5214 error (_("Corrupt header in group section `%s'\n"), name
);
5218 if (section
->sh_info
>= num_syms
)
5220 error (_("Bad sh_info in group section `%s'\n"), name
);
5224 sym
= symtab
+ section
->sh_info
;
5226 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5228 if (sym
->st_shndx
== 0
5229 || sym
->st_shndx
>= elf_header
.e_shnum
)
5231 error (_("Bad sh_info in group section `%s'\n"), name
);
5235 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5244 /* Get the string table. */
5245 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5254 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5259 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5260 1, strtab_sec
->sh_size
,
5262 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5264 group_name
= sym
->st_name
< strtab_size
5265 ? strtab
+ sym
->st_name
: _("<corrupt>");
5268 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5269 1, section
->sh_size
,
5275 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5276 entry
= byte_get (indices
, 4);
5279 if (do_section_groups
)
5281 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5282 get_group_flags (entry
), i
, name
, group_name
, size
);
5284 printf (_(" [Index] Name\n"));
5287 group
->group_index
= i
;
5289 for (j
= 0; j
< size
; j
++)
5291 struct group_list
* g
;
5293 entry
= byte_get (indices
, 4);
5296 if (entry
>= elf_header
.e_shnum
)
5298 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5299 entry
, i
, elf_header
.e_shnum
- 1);
5303 if (section_headers_groups
[entry
] != NULL
)
5307 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5309 section_headers_groups
[entry
]->group_index
);
5314 /* Intel C/C++ compiler may put section 0 in a
5315 section group. We just warn it the first time
5316 and ignore it afterwards. */
5317 static int warned
= 0;
5320 error (_("section 0 in group section [%5u]\n"),
5321 section_headers_groups
[entry
]->group_index
);
5327 section_headers_groups
[entry
] = group
;
5329 if (do_section_groups
)
5331 sec
= section_headers
+ entry
;
5332 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5335 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5336 g
->section_index
= entry
;
5337 g
->next
= group
->root
;
5355 /* Data used to display dynamic fixups. */
5357 struct ia64_vms_dynfixup
5359 bfd_vma needed_ident
; /* Library ident number. */
5360 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5361 bfd_vma fixup_needed
; /* Index of the library. */
5362 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5363 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5366 /* Data used to display dynamic relocations. */
5368 struct ia64_vms_dynimgrela
5370 bfd_vma img_rela_cnt
; /* Number of relocations. */
5371 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5374 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5378 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5379 const char *strtab
, unsigned int strtab_sz
)
5381 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5383 const char *lib_name
;
5385 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5386 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5387 _("dynamic section image fixups"));
5391 if (fixup
->needed
< strtab_sz
)
5392 lib_name
= strtab
+ fixup
->needed
;
5395 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5396 (unsigned long) fixup
->needed
);
5399 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5400 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5402 (_("Seg Offset Type SymVec DataType\n"));
5404 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5409 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5410 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5411 type
= BYTE_GET (imfs
[i
].type
);
5412 rtype
= elf_ia64_reloc_type (type
);
5414 printf (" 0x%08x ", type
);
5416 printf (" %-32s ", rtype
);
5417 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5418 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5424 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5427 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5429 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5432 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5433 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5434 _("dynamic section image relocations"));
5438 printf (_("\nImage relocs\n"));
5440 (_("Seg Offset Type Addend Seg Sym Off\n"));
5442 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5447 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5448 printf ("%08" BFD_VMA_FMT
"x ",
5449 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5450 type
= BYTE_GET (imrs
[i
].type
);
5451 rtype
= elf_ia64_reloc_type (type
);
5453 printf ("0x%08x ", type
);
5455 printf ("%-31s ", rtype
);
5456 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5457 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5458 printf ("%08" BFD_VMA_FMT
"x\n",
5459 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5465 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5468 process_ia64_vms_dynamic_relocs (FILE *file
)
5470 struct ia64_vms_dynfixup fixup
;
5471 struct ia64_vms_dynimgrela imgrela
;
5472 Elf_Internal_Dyn
*entry
;
5474 bfd_vma strtab_off
= 0;
5475 bfd_vma strtab_sz
= 0;
5476 char *strtab
= NULL
;
5478 memset (&fixup
, 0, sizeof (fixup
));
5479 memset (&imgrela
, 0, sizeof (imgrela
));
5481 /* Note: the order of the entries is specified by the OpenVMS specs. */
5482 for (entry
= dynamic_section
;
5483 entry
< dynamic_section
+ dynamic_nent
;
5486 switch (entry
->d_tag
)
5488 case DT_IA_64_VMS_STRTAB_OFFSET
:
5489 strtab_off
= entry
->d_un
.d_val
;
5492 strtab_sz
= entry
->d_un
.d_val
;
5494 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5495 1, strtab_sz
, _("dynamic string section"));
5498 case DT_IA_64_VMS_NEEDED_IDENT
:
5499 fixup
.needed_ident
= entry
->d_un
.d_val
;
5502 fixup
.needed
= entry
->d_un
.d_val
;
5504 case DT_IA_64_VMS_FIXUP_NEEDED
:
5505 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5507 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5508 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5510 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5511 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5513 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5516 case DT_IA_64_VMS_IMG_RELA_CNT
:
5517 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5519 case DT_IA_64_VMS_IMG_RELA_OFF
:
5520 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5522 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5542 } dynamic_relocations
[] =
5544 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5545 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5546 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5549 /* Process the reloc section. */
5552 process_relocs (FILE * file
)
5554 unsigned long rel_size
;
5555 unsigned long rel_offset
;
5561 if (do_using_dynamic
)
5565 int has_dynamic_reloc
;
5568 has_dynamic_reloc
= 0;
5570 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5572 is_rela
= dynamic_relocations
[i
].rela
;
5573 name
= dynamic_relocations
[i
].name
;
5574 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5575 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5577 has_dynamic_reloc
|= rel_size
;
5579 if (is_rela
== UNKNOWN
)
5581 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5582 switch (dynamic_info
[DT_PLTREL
])
5596 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5597 name
, rel_offset
, rel_size
);
5599 dump_relocations (file
,
5600 offset_from_vma (file
, rel_offset
, rel_size
),
5602 dynamic_symbols
, num_dynamic_syms
,
5603 dynamic_strings
, dynamic_strings_length
, is_rela
);
5608 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5610 if (! has_dynamic_reloc
)
5611 printf (_("\nThere are no dynamic relocations in this file.\n"));
5615 Elf_Internal_Shdr
* section
;
5619 for (i
= 0, section
= section_headers
;
5620 i
< elf_header
.e_shnum
;
5623 if ( section
->sh_type
!= SHT_RELA
5624 && section
->sh_type
!= SHT_REL
)
5627 rel_offset
= section
->sh_offset
;
5628 rel_size
= section
->sh_size
;
5632 Elf_Internal_Shdr
* strsec
;
5635 printf (_("\nRelocation section "));
5637 if (string_table
== NULL
)
5638 printf ("%d", section
->sh_name
);
5640 printf ("'%s'", SECTION_NAME (section
));
5642 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5643 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5645 is_rela
= section
->sh_type
== SHT_RELA
;
5647 if (section
->sh_link
!= 0
5648 && section
->sh_link
< elf_header
.e_shnum
)
5650 Elf_Internal_Shdr
* symsec
;
5651 Elf_Internal_Sym
* symtab
;
5652 unsigned long nsyms
;
5653 unsigned long strtablen
= 0;
5654 char * strtab
= NULL
;
5656 symsec
= section_headers
+ section
->sh_link
;
5657 if (symsec
->sh_type
!= SHT_SYMTAB
5658 && symsec
->sh_type
!= SHT_DYNSYM
)
5661 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5666 if (symsec
->sh_link
!= 0
5667 && symsec
->sh_link
< elf_header
.e_shnum
)
5669 strsec
= section_headers
+ symsec
->sh_link
;
5671 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5674 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5677 dump_relocations (file
, rel_offset
, rel_size
,
5678 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5684 dump_relocations (file
, rel_offset
, rel_size
,
5685 NULL
, 0, NULL
, 0, is_rela
);
5692 printf (_("\nThere are no relocations in this file.\n"));
5698 /* Process the unwind section. */
5700 #include "unwind-ia64.h"
5702 /* An absolute address consists of a section and an offset. If the
5703 section is NULL, the offset itself is the address, otherwise, the
5704 address equals to LOAD_ADDRESS(section) + offset. */
5708 unsigned short section
;
5712 #define ABSADDR(a) \
5714 ? section_headers [(a).section].sh_addr + (a).offset \
5717 struct ia64_unw_table_entry
5719 struct absaddr start
;
5721 struct absaddr info
;
5724 struct ia64_unw_aux_info
5727 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5728 unsigned long table_len
; /* Length of unwind table. */
5729 unsigned char * info
; /* Unwind info. */
5730 unsigned long info_size
; /* Size of unwind info. */
5731 bfd_vma info_addr
; /* starting address of unwind info. */
5732 bfd_vma seg_base
; /* Starting address of segment. */
5733 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5734 unsigned long nsyms
; /* Number of symbols. */
5735 char * strtab
; /* The string table. */
5736 unsigned long strtab_size
; /* Size of string table. */
5740 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5741 unsigned long nsyms
,
5742 const char * strtab
,
5743 unsigned long strtab_size
,
5744 struct absaddr addr
,
5745 const char ** symname
,
5748 bfd_vma dist
= 0x100000;
5749 Elf_Internal_Sym
* sym
;
5750 Elf_Internal_Sym
* best
= NULL
;
5753 REMOVE_ARCH_BITS (addr
.offset
);
5755 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5757 bfd_vma value
= sym
->st_value
;
5759 REMOVE_ARCH_BITS (value
);
5761 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5762 && sym
->st_name
!= 0
5763 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5764 && addr
.offset
>= value
5765 && addr
.offset
- value
< dist
)
5768 dist
= addr
.offset
- value
;
5776 *symname
= (best
->st_name
>= strtab_size
5777 ? _("<corrupt>") : strtab
+ best
->st_name
);
5783 *offset
= addr
.offset
;
5787 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5789 struct ia64_unw_table_entry
* tp
;
5792 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5796 const unsigned char * dp
;
5797 const unsigned char * head
;
5798 const char * procname
;
5800 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5801 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5803 fputs ("\n<", stdout
);
5807 fputs (procname
, stdout
);
5810 printf ("+%lx", (unsigned long) offset
);
5813 fputs (">: [", stdout
);
5814 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5815 fputc ('-', stdout
);
5816 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5817 printf ("], info at +0x%lx\n",
5818 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5820 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5821 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5823 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5824 (unsigned) UNW_VER (stamp
),
5825 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5826 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5827 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5828 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5830 if (UNW_VER (stamp
) != 1)
5832 printf (_("\tUnknown version.\n"));
5837 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5838 dp
= unw_decode (dp
, in_body
, & in_body
);
5843 slurp_ia64_unwind_table (FILE * file
,
5844 struct ia64_unw_aux_info
* aux
,
5845 Elf_Internal_Shdr
* sec
)
5847 unsigned long size
, nrelas
, i
;
5848 Elf_Internal_Phdr
* seg
;
5849 struct ia64_unw_table_entry
* tep
;
5850 Elf_Internal_Shdr
* relsec
;
5851 Elf_Internal_Rela
* rela
;
5852 Elf_Internal_Rela
* rp
;
5853 unsigned char * table
;
5855 Elf_Internal_Sym
* sym
;
5856 const char * relname
;
5858 /* First, find the starting address of the segment that includes
5861 if (elf_header
.e_phnum
)
5863 if (! get_program_headers (file
))
5866 for (seg
= program_headers
;
5867 seg
< program_headers
+ elf_header
.e_phnum
;
5870 if (seg
->p_type
!= PT_LOAD
)
5873 if (sec
->sh_addr
>= seg
->p_vaddr
5874 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5876 aux
->seg_base
= seg
->p_vaddr
;
5882 /* Second, build the unwind table from the contents of the unwind section: */
5883 size
= sec
->sh_size
;
5884 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5889 aux
->table
= (struct ia64_unw_table_entry
*)
5890 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5892 for (tp
= table
; tp
< table
+ size
; ++tep
)
5894 tep
->start
.section
= SHN_UNDEF
;
5895 tep
->end
.section
= SHN_UNDEF
;
5896 tep
->info
.section
= SHN_UNDEF
;
5897 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5898 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5899 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5900 tep
->start
.offset
+= aux
->seg_base
;
5901 tep
->end
.offset
+= aux
->seg_base
;
5902 tep
->info
.offset
+= aux
->seg_base
;
5906 /* Third, apply any relocations to the unwind table: */
5907 for (relsec
= section_headers
;
5908 relsec
< section_headers
+ elf_header
.e_shnum
;
5911 if (relsec
->sh_type
!= SHT_RELA
5912 || relsec
->sh_info
>= elf_header
.e_shnum
5913 || section_headers
+ relsec
->sh_info
!= sec
)
5916 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5920 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5922 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5923 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5925 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5927 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5931 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5933 switch (rp
->r_offset
/eh_addr_size
% 3)
5936 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5937 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5940 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5941 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5944 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5945 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5955 aux
->table_len
= size
/ (3 * eh_addr_size
);
5960 ia64_process_unwind (FILE * file
)
5962 Elf_Internal_Shdr
* sec
;
5963 Elf_Internal_Shdr
* unwsec
= NULL
;
5964 Elf_Internal_Shdr
* strsec
;
5965 unsigned long i
, unwcount
= 0, unwstart
= 0;
5966 struct ia64_unw_aux_info aux
;
5968 memset (& aux
, 0, sizeof (aux
));
5970 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5972 if (sec
->sh_type
== SHT_SYMTAB
5973 && sec
->sh_link
< elf_header
.e_shnum
)
5975 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
5977 strsec
= section_headers
+ sec
->sh_link
;
5978 assert (aux
.strtab
== NULL
);
5979 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5982 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5984 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5989 printf (_("\nThere are no unwind sections in this file.\n"));
5991 while (unwcount
-- > 0)
5996 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5997 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5998 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6005 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6007 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6009 /* We need to find which section group it is in. */
6010 struct group_list
* g
= section_headers_groups
[i
]->root
;
6012 for (; g
!= NULL
; g
= g
->next
)
6014 sec
= section_headers
+ g
->section_index
;
6016 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6021 i
= elf_header
.e_shnum
;
6023 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6025 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6026 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6027 suffix
= SECTION_NAME (unwsec
) + len
;
6028 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6030 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6031 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6036 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6037 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6038 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6039 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6041 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6042 suffix
= SECTION_NAME (unwsec
) + len
;
6043 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6045 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6046 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6050 if (i
== elf_header
.e_shnum
)
6052 printf (_("\nCould not find unwind info section for "));
6054 if (string_table
== NULL
)
6055 printf ("%d", unwsec
->sh_name
);
6057 printf (_("'%s'"), SECTION_NAME (unwsec
));
6061 aux
.info_addr
= sec
->sh_addr
;
6062 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6065 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6067 printf (_("\nUnwind section "));
6069 if (string_table
== NULL
)
6070 printf ("%d", unwsec
->sh_name
);
6072 printf (_("'%s'"), SECTION_NAME (unwsec
));
6074 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6075 (unsigned long) unwsec
->sh_offset
,
6076 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6078 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6080 if (aux
.table_len
> 0)
6081 dump_ia64_unwind (& aux
);
6084 free ((char *) aux
.table
);
6086 free ((char *) aux
.info
);
6095 free ((char *) aux
.strtab
);
6098 struct hppa_unw_table_entry
6100 struct absaddr start
;
6102 unsigned int Cannot_unwind
:1; /* 0 */
6103 unsigned int Millicode
:1; /* 1 */
6104 unsigned int Millicode_save_sr0
:1; /* 2 */
6105 unsigned int Region_description
:2; /* 3..4 */
6106 unsigned int reserved1
:1; /* 5 */
6107 unsigned int Entry_SR
:1; /* 6 */
6108 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6109 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6110 unsigned int Args_stored
:1; /* 16 */
6111 unsigned int Variable_Frame
:1; /* 17 */
6112 unsigned int Separate_Package_Body
:1; /* 18 */
6113 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6114 unsigned int Stack_Overflow_Check
:1; /* 20 */
6115 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6116 unsigned int Ada_Region
:1; /* 22 */
6117 unsigned int cxx_info
:1; /* 23 */
6118 unsigned int cxx_try_catch
:1; /* 24 */
6119 unsigned int sched_entry_seq
:1; /* 25 */
6120 unsigned int reserved2
:1; /* 26 */
6121 unsigned int Save_SP
:1; /* 27 */
6122 unsigned int Save_RP
:1; /* 28 */
6123 unsigned int Save_MRP_in_frame
:1; /* 29 */
6124 unsigned int extn_ptr_defined
:1; /* 30 */
6125 unsigned int Cleanup_defined
:1; /* 31 */
6127 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6128 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6129 unsigned int Large_frame
:1; /* 2 */
6130 unsigned int Pseudo_SP_Set
:1; /* 3 */
6131 unsigned int reserved4
:1; /* 4 */
6132 unsigned int Total_frame_size
:27; /* 5..31 */
6135 struct hppa_unw_aux_info
6137 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6138 unsigned long table_len
; /* Length of unwind table. */
6139 bfd_vma seg_base
; /* Starting address of segment. */
6140 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6141 unsigned long nsyms
; /* Number of symbols. */
6142 char * strtab
; /* The string table. */
6143 unsigned long strtab_size
; /* Size of string table. */
6147 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6149 struct hppa_unw_table_entry
* tp
;
6151 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6154 const char * procname
;
6156 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6157 aux
->strtab_size
, tp
->start
, &procname
,
6160 fputs ("\n<", stdout
);
6164 fputs (procname
, stdout
);
6167 printf ("+%lx", (unsigned long) offset
);
6170 fputs (">: [", stdout
);
6171 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6172 fputc ('-', stdout
);
6173 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6176 #define PF(_m) if (tp->_m) printf (#_m " ");
6177 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6180 PF(Millicode_save_sr0
);
6181 /* PV(Region_description); */
6187 PF(Separate_Package_Body
);
6188 PF(Frame_Extension_Millicode
);
6189 PF(Stack_Overflow_Check
);
6190 PF(Two_Instruction_SP_Increment
);
6194 PF(sched_entry_seq
);
6197 PF(Save_MRP_in_frame
);
6198 PF(extn_ptr_defined
);
6199 PF(Cleanup_defined
);
6200 PF(MPE_XL_interrupt_marker
);
6201 PF(HP_UX_interrupt_marker
);
6204 PV(Total_frame_size
);
6213 slurp_hppa_unwind_table (FILE * file
,
6214 struct hppa_unw_aux_info
* aux
,
6215 Elf_Internal_Shdr
* sec
)
6217 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6218 Elf_Internal_Phdr
* seg
;
6219 struct hppa_unw_table_entry
* tep
;
6220 Elf_Internal_Shdr
* relsec
;
6221 Elf_Internal_Rela
* rela
;
6222 Elf_Internal_Rela
* rp
;
6223 unsigned char * table
;
6225 Elf_Internal_Sym
* sym
;
6226 const char * relname
;
6228 /* First, find the starting address of the segment that includes
6231 if (elf_header
.e_phnum
)
6233 if (! get_program_headers (file
))
6236 for (seg
= program_headers
;
6237 seg
< program_headers
+ elf_header
.e_phnum
;
6240 if (seg
->p_type
!= PT_LOAD
)
6243 if (sec
->sh_addr
>= seg
->p_vaddr
6244 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6246 aux
->seg_base
= seg
->p_vaddr
;
6252 /* Second, build the unwind table from the contents of the unwind
6254 size
= sec
->sh_size
;
6255 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6261 nentries
= size
/ unw_ent_size
;
6262 size
= unw_ent_size
* nentries
;
6264 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6265 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6267 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6269 unsigned int tmp1
, tmp2
;
6271 tep
->start
.section
= SHN_UNDEF
;
6272 tep
->end
.section
= SHN_UNDEF
;
6274 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6275 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6276 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6277 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6279 tep
->start
.offset
+= aux
->seg_base
;
6280 tep
->end
.offset
+= aux
->seg_base
;
6282 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6283 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6284 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6285 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6286 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6287 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6288 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6289 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6290 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6291 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6292 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6293 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6294 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6295 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6296 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6297 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6298 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6299 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6300 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6301 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6302 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6303 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6304 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6305 tep
->Cleanup_defined
= tmp1
& 0x1;
6307 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6308 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6309 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6310 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6311 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6312 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6316 /* Third, apply any relocations to the unwind table. */
6317 for (relsec
= section_headers
;
6318 relsec
< section_headers
+ elf_header
.e_shnum
;
6321 if (relsec
->sh_type
!= SHT_RELA
6322 || relsec
->sh_info
>= elf_header
.e_shnum
6323 || section_headers
+ relsec
->sh_info
!= sec
)
6326 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6330 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6332 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6333 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6335 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6336 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6338 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6342 i
= rp
->r_offset
/ unw_ent_size
;
6344 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6347 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6348 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6351 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6352 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6362 aux
->table_len
= nentries
;
6368 hppa_process_unwind (FILE * file
)
6370 struct hppa_unw_aux_info aux
;
6371 Elf_Internal_Shdr
* unwsec
= NULL
;
6372 Elf_Internal_Shdr
* strsec
;
6373 Elf_Internal_Shdr
* sec
;
6376 if (string_table
== NULL
)
6379 memset (& aux
, 0, sizeof (aux
));
6381 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6383 if (sec
->sh_type
== SHT_SYMTAB
6384 && sec
->sh_link
< elf_header
.e_shnum
)
6386 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6388 strsec
= section_headers
+ sec
->sh_link
;
6389 assert (aux
.strtab
== NULL
);
6390 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6393 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6395 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6400 printf (_("\nThere are no unwind sections in this file.\n"));
6402 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6404 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6406 printf (_("\nUnwind section "));
6407 printf (_("'%s'"), SECTION_NAME (sec
));
6409 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6410 (unsigned long) sec
->sh_offset
,
6411 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6413 slurp_hppa_unwind_table (file
, &aux
, sec
);
6414 if (aux
.table_len
> 0)
6415 dump_hppa_unwind (&aux
);
6418 free ((char *) aux
.table
);
6426 free ((char *) aux
.strtab
);
6431 unsigned char * data
; /* The unwind data. */
6432 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6433 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6434 unsigned long nrelas
; /* The number of relocations. */
6435 unsigned int rel_type
; /* REL or RELA ? */
6436 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6439 struct arm_unw_aux_info
6441 FILE * file
; /* The file containing the unwind sections. */
6442 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6443 unsigned long nsyms
; /* Number of symbols. */
6444 char * strtab
; /* The file's string table. */
6445 unsigned long strtab_size
; /* Size of string table. */
6449 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6450 bfd_vma fn
, struct absaddr addr
)
6452 const char *procname
;
6455 if (addr
.section
== SHN_UNDEF
)
6458 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6459 aux
->strtab_size
, addr
, &procname
,
6462 print_vma (fn
, PREFIX_HEX
);
6466 fputs (" <", stdout
);
6467 fputs (procname
, stdout
);
6470 printf ("+0x%lx", (unsigned long) sym_offset
);
6471 fputc ('>', stdout
);
6478 arm_free_section (struct arm_section
*arm_sec
)
6480 if (arm_sec
->data
!= NULL
)
6481 free (arm_sec
->data
);
6483 if (arm_sec
->rela
!= NULL
)
6484 free (arm_sec
->rela
);
6487 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6488 cached section and install SEC instead.
6489 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6490 and return its valued in * WORDP, relocating if necessary.
6491 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6492 relocation's offset in ADDR.
6493 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6494 into the string table of the symbol associated with the reloc. If no
6495 reloc was applied store -1 there.
6496 5) Return TRUE upon success, FALSE otherwise. */
6499 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6500 struct arm_section
* arm_sec
,
6501 Elf_Internal_Shdr
* sec
,
6502 bfd_vma word_offset
,
6503 unsigned int * wordp
,
6504 struct absaddr
* addr
,
6507 Elf_Internal_Rela
*rp
;
6508 Elf_Internal_Sym
*sym
;
6509 const char * relname
;
6511 bfd_boolean wrapped
;
6513 addr
->section
= SHN_UNDEF
;
6516 if (sym_name
!= NULL
)
6517 *sym_name
= (bfd_vma
) -1;
6519 /* If necessary, update the section cache. */
6520 if (sec
!= arm_sec
->sec
)
6522 Elf_Internal_Shdr
*relsec
;
6524 arm_free_section (arm_sec
);
6527 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6528 sec
->sh_size
, _("unwind data"));
6529 arm_sec
->rela
= NULL
;
6530 arm_sec
->nrelas
= 0;
6532 for (relsec
= section_headers
;
6533 relsec
< section_headers
+ elf_header
.e_shnum
;
6536 if (relsec
->sh_info
>= elf_header
.e_shnum
6537 || section_headers
+ relsec
->sh_info
!= sec
)
6540 arm_sec
->rel_type
= relsec
->sh_type
;
6541 if (relsec
->sh_type
== SHT_REL
)
6543 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6545 & arm_sec
->rela
, & arm_sec
->nrelas
))
6549 else if (relsec
->sh_type
== SHT_RELA
)
6551 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6553 & arm_sec
->rela
, & arm_sec
->nrelas
))
6558 warn (_("unexpected relocation type (%d) for section %d"),
6559 relsec
->sh_type
, relsec
->sh_info
);
6562 arm_sec
->next_rela
= arm_sec
->rela
;
6565 /* If there is no unwind data we can do nothing. */
6566 if (arm_sec
->data
== NULL
)
6569 /* Get the word at the required offset. */
6570 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6572 /* Look through the relocs to find the one that applies to the provided offset. */
6574 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6576 bfd_vma prelval
, offset
;
6578 if (rp
->r_offset
> word_offset
&& !wrapped
)
6583 if (rp
->r_offset
> word_offset
)
6586 if (rp
->r_offset
& 3)
6588 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6589 (unsigned long) rp
->r_offset
);
6593 if (rp
->r_offset
< word_offset
)
6596 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6598 if (arm_sec
->rel_type
== SHT_REL
)
6600 offset
= word
& 0x7fffffff;
6601 if (offset
& 0x40000000)
6602 offset
|= ~ (bfd_vma
) 0x7fffffff;
6604 else if (arm_sec
->rel_type
== SHT_RELA
)
6605 offset
= rp
->r_addend
;
6609 offset
+= sym
->st_value
;
6610 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6612 /* Check that we are processing the expected reloc type. */
6613 if (elf_header
.e_machine
== EM_ARM
)
6615 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6617 if (streq (relname
, "R_ARM_NONE"))
6620 if (! streq (relname
, "R_ARM_PREL31"))
6622 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6626 else if (elf_header
.e_machine
== EM_TI_C6000
)
6628 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6630 if (streq (relname
, "R_C6000_NONE"))
6633 if (! streq (relname
, "R_C6000_PREL31"))
6635 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6642 /* This function currently only supports ARM and TI unwinders. */
6645 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6646 addr
->section
= sym
->st_shndx
;
6647 addr
->offset
= offset
;
6649 * sym_name
= sym
->st_name
;
6654 arm_sec
->next_rela
= rp
;
6659 static const char *tic6x_unwind_regnames
[16] =
6661 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6662 "A14", "A13", "A12", "A11", "A10",
6663 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6667 decode_tic6x_unwind_regmask (unsigned int mask
)
6671 for (i
= 12; mask
; mask
>>= 1, i
--)
6675 fputs (tic6x_unwind_regnames
[i
], stdout
);
6677 fputs (", ", stdout
);
6683 if (remaining == 0 && more_words) \
6686 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6687 data_offset, & word, & addr, NULL)) \
6693 #define GET_OP(OP) \
6698 (OP) = word >> 24; \
6703 printf (_("[Truncated opcode]\n")); \
6706 printf ("0x%02x ", OP)
6709 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6710 unsigned int word
, unsigned int remaining
,
6711 unsigned int more_words
,
6712 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6713 struct arm_section
*data_arm_sec
)
6715 struct absaddr addr
;
6717 /* Decode the unwinding instructions. */
6720 unsigned int op
, op2
;
6729 printf (" 0x%02x ", op
);
6731 if ((op
& 0xc0) == 0x00)
6733 int offset
= ((op
& 0x3f) << 2) + 4;
6735 printf (" vsp = vsp + %d", offset
);
6737 else if ((op
& 0xc0) == 0x40)
6739 int offset
= ((op
& 0x3f) << 2) + 4;
6741 printf (" vsp = vsp - %d", offset
);
6743 else if ((op
& 0xf0) == 0x80)
6746 if (op
== 0x80 && op2
== 0)
6747 printf (_("Refuse to unwind"));
6750 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6755 for (i
= 0; i
< 12; i
++)
6756 if (mask
& (1 << i
))
6762 printf ("r%d", 4 + i
);
6767 else if ((op
& 0xf0) == 0x90)
6769 if (op
== 0x9d || op
== 0x9f)
6770 printf (_(" [Reserved]"));
6772 printf (" vsp = r%d", op
& 0x0f);
6774 else if ((op
& 0xf0) == 0xa0)
6776 int end
= 4 + (op
& 0x07);
6781 for (i
= 4; i
<= end
; i
++)
6797 else if (op
== 0xb0)
6798 printf (_(" finish"));
6799 else if (op
== 0xb1)
6802 if (op2
== 0 || (op2
& 0xf0) != 0)
6803 printf (_("[Spare]"));
6806 unsigned int mask
= op2
& 0x0f;
6811 for (i
= 0; i
< 12; i
++)
6812 if (mask
& (1 << i
))
6823 else if (op
== 0xb2)
6825 unsigned char buf
[9];
6826 unsigned int i
, len
;
6827 unsigned long offset
;
6829 for (i
= 0; i
< sizeof (buf
); i
++)
6832 if ((buf
[i
] & 0x80) == 0)
6835 assert (i
< sizeof (buf
));
6836 offset
= read_uleb128 (buf
, &len
);
6837 assert (len
== i
+ 1);
6838 offset
= offset
* 4 + 0x204;
6839 printf ("vsp = vsp + %ld", offset
);
6841 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6843 unsigned int first
, last
;
6850 printf ("pop {D%d", first
);
6852 printf ("-D%d", first
+ last
);
6855 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6857 unsigned int count
= op
& 0x07;
6861 printf ("-D%d", 8 + count
);
6864 else if (op
>= 0xc0 && op
<= 0xc5)
6866 unsigned int count
= op
& 0x07;
6868 printf (" pop {wR10");
6870 printf ("-wR%d", 10 + count
);
6873 else if (op
== 0xc6)
6875 unsigned int first
, last
;
6880 printf ("pop {wR%d", first
);
6882 printf ("-wR%d", first
+ last
);
6885 else if (op
== 0xc7)
6888 if (op2
== 0 || (op2
& 0xf0) != 0)
6889 printf (_("[Spare]"));
6892 unsigned int mask
= op2
& 0x0f;
6897 for (i
= 0; i
< 4; i
++)
6898 if (mask
& (1 << i
))
6904 printf ("wCGR%d", i
);
6910 printf (_(" [unsupported opcode]"));
6916 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6917 unsigned int word
, unsigned int remaining
,
6918 unsigned int more_words
,
6919 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6920 struct arm_section
*data_arm_sec
)
6922 struct absaddr addr
;
6924 /* Decode the unwinding instructions. */
6927 unsigned int op
, op2
;
6936 printf (" 0x%02x ", op
);
6938 if ((op
& 0xc0) == 0x00)
6940 int offset
= ((op
& 0x3f) << 3) + 8;
6941 printf (" sp = sp + %d", offset
);
6943 else if ((op
& 0xc0) == 0x80)
6946 if (op
== 0x80 && op2
== 0)
6947 printf (_("Refuse to unwind"));
6950 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6952 printf ("pop compact {");
6956 decode_tic6x_unwind_regmask (mask
);
6960 else if ((op
& 0xf0) == 0xc0)
6968 unsigned int offset
;
6972 /* Scan entire instruction first so that GET_OP output is not
6973 interleaved with disassembly. */
6975 for (i
= 0; nregs
< (op
& 0xf); i
++)
6981 regpos
[nregs
].offset
= i
* 2;
6982 regpos
[nregs
].reg
= reg
;
6989 regpos
[nregs
].offset
= i
* 2 + 1;
6990 regpos
[nregs
].reg
= reg
;
6995 printf (_("pop frame {"));
6997 for (i
= i
* 2; i
> 0; i
--)
6999 if (regpos
[reg
].offset
== i
- 1)
7001 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7008 fputs (name
, stdout
);
7015 else if (op
== 0xd0)
7016 printf (" MOV FP, SP");
7017 else if (op
== 0xd1)
7018 printf (" __c6xabi_pop_rts");
7019 else if (op
== 0xd2)
7021 unsigned char buf
[9];
7022 unsigned int i
, len
;
7023 unsigned long offset
;
7025 for (i
= 0; i
< sizeof (buf
); i
++)
7028 if ((buf
[i
] & 0x80) == 0)
7031 assert (i
< sizeof (buf
));
7032 offset
= read_uleb128 (buf
, &len
);
7033 assert (len
== i
+ 1);
7034 offset
= offset
* 8 + 0x408;
7035 printf (_("sp = sp + %ld"), offset
);
7037 else if ((op
& 0xf0) == 0xe0)
7039 if ((op
& 0x0f) == 7)
7042 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7046 printf (_(" [unsupported opcode]"));
7053 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7057 offset
= word
& 0x7fffffff;
7058 if (offset
& 0x40000000)
7059 offset
|= ~ (bfd_vma
) 0x7fffffff;
7061 if (elf_header
.e_machine
== EM_TI_C6000
)
7064 return offset
+ where
;
7068 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7070 unsigned int remaining
,
7071 bfd_vma data_offset
,
7072 Elf_Internal_Shdr
* data_sec
,
7073 struct arm_section
* data_arm_sec
)
7076 unsigned int more_words
= 0;
7077 struct absaddr addr
;
7078 bfd_vma sym_name
= (bfd_vma
) -1;
7082 /* Fetch the first word.
7083 Note - when decoding an object file the address extracted
7084 here will always be 0. So we also pass in the sym_name
7085 parameter so that we can find the symbol associated with
7086 the personality routine. */
7087 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7088 & word
, & addr
, & sym_name
))
7094 if ((word
& 0x80000000) == 0)
7096 /* Expand prel31 for personality routine. */
7098 const char *procname
;
7100 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7101 printf (_(" Personality routine: "));
7103 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7104 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7106 procname
= aux
->strtab
+ sym_name
;
7107 print_vma (fn
, PREFIX_HEX
);
7110 fputs (" <", stdout
);
7111 fputs (procname
, stdout
);
7112 fputc ('>', stdout
);
7116 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7117 fputc ('\n', stdout
);
7119 /* The GCC personality routines use the standard compact
7120 encoding, starting with one byte giving the number of
7122 if (procname
!= NULL
7123 && (const_strneq (procname
, "__gcc_personality_v0")
7124 || const_strneq (procname
, "__gxx_personality_v0")
7125 || const_strneq (procname
, "__gcj_personality_v0")
7126 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7133 printf (_(" [Truncated data]\n"));
7136 more_words
= word
>> 24;
7146 /* ARM EHABI Section 6.3:
7148 An exception-handling table entry for the compact model looks like:
7152 1 0 index Data for personalityRoutine[index] */
7154 if (elf_header
.e_machine
== EM_ARM
7155 && (word
& 0x70000000))
7156 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7158 per_index
= (word
>> 24) & 0x7f;
7159 printf (_(" Compact model index: %d\n"), per_index
);
7166 else if (per_index
< 3)
7168 more_words
= (word
>> 16) & 0xff;
7174 switch (elf_header
.e_machine
)
7179 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7180 data_offset
, data_sec
, data_arm_sec
);
7184 warn (_("Unknown ARM compact model index encountered\n"));
7185 printf (_(" [reserved]\n"));
7192 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7193 data_offset
, data_sec
, data_arm_sec
);
7195 else if (per_index
< 5)
7197 if (((word
>> 17) & 0x7f) == 0x7f)
7198 printf (_(" Restore stack from frame pointer\n"));
7200 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7201 printf (_(" Registers restored: "));
7203 printf (" (compact) ");
7204 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7206 printf (_(" Return register: %s\n"),
7207 tic6x_unwind_regnames
[word
& 0xf]);
7210 printf (_(" [reserved (%d)]\n"), per_index
);
7214 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7215 elf_header
.e_machine
);
7218 /* Decode the descriptors. Not implemented. */
7222 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7224 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7225 unsigned int i
, exidx_len
;
7227 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7228 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7229 exidx_len
= exidx_sec
->sh_size
/ 8;
7231 for (i
= 0; i
< exidx_len
; i
++)
7233 unsigned int exidx_fn
, exidx_entry
;
7234 struct absaddr fn_addr
, entry_addr
;
7237 fputc ('\n', stdout
);
7239 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7240 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7241 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7242 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7244 arm_free_section (& exidx_arm_sec
);
7245 arm_free_section (& extab_arm_sec
);
7249 /* ARM EHABI, Section 5:
7250 An index table entry consists of 2 words.
7251 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7252 if (exidx_fn
& 0x80000000)
7253 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7255 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7257 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7258 fputs (": ", stdout
);
7260 if (exidx_entry
== 1)
7262 print_vma (exidx_entry
, PREFIX_HEX
);
7263 fputs (" [cantunwind]\n", stdout
);
7265 else if (exidx_entry
& 0x80000000)
7267 print_vma (exidx_entry
, PREFIX_HEX
);
7268 fputc ('\n', stdout
);
7269 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7273 bfd_vma table
, table_offset
= 0;
7274 Elf_Internal_Shdr
*table_sec
;
7276 fputs ("@", stdout
);
7277 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7278 print_vma (table
, PREFIX_HEX
);
7281 /* Locate the matching .ARM.extab. */
7282 if (entry_addr
.section
!= SHN_UNDEF
7283 && entry_addr
.section
< elf_header
.e_shnum
)
7285 table_sec
= section_headers
+ entry_addr
.section
;
7286 table_offset
= entry_addr
.offset
;
7290 table_sec
= find_section_by_address (table
);
7291 if (table_sec
!= NULL
)
7292 table_offset
= table
- table_sec
->sh_addr
;
7294 if (table_sec
== NULL
)
7296 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7297 (unsigned long) table
);
7300 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7307 arm_free_section (&exidx_arm_sec
);
7308 arm_free_section (&extab_arm_sec
);
7311 /* Used for both ARM and C6X unwinding tables. */
7314 arm_process_unwind (FILE *file
)
7316 struct arm_unw_aux_info aux
;
7317 Elf_Internal_Shdr
*unwsec
= NULL
;
7318 Elf_Internal_Shdr
*strsec
;
7319 Elf_Internal_Shdr
*sec
;
7321 unsigned int sec_type
;
7323 switch (elf_header
.e_machine
)
7326 sec_type
= SHT_ARM_EXIDX
;
7330 sec_type
= SHT_C6000_UNWIND
;
7334 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7335 elf_header
.e_machine
);
7339 if (string_table
== NULL
)
7342 memset (& aux
, 0, sizeof (aux
));
7345 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7347 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7349 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7351 strsec
= section_headers
+ sec
->sh_link
;
7352 assert (aux
.strtab
== NULL
);
7353 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7354 1, strsec
->sh_size
, _("string table"));
7355 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7357 else if (sec
->sh_type
== sec_type
)
7362 printf (_("\nThere are no unwind sections in this file.\n"));
7364 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7366 if (sec
->sh_type
== sec_type
)
7368 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7370 (unsigned long) sec
->sh_offset
,
7371 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7373 dump_arm_unwind (&aux
, sec
);
7380 free ((char *) aux
.strtab
);
7384 process_unwind (FILE * file
)
7386 struct unwind_handler
7389 void (* handler
)(FILE *);
7392 { EM_ARM
, arm_process_unwind
},
7393 { EM_IA_64
, ia64_process_unwind
},
7394 { EM_PARISC
, hppa_process_unwind
},
7395 { EM_TI_C6000
, arm_process_unwind
},
7403 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7404 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7405 return handlers
[i
].handler (file
);
7407 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7408 get_machine_name (elf_header
.e_machine
));
7412 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7414 switch (entry
->d_tag
)
7417 if (entry
->d_un
.d_val
== 0)
7421 static const char * opts
[] =
7423 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7424 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7425 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7426 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7432 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7433 if (entry
->d_un
.d_val
& (1 << cnt
))
7435 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7441 case DT_MIPS_IVERSION
:
7442 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7443 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7445 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7448 case DT_MIPS_TIME_STAMP
:
7453 time_t atime
= entry
->d_un
.d_val
;
7454 tmp
= gmtime (&atime
);
7455 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7456 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7457 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7458 printf (_("Time Stamp: %s"), timebuf
);
7462 case DT_MIPS_RLD_VERSION
:
7463 case DT_MIPS_LOCAL_GOTNO
:
7464 case DT_MIPS_CONFLICTNO
:
7465 case DT_MIPS_LIBLISTNO
:
7466 case DT_MIPS_SYMTABNO
:
7467 case DT_MIPS_UNREFEXTNO
:
7468 case DT_MIPS_HIPAGENO
:
7469 case DT_MIPS_DELTA_CLASS_NO
:
7470 case DT_MIPS_DELTA_INSTANCE_NO
:
7471 case DT_MIPS_DELTA_RELOC_NO
:
7472 case DT_MIPS_DELTA_SYM_NO
:
7473 case DT_MIPS_DELTA_CLASSSYM_NO
:
7474 case DT_MIPS_COMPACT_SIZE
:
7475 print_vma (entry
->d_un
.d_ptr
, DEC
);
7479 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7485 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7487 switch (entry
->d_tag
)
7489 case DT_HP_DLD_FLAGS
:
7498 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7499 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7500 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7501 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7502 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7503 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7504 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7505 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7506 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7507 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7508 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7509 { DT_HP_GST
, "HP_GST" },
7510 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7511 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7512 { DT_HP_NODELETE
, "HP_NODELETE" },
7513 { DT_HP_GROUP
, "HP_GROUP" },
7514 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7518 bfd_vma val
= entry
->d_un
.d_val
;
7520 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7521 if (val
& flags
[cnt
].bit
)
7525 fputs (flags
[cnt
].str
, stdout
);
7527 val
^= flags
[cnt
].bit
;
7530 if (val
!= 0 || first
)
7534 print_vma (val
, HEX
);
7540 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7548 /* VMS vs Unix time offset and factor. */
7550 #define VMS_EPOCH_OFFSET 35067168000000000LL
7551 #define VMS_GRANULARITY_FACTOR 10000000
7553 /* Display a VMS time in a human readable format. */
7556 print_vms_time (bfd_int64_t vmstime
)
7561 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7562 tm
= gmtime (&unxtime
);
7563 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7564 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7565 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7570 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7572 switch (entry
->d_tag
)
7574 case DT_IA_64_PLT_RESERVE
:
7575 /* First 3 slots reserved. */
7576 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7578 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7581 case DT_IA_64_VMS_LINKTIME
:
7583 print_vms_time (entry
->d_un
.d_val
);
7587 case DT_IA_64_VMS_LNKFLAGS
:
7588 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7589 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7590 printf (" CALL_DEBUG");
7591 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7592 printf (" NOP0BUFS");
7593 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7594 printf (" P0IMAGE");
7595 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7596 printf (" MKTHREADS");
7597 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7598 printf (" UPCALLS");
7599 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7601 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7602 printf (" INITIALIZE");
7603 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7605 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7606 printf (" EXE_INIT");
7607 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7608 printf (" TBK_IN_IMG");
7609 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7610 printf (" DBG_IN_IMG");
7611 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7612 printf (" TBK_IN_DSF");
7613 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7614 printf (" DBG_IN_DSF");
7615 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7616 printf (" SIGNATURES");
7617 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7618 printf (" REL_SEG_OFF");
7622 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7629 get_32bit_dynamic_section (FILE * file
)
7631 Elf32_External_Dyn
* edyn
;
7632 Elf32_External_Dyn
* ext
;
7633 Elf_Internal_Dyn
* entry
;
7635 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7636 dynamic_size
, _("dynamic section"));
7640 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7641 might not have the luxury of section headers. Look for the DT_NULL
7642 terminator to determine the number of entries. */
7643 for (ext
= edyn
, dynamic_nent
= 0;
7644 (char *) ext
< (char *) edyn
+ dynamic_size
;
7648 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7652 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7654 if (dynamic_section
== NULL
)
7656 error (_("Out of memory\n"));
7661 for (ext
= edyn
, entry
= dynamic_section
;
7662 entry
< dynamic_section
+ dynamic_nent
;
7665 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7666 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7675 get_64bit_dynamic_section (FILE * file
)
7677 Elf64_External_Dyn
* edyn
;
7678 Elf64_External_Dyn
* ext
;
7679 Elf_Internal_Dyn
* entry
;
7681 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7682 dynamic_size
, _("dynamic section"));
7686 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7687 might not have the luxury of section headers. Look for the DT_NULL
7688 terminator to determine the number of entries. */
7689 for (ext
= edyn
, dynamic_nent
= 0;
7690 (char *) ext
< (char *) edyn
+ dynamic_size
;
7694 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7698 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7700 if (dynamic_section
== NULL
)
7702 error (_("Out of memory\n"));
7707 for (ext
= edyn
, entry
= dynamic_section
;
7708 entry
< dynamic_section
+ dynamic_nent
;
7711 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7712 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7721 print_dynamic_flags (bfd_vma flags
)
7729 flag
= flags
& - flags
;
7739 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7740 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7741 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7742 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7743 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7744 default: fputs (_("unknown"), stdout
); break;
7750 /* Parse and display the contents of the dynamic section. */
7753 process_dynamic_section (FILE * file
)
7755 Elf_Internal_Dyn
* entry
;
7757 if (dynamic_size
== 0)
7760 printf (_("\nThere is no dynamic section in this file.\n"));
7767 if (! get_32bit_dynamic_section (file
))
7770 else if (! get_64bit_dynamic_section (file
))
7773 /* Find the appropriate symbol table. */
7774 if (dynamic_symbols
== NULL
)
7776 for (entry
= dynamic_section
;
7777 entry
< dynamic_section
+ dynamic_nent
;
7780 Elf_Internal_Shdr section
;
7782 if (entry
->d_tag
!= DT_SYMTAB
)
7785 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7787 /* Since we do not know how big the symbol table is,
7788 we default to reading in the entire file (!) and
7789 processing that. This is overkill, I know, but it
7791 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7793 if (archive_file_offset
!= 0)
7794 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7797 if (fseek (file
, 0, SEEK_END
))
7798 error (_("Unable to seek to end of file!\n"));
7800 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7804 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7806 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7808 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7809 if (num_dynamic_syms
< 1)
7811 error (_("Unable to determine the number of symbols to load\n"));
7817 /* Similarly find a string table. */
7818 if (dynamic_strings
== NULL
)
7820 for (entry
= dynamic_section
;
7821 entry
< dynamic_section
+ dynamic_nent
;
7824 unsigned long offset
;
7827 if (entry
->d_tag
!= DT_STRTAB
)
7830 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7832 /* Since we do not know how big the string table is,
7833 we default to reading in the entire file (!) and
7834 processing that. This is overkill, I know, but it
7837 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7839 if (archive_file_offset
!= 0)
7840 str_tab_len
= archive_file_size
- offset
;
7843 if (fseek (file
, 0, SEEK_END
))
7844 error (_("Unable to seek to end of file\n"));
7845 str_tab_len
= ftell (file
) - offset
;
7848 if (str_tab_len
< 1)
7851 (_("Unable to determine the length of the dynamic string table\n"));
7855 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7857 _("dynamic string table"));
7858 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7863 /* And find the syminfo section if available. */
7864 if (dynamic_syminfo
== NULL
)
7866 unsigned long syminsz
= 0;
7868 for (entry
= dynamic_section
;
7869 entry
< dynamic_section
+ dynamic_nent
;
7872 if (entry
->d_tag
== DT_SYMINENT
)
7874 /* Note: these braces are necessary to avoid a syntax
7875 error from the SunOS4 C compiler. */
7876 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7878 else if (entry
->d_tag
== DT_SYMINSZ
)
7879 syminsz
= entry
->d_un
.d_val
;
7880 else if (entry
->d_tag
== DT_SYMINFO
)
7881 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7885 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7887 Elf_External_Syminfo
* extsyminfo
;
7888 Elf_External_Syminfo
* extsym
;
7889 Elf_Internal_Syminfo
* syminfo
;
7891 /* There is a syminfo section. Read the data. */
7892 extsyminfo
= (Elf_External_Syminfo
*)
7893 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7894 _("symbol information"));
7898 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7899 if (dynamic_syminfo
== NULL
)
7901 error (_("Out of memory\n"));
7905 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7906 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7907 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7908 ++syminfo
, ++extsym
)
7910 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7911 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7918 if (do_dynamic
&& dynamic_addr
)
7919 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7920 dynamic_addr
, dynamic_nent
);
7922 printf (_(" Tag Type Name/Value\n"));
7924 for (entry
= dynamic_section
;
7925 entry
< dynamic_section
+ dynamic_nent
;
7933 print_vma (entry
->d_tag
, FULL_HEX
);
7934 dtype
= get_dynamic_type (entry
->d_tag
);
7935 printf (" (%s)%*s", dtype
,
7936 ((is_32bit_elf
? 27 : 19)
7937 - (int) strlen (dtype
)),
7941 switch (entry
->d_tag
)
7945 print_dynamic_flags (entry
->d_un
.d_val
);
7955 switch (entry
->d_tag
)
7958 printf (_("Auxiliary library"));
7962 printf (_("Filter library"));
7966 printf (_("Configuration file"));
7970 printf (_("Dependency audit library"));
7974 printf (_("Audit library"));
7978 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7979 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7983 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7992 printf (_("Flags:"));
7994 if (entry
->d_un
.d_val
== 0)
7995 printf (_(" None\n"));
7998 unsigned long int val
= entry
->d_un
.d_val
;
8000 if (val
& DTF_1_PARINIT
)
8002 printf (" PARINIT");
8003 val
^= DTF_1_PARINIT
;
8005 if (val
& DTF_1_CONFEXP
)
8007 printf (" CONFEXP");
8008 val
^= DTF_1_CONFEXP
;
8011 printf (" %lx", val
);
8020 printf (_("Flags:"));
8022 if (entry
->d_un
.d_val
== 0)
8023 printf (_(" None\n"));
8026 unsigned long int val
= entry
->d_un
.d_val
;
8028 if (val
& DF_P1_LAZYLOAD
)
8030 printf (" LAZYLOAD");
8031 val
^= DF_P1_LAZYLOAD
;
8033 if (val
& DF_P1_GROUPPERM
)
8035 printf (" GROUPPERM");
8036 val
^= DF_P1_GROUPPERM
;
8039 printf (" %lx", val
);
8048 printf (_("Flags:"));
8049 if (entry
->d_un
.d_val
== 0)
8050 printf (_(" None\n"));
8053 unsigned long int val
= entry
->d_un
.d_val
;
8060 if (val
& DF_1_GLOBAL
)
8065 if (val
& DF_1_GROUP
)
8070 if (val
& DF_1_NODELETE
)
8072 printf (" NODELETE");
8073 val
^= DF_1_NODELETE
;
8075 if (val
& DF_1_LOADFLTR
)
8077 printf (" LOADFLTR");
8078 val
^= DF_1_LOADFLTR
;
8080 if (val
& DF_1_INITFIRST
)
8082 printf (" INITFIRST");
8083 val
^= DF_1_INITFIRST
;
8085 if (val
& DF_1_NOOPEN
)
8090 if (val
& DF_1_ORIGIN
)
8095 if (val
& DF_1_DIRECT
)
8100 if (val
& DF_1_TRANS
)
8105 if (val
& DF_1_INTERPOSE
)
8107 printf (" INTERPOSE");
8108 val
^= DF_1_INTERPOSE
;
8110 if (val
& DF_1_NODEFLIB
)
8112 printf (" NODEFLIB");
8113 val
^= DF_1_NODEFLIB
;
8115 if (val
& DF_1_NODUMP
)
8120 if (val
& DF_1_CONFALT
)
8122 printf (" CONFALT");
8123 val
^= DF_1_CONFALT
;
8125 if (val
& DF_1_ENDFILTEE
)
8127 printf (" ENDFILTEE");
8128 val
^= DF_1_ENDFILTEE
;
8130 if (val
& DF_1_DISPRELDNE
)
8132 printf (" DISPRELDNE");
8133 val
^= DF_1_DISPRELDNE
;
8135 if (val
& DF_1_DISPRELPND
)
8137 printf (" DISPRELPND");
8138 val
^= DF_1_DISPRELPND
;
8140 if (val
& DF_1_NODIRECT
)
8142 printf (" NODIRECT");
8143 val
^= DF_1_NODIRECT
;
8145 if (val
& DF_1_IGNMULDEF
)
8147 printf (" IGNMULDEF");
8148 val
^= DF_1_IGNMULDEF
;
8150 if (val
& DF_1_NOKSYMS
)
8152 printf (" NOKSYMS");
8153 val
^= DF_1_NOKSYMS
;
8155 if (val
& DF_1_NOHDR
)
8160 if (val
& DF_1_EDITED
)
8165 if (val
& DF_1_NORELOC
)
8167 printf (" NORELOC");
8168 val
^= DF_1_NORELOC
;
8170 if (val
& DF_1_SYMINTPOSE
)
8172 printf (" SYMINTPOSE");
8173 val
^= DF_1_SYMINTPOSE
;
8175 if (val
& DF_1_GLOBAUDIT
)
8177 printf (" GLOBAUDIT");
8178 val
^= DF_1_GLOBAUDIT
;
8180 if (val
& DF_1_SINGLETON
)
8182 printf (" SINGLETON");
8183 val
^= DF_1_SINGLETON
;
8186 printf (" %lx", val
);
8193 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8195 puts (get_dynamic_type (entry
->d_un
.d_val
));
8215 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8221 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8222 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8228 switch (entry
->d_tag
)
8231 printf (_("Shared library: [%s]"), name
);
8233 if (streq (name
, program_interpreter
))
8234 printf (_(" program interpreter"));
8238 printf (_("Library soname: [%s]"), name
);
8242 printf (_("Library rpath: [%s]"), name
);
8246 printf (_("Library runpath: [%s]"), name
);
8250 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8255 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8268 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8272 case DT_INIT_ARRAYSZ
:
8273 case DT_FINI_ARRAYSZ
:
8274 case DT_GNU_CONFLICTSZ
:
8275 case DT_GNU_LIBLISTSZ
:
8278 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8279 printf (_(" (bytes)\n"));
8289 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8302 if (entry
->d_tag
== DT_USED
8303 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8305 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8309 printf (_("Not needed object: [%s]\n"), name
);
8314 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8320 /* The value of this entry is ignored. */
8325 case DT_GNU_PRELINKED
:
8329 time_t atime
= entry
->d_un
.d_val
;
8331 tmp
= gmtime (&atime
);
8332 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8333 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8334 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8340 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8343 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8349 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8350 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8355 switch (elf_header
.e_machine
)
8358 case EM_MIPS_RS3_LE
:
8359 dynamic_section_mips_val (entry
);
8362 dynamic_section_parisc_val (entry
);
8365 dynamic_section_ia64_val (entry
);
8368 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8380 get_ver_flags (unsigned int flags
)
8382 static char buff
[32];
8389 if (flags
& VER_FLG_BASE
)
8390 strcat (buff
, "BASE ");
8392 if (flags
& VER_FLG_WEAK
)
8394 if (flags
& VER_FLG_BASE
)
8395 strcat (buff
, "| ");
8397 strcat (buff
, "WEAK ");
8400 if (flags
& VER_FLG_INFO
)
8402 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8403 strcat (buff
, "| ");
8405 strcat (buff
, "INFO ");
8408 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8409 strcat (buff
, _("| <unknown>"));
8414 /* Display the contents of the version sections. */
8417 process_version_sections (FILE * file
)
8419 Elf_Internal_Shdr
* section
;
8426 for (i
= 0, section
= section_headers
;
8427 i
< elf_header
.e_shnum
;
8430 switch (section
->sh_type
)
8432 case SHT_GNU_verdef
:
8434 Elf_External_Verdef
* edefs
;
8442 (_("\nVersion definition section '%s' contains %u entries:\n"),
8443 SECTION_NAME (section
), section
->sh_info
);
8445 printf (_(" Addr: 0x"));
8446 printf_vma (section
->sh_addr
);
8447 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8448 (unsigned long) section
->sh_offset
, section
->sh_link
,
8449 section
->sh_link
< elf_header
.e_shnum
8450 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8453 edefs
= (Elf_External_Verdef
*)
8454 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8455 _("version definition section"));
8458 endbuf
= (char *) edefs
+ section
->sh_size
;
8460 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8463 Elf_External_Verdef
* edef
;
8464 Elf_Internal_Verdef ent
;
8465 Elf_External_Verdaux
* eaux
;
8466 Elf_Internal_Verdaux aux
;
8470 /* Check for very large indicies. */
8471 if (idx
> (size_t) (endbuf
- (char *) edefs
))
8474 vstart
= ((char *) edefs
) + idx
;
8475 if (vstart
+ sizeof (*edef
) > endbuf
)
8478 edef
= (Elf_External_Verdef
*) vstart
;
8480 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8481 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8482 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8483 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8484 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8485 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8486 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8488 printf (_(" %#06x: Rev: %d Flags: %s"),
8489 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8491 printf (_(" Index: %d Cnt: %d "),
8492 ent
.vd_ndx
, ent
.vd_cnt
);
8494 /* Check for overflow. */
8495 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
8498 vstart
+= ent
.vd_aux
;
8500 eaux
= (Elf_External_Verdaux
*) vstart
;
8502 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8503 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8505 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8506 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8508 printf (_("Name index: %ld\n"), aux
.vda_name
);
8510 isum
= idx
+ ent
.vd_aux
;
8512 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8514 /* Check for overflow. */
8515 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
8518 isum
+= aux
.vda_next
;
8519 vstart
+= aux
.vda_next
;
8521 eaux
= (Elf_External_Verdaux
*) vstart
;
8522 if (vstart
+ sizeof (*eaux
) > endbuf
)
8525 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8526 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8528 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8529 printf (_(" %#06x: Parent %d: %s\n"),
8530 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8532 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8533 isum
, j
, aux
.vda_name
);
8537 printf (_(" Version def aux past end of section\n"));
8542 if (cnt
< section
->sh_info
)
8543 printf (_(" Version definition past end of section\n"));
8549 case SHT_GNU_verneed
:
8551 Elf_External_Verneed
* eneed
;
8558 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8559 SECTION_NAME (section
), section
->sh_info
);
8561 printf (_(" Addr: 0x"));
8562 printf_vma (section
->sh_addr
);
8563 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8564 (unsigned long) section
->sh_offset
, section
->sh_link
,
8565 section
->sh_link
< elf_header
.e_shnum
8566 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8569 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8570 section
->sh_offset
, 1,
8572 _("Version Needs section"));
8575 endbuf
= (char *) eneed
+ section
->sh_size
;
8577 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8579 Elf_External_Verneed
* entry
;
8580 Elf_Internal_Verneed ent
;
8585 if (idx
> (size_t) (endbuf
- (char *) eneed
))
8588 vstart
= ((char *) eneed
) + idx
;
8589 if (vstart
+ sizeof (*entry
) > endbuf
)
8592 entry
= (Elf_External_Verneed
*) vstart
;
8594 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8595 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8596 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8597 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8598 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8600 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8602 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8603 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8605 printf (_(" File: %lx"), ent
.vn_file
);
8607 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8609 /* Check for overflow. */
8610 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
8613 vstart
+= ent
.vn_aux
;
8615 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8617 Elf_External_Vernaux
* eaux
;
8618 Elf_Internal_Vernaux aux
;
8620 if (vstart
+ sizeof (*eaux
) > endbuf
)
8622 eaux
= (Elf_External_Vernaux
*) vstart
;
8624 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8625 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8626 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8627 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8628 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8630 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8631 printf (_(" %#06x: Name: %s"),
8632 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8634 printf (_(" %#06x: Name index: %lx"),
8635 isum
, aux
.vna_name
);
8637 printf (_(" Flags: %s Version: %d\n"),
8638 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8640 /* Check for overflow. */
8641 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
8644 isum
+= aux
.vna_next
;
8645 vstart
+= aux
.vna_next
;
8649 warn (_("Missing Version Needs auxillary information\n"));
8654 if (cnt
< section
->sh_info
)
8655 warn (_("Missing Version Needs information\n"));
8661 case SHT_GNU_versym
:
8663 Elf_Internal_Shdr
* link_section
;
8666 unsigned char * edata
;
8667 unsigned short * data
;
8669 Elf_Internal_Sym
* symbols
;
8670 Elf_Internal_Shdr
* string_sec
;
8671 unsigned long num_syms
;
8674 if (section
->sh_link
>= elf_header
.e_shnum
)
8677 link_section
= section_headers
+ section
->sh_link
;
8678 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8680 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8685 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8686 if (symbols
== NULL
)
8689 string_sec
= section_headers
+ link_section
->sh_link
;
8691 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8692 string_sec
->sh_size
,
8693 _("version string table"));
8700 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8701 SECTION_NAME (section
), total
);
8703 printf (_(" Addr: "));
8704 printf_vma (section
->sh_addr
);
8705 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8706 (unsigned long) section
->sh_offset
, section
->sh_link
,
8707 SECTION_NAME (link_section
));
8709 off
= offset_from_vma (file
,
8710 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8711 total
* sizeof (short));
8712 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8714 _("version symbol data"));
8722 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8724 for (cnt
= total
; cnt
--;)
8725 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8730 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8733 int check_def
, check_need
;
8736 printf (" %03x:", cnt
);
8738 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8739 switch (data
[cnt
+ j
])
8742 fputs (_(" 0 (*local*) "), stdout
);
8746 fputs (_(" 1 (*global*) "), stdout
);
8750 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8751 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8753 /* If this index value is greater than the size of the symbols
8754 array, break to avoid an out-of-bounds read. */
8755 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8757 warn (_("invalid index into symbol array\n"));
8763 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8764 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8767 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8774 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8776 Elf_Internal_Verneed ivn
;
8777 unsigned long offset
;
8779 offset
= offset_from_vma
8780 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8781 sizeof (Elf_External_Verneed
));
8785 Elf_Internal_Vernaux ivna
;
8786 Elf_External_Verneed evn
;
8787 Elf_External_Vernaux evna
;
8788 unsigned long a_off
;
8790 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8791 _("version need")) == NULL
)
8794 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8795 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8797 a_off
= offset
+ ivn
.vn_aux
;
8801 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8802 1, _("version need aux (2)")) == NULL
)
8809 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8810 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8813 a_off
+= ivna
.vna_next
;
8815 while (ivna
.vna_other
!= data
[cnt
+ j
]
8816 && ivna
.vna_next
!= 0);
8818 if (ivna
.vna_other
== data
[cnt
+ j
])
8820 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8822 if (ivna
.vna_name
>= string_sec
->sh_size
)
8823 name
= _("*invalid*");
8825 name
= strtab
+ ivna
.vna_name
;
8826 nn
+= printf ("(%s%-*s",
8828 12 - (int) strlen (name
),
8834 offset
+= ivn
.vn_next
;
8836 while (ivn
.vn_next
);
8839 if (check_def
&& data
[cnt
+ j
] != 0x8001
8840 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8842 Elf_Internal_Verdef ivd
;
8843 Elf_External_Verdef evd
;
8844 unsigned long offset
;
8846 offset
= offset_from_vma
8847 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8852 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8853 _("version def")) == NULL
)
8860 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8861 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8864 offset
+= ivd
.vd_next
;
8866 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8867 && ivd
.vd_next
!= 0);
8869 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8871 Elf_External_Verdaux evda
;
8872 Elf_Internal_Verdaux ivda
;
8874 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8876 if (get_data (&evda
, file
,
8877 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8879 _("version def aux")) == NULL
)
8882 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8884 if (ivda
.vda_name
>= string_sec
->sh_size
)
8885 name
= _("*invalid*");
8887 name
= strtab
+ ivda
.vda_name
;
8888 nn
+= printf ("(%s%-*s",
8890 12 - (int) strlen (name
),
8896 printf ("%*c", 18 - nn
, ' ');
8914 printf (_("\nNo version information found in this file.\n"));
8920 get_symbol_binding (unsigned int binding
)
8922 static char buff
[32];
8926 case STB_LOCAL
: return "LOCAL";
8927 case STB_GLOBAL
: return "GLOBAL";
8928 case STB_WEAK
: return "WEAK";
8930 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8931 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8933 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8935 if (binding
== STB_GNU_UNIQUE
8936 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8937 /* GNU is still using the default value 0. */
8938 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8940 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8943 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8949 get_symbol_type (unsigned int type
)
8951 static char buff
[32];
8955 case STT_NOTYPE
: return "NOTYPE";
8956 case STT_OBJECT
: return "OBJECT";
8957 case STT_FUNC
: return "FUNC";
8958 case STT_SECTION
: return "SECTION";
8959 case STT_FILE
: return "FILE";
8960 case STT_COMMON
: return "COMMON";
8961 case STT_TLS
: return "TLS";
8962 case STT_RELC
: return "RELC";
8963 case STT_SRELC
: return "SRELC";
8965 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8967 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8968 return "THUMB_FUNC";
8970 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8973 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8974 return "PARISC_MILLI";
8976 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8978 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8980 if (elf_header
.e_machine
== EM_PARISC
)
8982 if (type
== STT_HP_OPAQUE
)
8984 if (type
== STT_HP_STUB
)
8988 if (type
== STT_GNU_IFUNC
8989 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8990 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
8991 /* GNU is still using the default value 0. */
8992 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8995 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8998 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9004 get_symbol_visibility (unsigned int visibility
)
9008 case STV_DEFAULT
: return "DEFAULT";
9009 case STV_INTERNAL
: return "INTERNAL";
9010 case STV_HIDDEN
: return "HIDDEN";
9011 case STV_PROTECTED
: return "PROTECTED";
9017 get_mips_symbol_other (unsigned int other
)
9029 case STO_MICROMIPS
| STO_MIPS_PIC
:
9030 return "MICROMIPS, MIPS PIC";
9039 get_ia64_symbol_other (unsigned int other
)
9043 static char res
[32];
9047 /* Function types is for images and .STB files only. */
9048 switch (elf_header
.e_type
)
9052 switch (VMS_ST_FUNC_TYPE (other
))
9054 case VMS_SFT_CODE_ADDR
:
9055 strcat (res
, " CA");
9057 case VMS_SFT_SYMV_IDX
:
9058 strcat (res
, " VEC");
9061 strcat (res
, " FD");
9063 case VMS_SFT_RESERVE
:
9064 strcat (res
, " RSV");
9073 switch (VMS_ST_LINKAGE (other
))
9075 case VMS_STL_IGNORE
:
9076 strcat (res
, " IGN");
9078 case VMS_STL_RESERVE
:
9079 strcat (res
, " RSV");
9082 strcat (res
, " STD");
9085 strcat (res
, " LNK");
9100 get_symbol_other (unsigned int other
)
9102 const char * result
= NULL
;
9103 static char buff
[32];
9108 switch (elf_header
.e_machine
)
9111 result
= get_mips_symbol_other (other
);
9114 result
= get_ia64_symbol_other (other
);
9123 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9128 get_symbol_index_type (unsigned int type
)
9130 static char buff
[32];
9134 case SHN_UNDEF
: return "UND";
9135 case SHN_ABS
: return "ABS";
9136 case SHN_COMMON
: return "COM";
9138 if (type
== SHN_IA_64_ANSI_COMMON
9139 && elf_header
.e_machine
== EM_IA_64
9140 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9142 else if ((elf_header
.e_machine
== EM_X86_64
9143 || elf_header
.e_machine
== EM_L1OM
9144 || elf_header
.e_machine
== EM_K1OM
)
9145 && type
== SHN_X86_64_LCOMMON
)
9147 else if ((type
== SHN_MIPS_SCOMMON
9148 && elf_header
.e_machine
== EM_MIPS
)
9149 || (type
== SHN_TIC6X_SCOMMON
9150 && elf_header
.e_machine
== EM_TI_C6000
))
9152 else if (type
== SHN_MIPS_SUNDEFINED
9153 && elf_header
.e_machine
== EM_MIPS
)
9155 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9156 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9157 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9158 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9159 else if (type
>= SHN_LORESERVE
)
9160 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9161 else if (type
>= elf_header
.e_shnum
)
9162 sprintf (buff
, "bad section index[%3d]", type
);
9164 sprintf (buff
, "%3d", type
);
9172 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9174 unsigned char * e_data
;
9177 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9181 error (_("Out of memory\n"));
9185 if (fread (e_data
, ent_size
, number
, file
) != number
)
9187 error (_("Unable to read in dynamic data\n"));
9191 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9195 error (_("Out of memory\n"));
9201 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9209 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9211 Elf_Internal_Sym
* psym
;
9214 psym
= dynamic_symbols
+ si
;
9216 n
= print_vma (si
, DEC_5
);
9218 fputs (" " + n
, stdout
);
9219 printf (" %3lu: ", hn
);
9220 print_vma (psym
->st_value
, LONG_HEX
);
9222 print_vma (psym
->st_size
, DEC_5
);
9224 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9225 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9226 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9227 /* Check to see if any other bits in the st_other field are set.
9228 Note - displaying this information disrupts the layout of the
9229 table being generated, but for the moment this case is very
9231 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9232 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9233 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9234 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9235 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9237 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9241 /* Dump the symbol table. */
9243 process_symbol_table (FILE * file
)
9245 Elf_Internal_Shdr
* section
;
9246 bfd_vma nbuckets
= 0;
9247 bfd_vma nchains
= 0;
9248 bfd_vma
* buckets
= NULL
;
9249 bfd_vma
* chains
= NULL
;
9250 bfd_vma ngnubuckets
= 0;
9251 bfd_vma
* gnubuckets
= NULL
;
9252 bfd_vma
* gnuchains
= NULL
;
9253 bfd_vma gnusymidx
= 0;
9255 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9258 if (dynamic_info
[DT_HASH
]
9260 || (do_using_dynamic
9262 && dynamic_strings
!= NULL
)))
9264 unsigned char nb
[8];
9265 unsigned char nc
[8];
9266 int hash_ent_size
= 4;
9268 if ((elf_header
.e_machine
== EM_ALPHA
9269 || elf_header
.e_machine
== EM_S390
9270 || elf_header
.e_machine
== EM_S390_OLD
)
9271 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9275 (archive_file_offset
9276 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9277 sizeof nb
+ sizeof nc
)),
9280 error (_("Unable to seek to start of dynamic information\n"));
9284 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9286 error (_("Failed to read in number of buckets\n"));
9290 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9292 error (_("Failed to read in number of chains\n"));
9296 nbuckets
= byte_get (nb
, hash_ent_size
);
9297 nchains
= byte_get (nc
, hash_ent_size
);
9299 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9300 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9303 if (buckets
== NULL
|| chains
== NULL
)
9305 if (do_using_dynamic
)
9316 if (dynamic_info_DT_GNU_HASH
9318 || (do_using_dynamic
9320 && dynamic_strings
!= NULL
)))
9322 unsigned char nb
[16];
9323 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9324 bfd_vma buckets_vma
;
9327 (archive_file_offset
9328 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9332 error (_("Unable to seek to start of dynamic information\n"));
9336 if (fread (nb
, 16, 1, file
) != 1)
9338 error (_("Failed to read in number of buckets\n"));
9342 ngnubuckets
= byte_get (nb
, 4);
9343 gnusymidx
= byte_get (nb
+ 4, 4);
9344 bitmaskwords
= byte_get (nb
+ 8, 4);
9345 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9347 buckets_vma
+= bitmaskwords
* 4;
9349 buckets_vma
+= bitmaskwords
* 8;
9352 (archive_file_offset
9353 + offset_from_vma (file
, buckets_vma
, 4)),
9356 error (_("Unable to seek to start of dynamic information\n"));
9360 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9362 if (gnubuckets
== NULL
)
9365 for (i
= 0; i
< ngnubuckets
; i
++)
9366 if (gnubuckets
[i
] != 0)
9368 if (gnubuckets
[i
] < gnusymidx
)
9371 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9372 maxchain
= gnubuckets
[i
];
9375 if (maxchain
== 0xffffffff)
9378 maxchain
-= gnusymidx
;
9381 (archive_file_offset
9382 + offset_from_vma (file
, buckets_vma
9383 + 4 * (ngnubuckets
+ maxchain
), 4)),
9386 error (_("Unable to seek to start of dynamic information\n"));
9392 if (fread (nb
, 4, 1, file
) != 1)
9394 error (_("Failed to determine last chain length\n"));
9398 if (maxchain
+ 1 == 0)
9403 while ((byte_get (nb
, 4) & 1) == 0);
9406 (archive_file_offset
9407 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9410 error (_("Unable to seek to start of dynamic information\n"));
9414 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9417 if (gnuchains
== NULL
)
9422 if (do_using_dynamic
)
9427 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9430 && dynamic_strings
!= NULL
)
9434 if (dynamic_info
[DT_HASH
])
9438 printf (_("\nSymbol table for image:\n"));
9440 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9442 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9444 for (hn
= 0; hn
< nbuckets
; hn
++)
9449 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9450 print_dynamic_symbol (si
, hn
);
9454 if (dynamic_info_DT_GNU_HASH
)
9456 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9458 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9460 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9462 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9463 if (gnubuckets
[hn
] != 0)
9465 bfd_vma si
= gnubuckets
[hn
];
9466 bfd_vma off
= si
- gnusymidx
;
9470 print_dynamic_symbol (si
, hn
);
9473 while ((gnuchains
[off
++] & 1) == 0);
9477 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9481 for (i
= 0, section
= section_headers
;
9482 i
< elf_header
.e_shnum
;
9486 char * strtab
= NULL
;
9487 unsigned long int strtab_size
= 0;
9488 Elf_Internal_Sym
* symtab
;
9489 Elf_Internal_Sym
* psym
;
9490 unsigned long num_syms
;
9492 if ((section
->sh_type
!= SHT_SYMTAB
9493 && section
->sh_type
!= SHT_DYNSYM
)
9495 && section
->sh_type
== SHT_SYMTAB
))
9498 if (section
->sh_entsize
== 0)
9500 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9501 SECTION_NAME (section
));
9505 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9506 SECTION_NAME (section
),
9507 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9510 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9512 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9514 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9518 if (section
->sh_link
== elf_header
.e_shstrndx
)
9520 strtab
= string_table
;
9521 strtab_size
= string_table_length
;
9523 else if (section
->sh_link
< elf_header
.e_shnum
)
9525 Elf_Internal_Shdr
* string_sec
;
9527 string_sec
= section_headers
+ section
->sh_link
;
9529 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9530 1, string_sec
->sh_size
,
9532 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9535 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9537 printf ("%6d: ", si
);
9538 print_vma (psym
->st_value
, LONG_HEX
);
9540 print_vma (psym
->st_size
, DEC_5
);
9541 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9542 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9543 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9544 /* Check to see if any other bits in the st_other field are set.
9545 Note - displaying this information disrupts the layout of the
9546 table being generated, but for the moment this case is very rare. */
9547 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9548 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9549 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9550 print_symbol (25, psym
->st_name
< strtab_size
9551 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9553 if (section
->sh_type
== SHT_DYNSYM
9554 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9556 unsigned char data
[2];
9557 unsigned short vers_data
;
9558 unsigned long offset
;
9562 offset
= offset_from_vma
9563 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9564 sizeof data
+ si
* sizeof (vers_data
));
9566 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9567 sizeof (data
), 1, _("version data")) == NULL
)
9570 vers_data
= byte_get (data
, 2);
9572 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9573 && section_headers
[psym
->st_shndx
].sh_type
9576 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9578 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9580 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9581 && (is_nobits
|| ! check_def
))
9583 Elf_External_Verneed evn
;
9584 Elf_Internal_Verneed ivn
;
9585 Elf_Internal_Vernaux ivna
;
9587 /* We must test both. */
9588 offset
= offset_from_vma
9589 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9594 unsigned long vna_off
;
9596 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9597 _("version need")) == NULL
)
9605 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9606 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9608 vna_off
= offset
+ ivn
.vn_aux
;
9612 Elf_External_Vernaux evna
;
9614 if (get_data (&evna
, file
, vna_off
,
9616 _("version need aux (3)")) == NULL
)
9624 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9625 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9626 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9629 vna_off
+= ivna
.vna_next
;
9631 while (ivna
.vna_other
!= vers_data
9632 && ivna
.vna_next
!= 0);
9634 if (ivna
.vna_other
== vers_data
)
9637 offset
+= ivn
.vn_next
;
9639 while (ivn
.vn_next
!= 0);
9641 if (ivna
.vna_other
== vers_data
)
9644 ivna
.vna_name
< strtab_size
9645 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9649 else if (! is_nobits
)
9650 error (_("bad dynamic symbol\n"));
9657 if (vers_data
!= 0x8001
9658 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9660 Elf_Internal_Verdef ivd
;
9661 Elf_Internal_Verdaux ivda
;
9662 Elf_External_Verdaux evda
;
9665 off
= offset_from_vma
9667 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9668 sizeof (Elf_External_Verdef
));
9672 Elf_External_Verdef evd
;
9674 if (get_data (&evd
, file
, off
, sizeof (evd
),
9675 1, _("version def")) == NULL
)
9683 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9684 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9685 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9690 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9691 && ivd
.vd_next
!= 0);
9696 if (get_data (&evda
, file
, off
, sizeof (evda
),
9697 1, _("version def aux")) == NULL
)
9700 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9702 if (psym
->st_name
!= ivda
.vda_name
)
9703 printf ((vers_data
& VERSYM_HIDDEN
)
9705 ivda
.vda_name
< strtab_size
9706 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9716 if (strtab
!= string_table
)
9722 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9724 if (do_histogram
&& buckets
!= NULL
)
9726 unsigned long * lengths
;
9727 unsigned long * counts
;
9730 unsigned long maxlength
= 0;
9731 unsigned long nzero_counts
= 0;
9732 unsigned long nsyms
= 0;
9734 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9735 (unsigned long) nbuckets
);
9736 printf (_(" Length Number %% of total Coverage\n"));
9738 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9739 if (lengths
== NULL
)
9741 error (_("Out of memory\n"));
9744 for (hn
= 0; hn
< nbuckets
; ++hn
)
9746 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9749 if (maxlength
< ++lengths
[hn
])
9754 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9757 error (_("Out of memory\n"));
9761 for (hn
= 0; hn
< nbuckets
; ++hn
)
9762 ++counts
[lengths
[hn
]];
9767 printf (" 0 %-10lu (%5.1f%%)\n",
9768 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9769 for (i
= 1; i
<= maxlength
; ++i
)
9771 nzero_counts
+= counts
[i
] * i
;
9772 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9773 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9774 (nzero_counts
* 100.0) / nsyms
);
9782 if (buckets
!= NULL
)
9788 if (do_histogram
&& gnubuckets
!= NULL
)
9790 unsigned long * lengths
;
9791 unsigned long * counts
;
9793 unsigned long maxlength
= 0;
9794 unsigned long nzero_counts
= 0;
9795 unsigned long nsyms
= 0;
9797 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9798 if (lengths
== NULL
)
9800 error (_("Out of memory\n"));
9804 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9805 (unsigned long) ngnubuckets
);
9806 printf (_(" Length Number %% of total Coverage\n"));
9808 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9809 if (gnubuckets
[hn
] != 0)
9811 bfd_vma off
, length
= 1;
9813 for (off
= gnubuckets
[hn
] - gnusymidx
;
9814 (gnuchains
[off
] & 1) == 0; ++off
)
9816 lengths
[hn
] = length
;
9817 if (length
> maxlength
)
9822 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9825 error (_("Out of memory\n"));
9829 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9830 ++counts
[lengths
[hn
]];
9832 if (ngnubuckets
> 0)
9835 printf (" 0 %-10lu (%5.1f%%)\n",
9836 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9837 for (j
= 1; j
<= maxlength
; ++j
)
9839 nzero_counts
+= counts
[j
] * j
;
9840 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9841 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9842 (nzero_counts
* 100.0) / nsyms
);
9856 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9860 if (dynamic_syminfo
== NULL
9862 /* No syminfo, this is ok. */
9865 /* There better should be a dynamic symbol section. */
9866 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9870 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9871 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9873 printf (_(" Num: Name BoundTo Flags\n"));
9874 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9876 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9878 printf ("%4d: ", i
);
9879 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9880 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9882 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9885 switch (dynamic_syminfo
[i
].si_boundto
)
9887 case SYMINFO_BT_SELF
:
9888 fputs ("SELF ", stdout
);
9890 case SYMINFO_BT_PARENT
:
9891 fputs ("PARENT ", stdout
);
9894 if (dynamic_syminfo
[i
].si_boundto
> 0
9895 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9896 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9898 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9902 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9906 if (flags
& SYMINFO_FLG_DIRECT
)
9908 if (flags
& SYMINFO_FLG_PASSTHRU
)
9909 printf (" PASSTHRU");
9910 if (flags
& SYMINFO_FLG_COPY
)
9912 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9913 printf (" LAZYLOAD");
9921 /* Check to see if the given reloc needs to be handled in a target specific
9922 manner. If so then process the reloc and return TRUE otherwise return
9926 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9927 unsigned char * start
,
9928 Elf_Internal_Sym
* symtab
)
9930 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9932 switch (elf_header
.e_machine
)
9935 case EM_CYGNUS_MN10300
:
9937 static Elf_Internal_Sym
* saved_sym
= NULL
;
9941 case 34: /* R_MN10300_ALIGN */
9943 case 33: /* R_MN10300_SYM_DIFF */
9944 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9946 case 1: /* R_MN10300_32 */
9947 case 2: /* R_MN10300_16 */
9948 if (saved_sym
!= NULL
)
9952 value
= reloc
->r_addend
9953 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9954 - saved_sym
->st_value
);
9956 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9963 if (saved_sym
!= NULL
)
9964 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9974 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9975 DWARF debug sections. This is a target specific test. Note - we do not
9976 go through the whole including-target-headers-multiple-times route, (as
9977 we have already done with <elf/h8.h>) because this would become very
9978 messy and even then this function would have to contain target specific
9979 information (the names of the relocs instead of their numeric values).
9980 FIXME: This is not the correct way to solve this problem. The proper way
9981 is to have target specific reloc sizing and typing functions created by
9982 the reloc-macros.h header, in the same way that it already creates the
9983 reloc naming functions. */
9986 is_32bit_abs_reloc (unsigned int reloc_type
)
9988 switch (elf_header
.e_machine
)
9992 return reloc_type
== 1; /* R_386_32. */
9994 return reloc_type
== 1; /* R_68K_32. */
9996 return reloc_type
== 1; /* R_860_32. */
9998 return reloc_type
== 2; /* R_960_32. */
10000 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10002 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10004 return reloc_type
== 1; /* R_ARC_32. */
10006 return reloc_type
== 2; /* R_ARM_ABS32 */
10009 return reloc_type
== 1;
10010 case EM_ADAPTEVA_EPIPHANY
:
10011 return reloc_type
== 3;
10013 return reloc_type
== 0x12; /* R_byte4_data. */
10015 return reloc_type
== 3; /* R_CRIS_32. */
10017 return reloc_type
== 3; /* R_CR16_NUM32. */
10019 return reloc_type
== 15; /* R_CRX_NUM32. */
10020 case EM_CYGNUS_FRV
:
10021 return reloc_type
== 1;
10022 case EM_CYGNUS_D10V
:
10024 return reloc_type
== 6; /* R_D10V_32. */
10025 case EM_CYGNUS_D30V
:
10027 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10029 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10030 case EM_CYGNUS_FR30
:
10032 return reloc_type
== 3; /* R_FR30_32. */
10036 return reloc_type
== 1; /* R_H8_DIR32. */
10038 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10041 return reloc_type
== 2; /* R_IP2K_32. */
10043 return reloc_type
== 2; /* R_IQ2000_32. */
10044 case EM_LATTICEMICO32
:
10045 return reloc_type
== 3; /* R_LM32_32. */
10048 return reloc_type
== 3; /* R_M32C_32. */
10050 return reloc_type
== 34; /* R_M32R_32_RELA. */
10052 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10053 case EM_CYGNUS_MEP
:
10054 return reloc_type
== 4; /* R_MEP_32. */
10056 return reloc_type
== 2; /* R_METAG_ADDR32. */
10057 case EM_MICROBLAZE
:
10058 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10060 return reloc_type
== 2; /* R_MIPS_32. */
10062 return reloc_type
== 4; /* R_MMIX_32. */
10063 case EM_CYGNUS_MN10200
:
10065 return reloc_type
== 1; /* R_MN10200_32. */
10066 case EM_CYGNUS_MN10300
:
10068 return reloc_type
== 1; /* R_MN10300_32. */
10070 return reloc_type
== 1; /* R_MOXIE_32. */
10071 case EM_MSP430_OLD
:
10073 return reloc_type
== 1; /* R_MSP43_32. */
10075 return reloc_type
== 2; /* R_MT_32. */
10076 case EM_ALTERA_NIOS2
:
10078 return reloc_type
== 1; /* R_NIOS_32. */
10081 return reloc_type
== 1; /* R_OR32_32. */
10083 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10084 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10087 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10089 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10091 return reloc_type
== 1; /* R_PPC_ADDR32. */
10093 return reloc_type
== 1; /* R_RL78_DIR32. */
10095 return reloc_type
== 1; /* R_RX_DIR32. */
10097 return reloc_type
== 1; /* R_I370_ADDR31. */
10100 return reloc_type
== 4; /* R_S390_32. */
10102 return reloc_type
== 8; /* R_SCORE_ABS32. */
10104 return reloc_type
== 1; /* R_SH_DIR32. */
10105 case EM_SPARC32PLUS
:
10108 return reloc_type
== 3 /* R_SPARC_32. */
10109 || reloc_type
== 23; /* R_SPARC_UA32. */
10111 return reloc_type
== 6; /* R_SPU_ADDR32 */
10113 return reloc_type
== 1; /* R_C6000_ABS32. */
10115 return reloc_type
== 2; /* R_TILEGX_32. */
10117 return reloc_type
== 1; /* R_TILEPRO_32. */
10118 case EM_CYGNUS_V850
:
10120 return reloc_type
== 6; /* R_V850_ABS32. */
10122 return reloc_type
== 0x33; /* R_V810_WORD. */
10124 return reloc_type
== 1; /* R_VAX_32. */
10128 return reloc_type
== 10; /* R_X86_64_32. */
10131 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10133 return reloc_type
== 4; /* R_XGATE_32. */
10135 return reloc_type
== 1; /* R_XSTROMY16_32. */
10136 case EM_XTENSA_OLD
:
10138 return reloc_type
== 1; /* R_XTENSA_32. */
10140 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10141 elf_header
.e_machine
);
10146 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10147 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10150 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10152 switch (elf_header
.e_machine
)
10156 return reloc_type
== 2; /* R_386_PC32. */
10158 return reloc_type
== 4; /* R_68K_PC32. */
10160 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10161 case EM_ADAPTEVA_EPIPHANY
:
10162 return reloc_type
== 6;
10164 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10166 return reloc_type
== 3; /* R_ARM_REL32 */
10167 case EM_MICROBLAZE
:
10168 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10170 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10172 return reloc_type
== 26; /* R_PPC_REL32. */
10174 return reloc_type
== 26; /* R_PPC64_REL32. */
10177 return reloc_type
== 5; /* R_390_PC32. */
10179 return reloc_type
== 2; /* R_SH_REL32. */
10180 case EM_SPARC32PLUS
:
10183 return reloc_type
== 6; /* R_SPARC_DISP32. */
10185 return reloc_type
== 13; /* R_SPU_REL32. */
10187 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10189 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10193 return reloc_type
== 2; /* R_X86_64_PC32. */
10194 case EM_XTENSA_OLD
:
10196 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10198 /* Do not abort or issue an error message here. Not all targets use
10199 pc-relative 32-bit relocs in their DWARF debug information and we
10200 have already tested for target coverage in is_32bit_abs_reloc. A
10201 more helpful warning message will be generated by apply_relocations
10202 anyway, so just return. */
10207 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10208 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10211 is_64bit_abs_reloc (unsigned int reloc_type
)
10213 switch (elf_header
.e_machine
)
10216 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10218 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10220 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10222 return reloc_type
== 80; /* R_PARISC_DIR64. */
10224 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10225 case EM_SPARC32PLUS
:
10228 return reloc_type
== 54; /* R_SPARC_UA64. */
10232 return reloc_type
== 1; /* R_X86_64_64. */
10235 return reloc_type
== 22; /* R_S390_64. */
10237 return reloc_type
== 1; /* R_TILEGX_64. */
10239 return reloc_type
== 18; /* R_MIPS_64. */
10245 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10246 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10249 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10251 switch (elf_header
.e_machine
)
10254 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10256 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10258 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10260 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10262 return reloc_type
== 44; /* R_PPC64_REL64. */
10263 case EM_SPARC32PLUS
:
10266 return reloc_type
== 46; /* R_SPARC_DISP64. */
10270 return reloc_type
== 24; /* R_X86_64_PC64. */
10273 return reloc_type
== 23; /* R_S390_PC64. */
10275 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10281 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10282 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10285 is_24bit_abs_reloc (unsigned int reloc_type
)
10287 switch (elf_header
.e_machine
)
10289 case EM_CYGNUS_MN10200
:
10291 return reloc_type
== 4; /* R_MN10200_24. */
10297 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10298 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10301 is_16bit_abs_reloc (unsigned int reloc_type
)
10303 switch (elf_header
.e_machine
)
10307 return reloc_type
== 4; /* R_AVR_16. */
10308 case EM_ADAPTEVA_EPIPHANY
:
10309 return reloc_type
== 5;
10310 case EM_CYGNUS_D10V
:
10312 return reloc_type
== 3; /* R_D10V_16. */
10316 return reloc_type
== R_H8_DIR16
;
10319 return reloc_type
== 1; /* R_IP2K_16. */
10322 return reloc_type
== 1; /* R_M32C_16 */
10324 case EM_MSP430_OLD
:
10325 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10326 case EM_ALTERA_NIOS2
:
10328 return reloc_type
== 9; /* R_NIOS_16. */
10330 return reloc_type
== 2; /* R_C6000_ABS16. */
10333 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10334 case EM_CYGNUS_MN10200
:
10336 return reloc_type
== 2; /* R_MN10200_16. */
10337 case EM_CYGNUS_MN10300
:
10339 return reloc_type
== 2; /* R_MN10300_16. */
10341 return reloc_type
== 3; /* R_XGATE_16. */
10347 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10348 relocation entries (possibly formerly used for SHT_GROUP sections). */
10351 is_none_reloc (unsigned int reloc_type
)
10353 switch (elf_header
.e_machine
)
10355 case EM_68K
: /* R_68K_NONE. */
10356 case EM_386
: /* R_386_NONE. */
10357 case EM_SPARC32PLUS
:
10359 case EM_SPARC
: /* R_SPARC_NONE. */
10360 case EM_MIPS
: /* R_MIPS_NONE. */
10361 case EM_PARISC
: /* R_PARISC_NONE. */
10362 case EM_ALPHA
: /* R_ALPHA_NONE. */
10363 case EM_ADAPTEVA_EPIPHANY
:
10364 case EM_PPC
: /* R_PPC_NONE. */
10365 case EM_PPC64
: /* R_PPC64_NONE. */
10366 case EM_ARM
: /* R_ARM_NONE. */
10367 case EM_IA_64
: /* R_IA64_NONE. */
10368 case EM_SH
: /* R_SH_NONE. */
10370 case EM_S390
: /* R_390_NONE. */
10371 case EM_CRIS
: /* R_CRIS_NONE. */
10372 case EM_X86_64
: /* R_X86_64_NONE. */
10373 case EM_L1OM
: /* R_X86_64_NONE. */
10374 case EM_K1OM
: /* R_X86_64_NONE. */
10375 case EM_MN10300
: /* R_MN10300_NONE. */
10376 case EM_MOXIE
: /* R_MOXIE_NONE. */
10377 case EM_M32R
: /* R_M32R_NONE. */
10378 case EM_TI_C6000
:/* R_C6000_NONE. */
10379 case EM_TILEGX
: /* R_TILEGX_NONE. */
10380 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10382 case EM_C166
: /* R_XC16X_NONE. */
10383 return reloc_type
== 0;
10385 return reloc_type
== 0 || reloc_type
== 256;
10386 case EM_XTENSA_OLD
:
10388 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10389 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10390 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10391 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10393 return reloc_type
== 3; /* R_METAG_NONE. */
10398 /* Apply relocations to a section.
10399 Note: So far support has been added only for those relocations
10400 which can be found in debug sections.
10401 FIXME: Add support for more relocations ? */
10404 apply_relocations (void * file
,
10405 Elf_Internal_Shdr
* section
,
10406 unsigned char * start
)
10408 Elf_Internal_Shdr
* relsec
;
10409 unsigned char * end
= start
+ section
->sh_size
;
10411 if (elf_header
.e_type
!= ET_REL
)
10414 /* Find the reloc section associated with the section. */
10415 for (relsec
= section_headers
;
10416 relsec
< section_headers
+ elf_header
.e_shnum
;
10419 bfd_boolean is_rela
;
10420 unsigned long num_relocs
;
10421 Elf_Internal_Rela
* relocs
;
10422 Elf_Internal_Rela
* rp
;
10423 Elf_Internal_Shdr
* symsec
;
10424 Elf_Internal_Sym
* symtab
;
10425 unsigned long num_syms
;
10426 Elf_Internal_Sym
* sym
;
10428 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10429 || relsec
->sh_info
>= elf_header
.e_shnum
10430 || section_headers
+ relsec
->sh_info
!= section
10431 || relsec
->sh_size
== 0
10432 || relsec
->sh_link
>= elf_header
.e_shnum
)
10435 is_rela
= relsec
->sh_type
== SHT_RELA
;
10439 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10440 relsec
->sh_size
, & relocs
, & num_relocs
))
10445 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10446 relsec
->sh_size
, & relocs
, & num_relocs
))
10450 /* SH uses RELA but uses in place value instead of the addend field. */
10451 if (elf_header
.e_machine
== EM_SH
)
10454 symsec
= section_headers
+ relsec
->sh_link
;
10455 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10457 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10460 unsigned int reloc_type
;
10461 unsigned int reloc_size
;
10462 unsigned char * rloc
;
10463 unsigned long sym_index
;
10465 reloc_type
= get_reloc_type (rp
->r_info
);
10467 if (target_specific_reloc_handling (rp
, start
, symtab
))
10469 else if (is_none_reloc (reloc_type
))
10471 else if (is_32bit_abs_reloc (reloc_type
)
10472 || is_32bit_pcrel_reloc (reloc_type
))
10474 else if (is_64bit_abs_reloc (reloc_type
)
10475 || is_64bit_pcrel_reloc (reloc_type
))
10477 else if (is_24bit_abs_reloc (reloc_type
))
10479 else if (is_16bit_abs_reloc (reloc_type
))
10483 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10484 reloc_type
, SECTION_NAME (section
));
10488 rloc
= start
+ rp
->r_offset
;
10489 if ((rloc
+ reloc_size
) > end
)
10491 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10492 (unsigned long) rp
->r_offset
,
10493 SECTION_NAME (section
));
10497 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10498 if (sym_index
>= num_syms
)
10500 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10501 sym_index
, SECTION_NAME (section
));
10504 sym
= symtab
+ sym_index
;
10506 /* If the reloc has a symbol associated with it,
10507 make sure that it is of an appropriate type.
10509 Relocations against symbols without type can happen.
10510 Gcc -feliminate-dwarf2-dups may generate symbols
10511 without type for debug info.
10513 Icc generates relocations against function symbols
10514 instead of local labels.
10516 Relocations against object symbols can happen, eg when
10517 referencing a global array. For an example of this see
10518 the _clz.o binary in libgcc.a. */
10520 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10522 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10523 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10524 (long int)(rp
- relocs
),
10525 SECTION_NAME (relsec
));
10531 addend
+= rp
->r_addend
;
10532 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10533 partial_inplace. */
10535 || (elf_header
.e_machine
== EM_XTENSA
10536 && reloc_type
== 1)
10537 || ((elf_header
.e_machine
== EM_PJ
10538 || elf_header
.e_machine
== EM_PJ_OLD
)
10539 && reloc_type
== 1)
10540 || ((elf_header
.e_machine
== EM_D30V
10541 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10542 && reloc_type
== 12))
10543 addend
+= byte_get (rloc
, reloc_size
);
10545 if (is_32bit_pcrel_reloc (reloc_type
)
10546 || is_64bit_pcrel_reloc (reloc_type
))
10548 /* On HPPA, all pc-relative relocations are biased by 8. */
10549 if (elf_header
.e_machine
== EM_PARISC
)
10551 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10555 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10564 #ifdef SUPPORT_DISASSEMBLY
10566 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10568 printf (_("\nAssembly dump of section %s\n"),
10569 SECTION_NAME (section
));
10571 /* XXX -- to be done --- XXX */
10577 /* Reads in the contents of SECTION from FILE, returning a pointer
10578 to a malloc'ed buffer or NULL if something went wrong. */
10581 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10583 bfd_size_type num_bytes
;
10585 num_bytes
= section
->sh_size
;
10587 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10589 printf (_("\nSection '%s' has no data to dump.\n"),
10590 SECTION_NAME (section
));
10594 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10595 _("section contents"));
10600 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10602 Elf_Internal_Shdr
* relsec
;
10603 bfd_size_type num_bytes
;
10607 char * name
= SECTION_NAME (section
);
10608 bfd_boolean some_strings_shown
;
10610 start
= get_section_contents (section
, file
);
10614 printf (_("\nString dump of section '%s':\n"), name
);
10616 /* If the section being dumped has relocations against it the user might
10617 be expecting these relocations to have been applied. Check for this
10618 case and issue a warning message in order to avoid confusion.
10619 FIXME: Maybe we ought to have an option that dumps a section with
10620 relocs applied ? */
10621 for (relsec
= section_headers
;
10622 relsec
< section_headers
+ elf_header
.e_shnum
;
10625 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10626 || relsec
->sh_info
>= elf_header
.e_shnum
10627 || section_headers
+ relsec
->sh_info
!= section
10628 || relsec
->sh_size
== 0
10629 || relsec
->sh_link
>= elf_header
.e_shnum
)
10632 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10636 num_bytes
= section
->sh_size
;
10638 end
= start
+ num_bytes
;
10639 some_strings_shown
= FALSE
;
10643 while (!ISPRINT (* data
))
10644 if (++ data
>= end
)
10650 /* PR 11128: Use two separate invocations in order to work
10651 around bugs in the Solaris 8 implementation of printf. */
10652 printf (" [%6tx] ", data
- start
);
10653 printf ("%s\n", data
);
10655 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10657 data
+= strlen (data
);
10658 some_strings_shown
= TRUE
;
10662 if (! some_strings_shown
)
10663 printf (_(" No strings found in this section."));
10671 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10673 bfd_boolean relocate
)
10675 Elf_Internal_Shdr
* relsec
;
10676 bfd_size_type bytes
;
10678 unsigned char * data
;
10679 unsigned char * start
;
10681 start
= (unsigned char *) get_section_contents (section
, file
);
10685 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10689 apply_relocations (file
, section
, start
);
10693 /* If the section being dumped has relocations against it the user might
10694 be expecting these relocations to have been applied. Check for this
10695 case and issue a warning message in order to avoid confusion.
10696 FIXME: Maybe we ought to have an option that dumps a section with
10697 relocs applied ? */
10698 for (relsec
= section_headers
;
10699 relsec
< section_headers
+ elf_header
.e_shnum
;
10702 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10703 || relsec
->sh_info
>= elf_header
.e_shnum
10704 || section_headers
+ relsec
->sh_info
!= section
10705 || relsec
->sh_size
== 0
10706 || relsec
->sh_link
>= elf_header
.e_shnum
)
10709 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10714 addr
= section
->sh_addr
;
10715 bytes
= section
->sh_size
;
10724 lbytes
= (bytes
> 16 ? 16 : bytes
);
10726 printf (" 0x%8.8lx ", (unsigned long) addr
);
10728 for (j
= 0; j
< 16; j
++)
10731 printf ("%2.2x", data
[j
]);
10739 for (j
= 0; j
< lbytes
; j
++)
10742 if (k
>= ' ' && k
< 0x7f)
10760 /* Uncompresses a section that was compressed using zlib, in place. */
10763 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10764 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10766 #ifndef HAVE_ZLIB_H
10769 dwarf_size_type compressed_size
= *size
;
10770 unsigned char * compressed_buffer
= *buffer
;
10771 dwarf_size_type uncompressed_size
;
10772 unsigned char * uncompressed_buffer
;
10775 dwarf_size_type header_size
= 12;
10777 /* Read the zlib header. In this case, it should be "ZLIB" followed
10778 by the uncompressed section size, 8 bytes in big-endian order. */
10779 if (compressed_size
< header_size
10780 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10783 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10784 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10785 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10786 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10787 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10788 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10789 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10790 uncompressed_size
+= compressed_buffer
[11];
10792 /* It is possible the section consists of several compressed
10793 buffers concatenated together, so we uncompress in a loop. */
10794 strm
.zalloc
= NULL
;
10796 strm
.opaque
= NULL
;
10797 strm
.avail_in
= compressed_size
- header_size
;
10798 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10799 strm
.avail_out
= uncompressed_size
;
10800 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10802 rc
= inflateInit (& strm
);
10803 while (strm
.avail_in
> 0)
10807 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10808 + (uncompressed_size
- strm
.avail_out
));
10809 rc
= inflate (&strm
, Z_FINISH
);
10810 if (rc
!= Z_STREAM_END
)
10812 rc
= inflateReset (& strm
);
10814 rc
= inflateEnd (& strm
);
10816 || strm
.avail_out
!= 0)
10819 free (compressed_buffer
);
10820 *buffer
= uncompressed_buffer
;
10821 *size
= uncompressed_size
;
10825 free (uncompressed_buffer
);
10826 /* Indicate decompression failure. */
10829 #endif /* HAVE_ZLIB_H */
10833 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10834 Elf_Internal_Shdr
* sec
, void * file
)
10836 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10839 /* If it is already loaded, do nothing. */
10840 if (section
->start
!= NULL
)
10843 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10844 section
->address
= sec
->sh_addr
;
10845 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10847 sec
->sh_size
, buf
);
10848 if (section
->start
== NULL
)
10852 section
->size
= sec
->sh_size
;
10853 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10854 sec
->sh_size
= section
->size
;
10857 if (section
->start
== NULL
)
10860 if (debug_displays
[debug
].relocate
)
10861 apply_relocations ((FILE *) file
, sec
, section
->start
);
10866 /* If this is not NULL, load_debug_section will only look for sections
10867 within the list of sections given here. */
10868 unsigned int *section_subset
= NULL
;
10871 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10873 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10874 Elf_Internal_Shdr
* sec
;
10876 /* Locate the debug section. */
10877 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10879 section
->name
= section
->uncompressed_name
;
10882 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10884 section
->name
= section
->compressed_name
;
10889 /* If we're loading from a subset of sections, and we've loaded
10890 a section matching this name before, it's likely that it's a
10892 if (section_subset
!= NULL
)
10893 free_debug_section (debug
);
10895 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10899 free_debug_section (enum dwarf_section_display_enum debug
)
10901 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10903 if (section
->start
== NULL
)
10906 free ((char *) section
->start
);
10907 section
->start
= NULL
;
10908 section
->address
= 0;
10913 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10915 char * name
= SECTION_NAME (section
);
10916 bfd_size_type length
;
10920 length
= section
->sh_size
;
10923 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10926 if (section
->sh_type
== SHT_NOBITS
)
10928 /* There is no point in dumping the contents of a debugging section
10929 which has the NOBITS type - the bits in the file will be random.
10930 This can happen when a file containing a .eh_frame section is
10931 stripped with the --only-keep-debug command line option. */
10932 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10936 if (const_strneq (name
, ".gnu.linkonce.wi."))
10937 name
= ".debug_info";
10939 /* See if we know how to display the contents of this section. */
10940 for (i
= 0; i
< max
; i
++)
10941 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10942 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10944 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10945 int secondary
= (section
!= find_section (name
));
10948 free_debug_section ((enum dwarf_section_display_enum
) i
);
10950 if (streq (sec
->uncompressed_name
, name
))
10951 sec
->name
= sec
->uncompressed_name
;
10953 sec
->name
= sec
->compressed_name
;
10954 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10957 /* If this debug section is part of a CU/TU set in a .dwp file,
10958 restrict load_debug_section to the sections in that set. */
10959 section_subset
= find_cu_tu_set (file
, shndx
);
10961 result
&= debug_displays
[i
].display (sec
, file
);
10963 section_subset
= NULL
;
10965 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10966 free_debug_section ((enum dwarf_section_display_enum
) i
);
10974 printf (_("Unrecognized debug section: %s\n"), name
);
10981 /* Set DUMP_SECTS for all sections where dumps were requested
10982 based on section name. */
10985 initialise_dumps_byname (void)
10987 struct dump_list_entry
* cur
;
10989 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10994 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10995 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10997 request_dump_bynumber (i
, cur
->type
);
11002 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11008 process_section_contents (FILE * file
)
11010 Elf_Internal_Shdr
* section
;
11016 initialise_dumps_byname ();
11018 for (i
= 0, section
= section_headers
;
11019 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11022 #ifdef SUPPORT_DISASSEMBLY
11023 if (dump_sects
[i
] & DISASS_DUMP
)
11024 disassemble_section (section
, file
);
11026 if (dump_sects
[i
] & HEX_DUMP
)
11027 dump_section_as_bytes (section
, file
, FALSE
);
11029 if (dump_sects
[i
] & RELOC_DUMP
)
11030 dump_section_as_bytes (section
, file
, TRUE
);
11032 if (dump_sects
[i
] & STRING_DUMP
)
11033 dump_section_as_strings (section
, file
);
11035 if (dump_sects
[i
] & DEBUG_DUMP
)
11036 display_debug_section (i
, section
, file
);
11039 /* Check to see if the user requested a
11040 dump of a section that does not exist. */
11041 while (i
++ < num_dump_sects
)
11043 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11047 process_mips_fpe_exception (int mask
)
11052 if (mask
& OEX_FPU_INEX
)
11053 fputs ("INEX", stdout
), first
= 0;
11054 if (mask
& OEX_FPU_UFLO
)
11055 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11056 if (mask
& OEX_FPU_OFLO
)
11057 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11058 if (mask
& OEX_FPU_DIV0
)
11059 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11060 if (mask
& OEX_FPU_INVAL
)
11061 printf ("%sINVAL", first
? "" : "|");
11064 fputs ("0", stdout
);
11067 /* ARM EABI attributes section. */
11072 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11074 const char ** table
;
11075 } arm_attr_public_tag
;
11077 static const char * arm_attr_tag_CPU_arch
[] =
11078 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11079 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11080 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11081 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11082 {"No", "Thumb-1", "Thumb-2"};
11083 static const char * arm_attr_tag_FP_arch
[] =
11084 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11086 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11087 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11088 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11089 static const char * arm_attr_tag_PCS_config
[] =
11090 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11091 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11092 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11093 {"V6", "SB", "TLS", "Unused"};
11094 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11095 {"Absolute", "PC-relative", "SB-relative", "None"};
11096 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11097 {"Absolute", "PC-relative", "None"};
11098 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11099 {"None", "direct", "GOT-indirect"};
11100 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11101 {"None", "??? 1", "2", "??? 3", "4"};
11102 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11103 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11104 {"Unused", "Needed", "Sign only"};
11105 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11106 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11107 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11108 {"Unused", "Finite", "RTABI", "IEEE 754"};
11109 static const char * arm_attr_tag_ABI_enum_size
[] =
11110 {"Unused", "small", "int", "forced to int"};
11111 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11112 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11113 static const char * arm_attr_tag_ABI_VFP_args
[] =
11114 {"AAPCS", "VFP registers", "custom"};
11115 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11116 {"AAPCS", "WMMX registers", "custom"};
11117 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11118 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11119 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11120 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11121 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11122 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11123 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11124 static const char * arm_attr_tag_FP_HP_extension
[] =
11125 {"Not Allowed", "Allowed"};
11126 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11127 {"None", "IEEE 754", "Alternative Format"};
11128 static const char * arm_attr_tag_MPextension_use
[] =
11129 {"Not Allowed", "Allowed"};
11130 static const char * arm_attr_tag_DIV_use
[] =
11131 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11132 "Allowed in v7-A with integer division extension"};
11133 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11134 static const char * arm_attr_tag_Virtualization_use
[] =
11135 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11136 "TrustZone and Virtualization Extensions"};
11137 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11138 {"Not Allowed", "Allowed"};
11140 #define LOOKUP(id, name) \
11141 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11142 static arm_attr_public_tag arm_attr_public_tags
[] =
11144 {4, "CPU_raw_name", 1, NULL
},
11145 {5, "CPU_name", 1, NULL
},
11146 LOOKUP(6, CPU_arch
),
11147 {7, "CPU_arch_profile", 0, NULL
},
11148 LOOKUP(8, ARM_ISA_use
),
11149 LOOKUP(9, THUMB_ISA_use
),
11150 LOOKUP(10, FP_arch
),
11151 LOOKUP(11, WMMX_arch
),
11152 LOOKUP(12, Advanced_SIMD_arch
),
11153 LOOKUP(13, PCS_config
),
11154 LOOKUP(14, ABI_PCS_R9_use
),
11155 LOOKUP(15, ABI_PCS_RW_data
),
11156 LOOKUP(16, ABI_PCS_RO_data
),
11157 LOOKUP(17, ABI_PCS_GOT_use
),
11158 LOOKUP(18, ABI_PCS_wchar_t
),
11159 LOOKUP(19, ABI_FP_rounding
),
11160 LOOKUP(20, ABI_FP_denormal
),
11161 LOOKUP(21, ABI_FP_exceptions
),
11162 LOOKUP(22, ABI_FP_user_exceptions
),
11163 LOOKUP(23, ABI_FP_number_model
),
11164 {24, "ABI_align_needed", 0, NULL
},
11165 {25, "ABI_align_preserved", 0, NULL
},
11166 LOOKUP(26, ABI_enum_size
),
11167 LOOKUP(27, ABI_HardFP_use
),
11168 LOOKUP(28, ABI_VFP_args
),
11169 LOOKUP(29, ABI_WMMX_args
),
11170 LOOKUP(30, ABI_optimization_goals
),
11171 LOOKUP(31, ABI_FP_optimization_goals
),
11172 {32, "compatibility", 0, NULL
},
11173 LOOKUP(34, CPU_unaligned_access
),
11174 LOOKUP(36, FP_HP_extension
),
11175 LOOKUP(38, ABI_FP_16bit_format
),
11176 LOOKUP(42, MPextension_use
),
11177 LOOKUP(44, DIV_use
),
11178 {64, "nodefaults", 0, NULL
},
11179 {65, "also_compatible_with", 0, NULL
},
11180 LOOKUP(66, T2EE_use
),
11181 {67, "conformance", 1, NULL
},
11182 LOOKUP(68, Virtualization_use
),
11183 LOOKUP(70, MPextension_use_legacy
)
11187 static unsigned char *
11188 display_arm_attribute (unsigned char * p
)
11193 arm_attr_public_tag
* attr
;
11197 tag
= read_uleb128 (p
, &len
);
11200 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11202 if (arm_attr_public_tags
[i
].tag
== tag
)
11204 attr
= &arm_attr_public_tags
[i
];
11211 printf (" Tag_%s: ", attr
->name
);
11212 switch (attr
->type
)
11217 case 7: /* Tag_CPU_arch_profile. */
11218 val
= read_uleb128 (p
, &len
);
11222 case 0: printf (_("None\n")); break;
11223 case 'A': printf (_("Application\n")); break;
11224 case 'R': printf (_("Realtime\n")); break;
11225 case 'M': printf (_("Microcontroller\n")); break;
11226 case 'S': printf (_("Application or Realtime\n")); break;
11227 default: printf ("??? (%d)\n", val
); break;
11231 case 24: /* Tag_align_needed. */
11232 val
= read_uleb128 (p
, &len
);
11236 case 0: printf (_("None\n")); break;
11237 case 1: printf (_("8-byte\n")); break;
11238 case 2: printf (_("4-byte\n")); break;
11239 case 3: printf ("??? 3\n"); break;
11242 printf (_("8-byte and up to %d-byte extended\n"),
11245 printf ("??? (%d)\n", val
);
11250 case 25: /* Tag_align_preserved. */
11251 val
= read_uleb128 (p
, &len
);
11255 case 0: printf (_("None\n")); break;
11256 case 1: printf (_("8-byte, except leaf SP\n")); break;
11257 case 2: printf (_("8-byte\n")); break;
11258 case 3: printf ("??? 3\n"); break;
11261 printf (_("8-byte and up to %d-byte extended\n"),
11264 printf ("??? (%d)\n", val
);
11269 case 32: /* Tag_compatibility. */
11270 val
= read_uleb128 (p
, &len
);
11272 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11273 p
+= strlen ((char *) p
) + 1;
11276 case 64: /* Tag_nodefaults. */
11278 printf (_("True\n"));
11281 case 65: /* Tag_also_compatible_with. */
11282 val
= read_uleb128 (p
, &len
);
11284 if (val
== 6 /* Tag_CPU_arch. */)
11286 val
= read_uleb128 (p
, &len
);
11288 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11289 printf ("??? (%d)\n", val
);
11291 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11295 while (*(p
++) != '\0' /* NUL terminator. */);
11309 assert (attr
->type
& 0x80);
11310 val
= read_uleb128 (p
, &len
);
11312 type
= attr
->type
& 0x7f;
11314 printf ("??? (%d)\n", val
);
11316 printf ("%s\n", attr
->table
[val
]);
11323 type
= 1; /* String. */
11325 type
= 2; /* uleb128. */
11326 printf (" Tag_unknown_%d: ", tag
);
11331 printf ("\"%s\"\n", p
);
11332 p
+= strlen ((char *) p
) + 1;
11336 val
= read_uleb128 (p
, &len
);
11338 printf ("%d (0x%x)\n", val
, val
);
11344 static unsigned char *
11345 display_gnu_attribute (unsigned char * p
,
11346 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11353 tag
= read_uleb128 (p
, &len
);
11356 /* Tag_compatibility is the only generic GNU attribute defined at
11360 val
= read_uleb128 (p
, &len
);
11362 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11363 p
+= strlen ((char *) p
) + 1;
11367 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11368 return display_proc_gnu_attribute (p
, tag
);
11371 type
= 1; /* String. */
11373 type
= 2; /* uleb128. */
11374 printf (" Tag_unknown_%d: ", tag
);
11378 printf ("\"%s\"\n", p
);
11379 p
+= strlen ((char *) p
) + 1;
11383 val
= read_uleb128 (p
, &len
);
11385 printf ("%d (0x%x)\n", val
, val
);
11391 static unsigned char *
11392 display_power_gnu_attribute (unsigned char * p
, int tag
)
11398 if (tag
== Tag_GNU_Power_ABI_FP
)
11400 val
= read_uleb128 (p
, &len
);
11402 printf (" Tag_GNU_Power_ABI_FP: ");
11407 printf (_("Hard or soft float\n"));
11410 printf (_("Hard float\n"));
11413 printf (_("Soft float\n"));
11416 printf (_("Single-precision hard float\n"));
11419 printf ("??? (%d)\n", val
);
11425 if (tag
== Tag_GNU_Power_ABI_Vector
)
11427 val
= read_uleb128 (p
, &len
);
11429 printf (" Tag_GNU_Power_ABI_Vector: ");
11433 printf (_("Any\n"));
11436 printf (_("Generic\n"));
11439 printf ("AltiVec\n");
11445 printf ("??? (%d)\n", val
);
11451 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11453 val
= read_uleb128 (p
, &len
);
11455 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11459 printf (_("Any\n"));
11462 printf ("r3/r4\n");
11465 printf (_("Memory\n"));
11468 printf ("??? (%d)\n", val
);
11475 type
= 1; /* String. */
11477 type
= 2; /* uleb128. */
11478 printf (" Tag_unknown_%d: ", tag
);
11482 printf ("\"%s\"\n", p
);
11483 p
+= strlen ((char *) p
) + 1;
11487 val
= read_uleb128 (p
, &len
);
11489 printf ("%d (0x%x)\n", val
, val
);
11496 display_sparc_hwcaps (int mask
)
11501 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11502 fputs ("mul32", stdout
), first
= 0;
11503 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11504 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11505 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11506 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11507 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11508 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11509 if (mask
& ELF_SPARC_HWCAP_POPC
)
11510 printf ("%spopc", first
? "" : "|"), first
= 0;
11511 if (mask
& ELF_SPARC_HWCAP_VIS
)
11512 printf ("%svis", first
? "" : "|"), first
= 0;
11513 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11514 printf ("%svis2", first
? "" : "|"), first
= 0;
11515 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11516 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11517 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11518 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11519 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11520 printf ("%svis3", first
? "" : "|"), first
= 0;
11521 if (mask
& ELF_SPARC_HWCAP_HPC
)
11522 printf ("%shpc", first
? "" : "|"), first
= 0;
11523 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11524 printf ("%srandom", first
? "" : "|"), first
= 0;
11525 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11526 printf ("%strans", first
? "" : "|"), first
= 0;
11527 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11528 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11529 if (mask
& ELF_SPARC_HWCAP_IMA
)
11530 printf ("%sima", first
? "" : "|"), first
= 0;
11531 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11532 printf ("%scspare", first
? "" : "|"), first
= 0;
11535 fputc('0', stdout
);
11536 fputc('\n', stdout
);
11539 static unsigned char *
11540 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11546 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11548 val
= read_uleb128 (p
, &len
);
11550 printf (" Tag_GNU_Sparc_HWCAPS: ");
11552 display_sparc_hwcaps (val
);
11557 type
= 1; /* String. */
11559 type
= 2; /* uleb128. */
11560 printf (" Tag_unknown_%d: ", tag
);
11564 printf ("\"%s\"\n", p
);
11565 p
+= strlen ((char *) p
) + 1;
11569 val
= read_uleb128 (p
, &len
);
11571 printf ("%d (0x%x)\n", val
, val
);
11577 static unsigned char *
11578 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11584 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11586 val
= read_uleb128 (p
, &len
);
11588 printf (" Tag_GNU_MIPS_ABI_FP: ");
11593 printf (_("Hard or soft float\n"));
11596 printf (_("Hard float (double precision)\n"));
11599 printf (_("Hard float (single precision)\n"));
11602 printf (_("Soft float\n"));
11605 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11608 printf ("??? (%d)\n", val
);
11615 type
= 1; /* String. */
11617 type
= 2; /* uleb128. */
11618 printf (" Tag_unknown_%d: ", tag
);
11622 printf ("\"%s\"\n", p
);
11623 p
+= strlen ((char *) p
) + 1;
11627 val
= read_uleb128 (p
, &len
);
11629 printf ("%d (0x%x)\n", val
, val
);
11635 static unsigned char *
11636 display_tic6x_attribute (unsigned char * p
)
11642 tag
= read_uleb128 (p
, &len
);
11648 val
= read_uleb128 (p
, &len
);
11650 printf (" Tag_ISA: ");
11654 case C6XABI_Tag_ISA_none
:
11655 printf (_("None\n"));
11657 case C6XABI_Tag_ISA_C62X
:
11660 case C6XABI_Tag_ISA_C67X
:
11663 case C6XABI_Tag_ISA_C67XP
:
11664 printf ("C67x+\n");
11666 case C6XABI_Tag_ISA_C64X
:
11669 case C6XABI_Tag_ISA_C64XP
:
11670 printf ("C64x+\n");
11672 case C6XABI_Tag_ISA_C674X
:
11673 printf ("C674x\n");
11676 printf ("??? (%d)\n", val
);
11681 case Tag_ABI_wchar_t
:
11682 val
= read_uleb128 (p
, &len
);
11684 printf (" Tag_ABI_wchar_t: ");
11688 printf (_("Not used\n"));
11691 printf (_("2 bytes\n"));
11694 printf (_("4 bytes\n"));
11697 printf ("??? (%d)\n", val
);
11702 case Tag_ABI_stack_align_needed
:
11703 val
= read_uleb128 (p
, &len
);
11705 printf (" Tag_ABI_stack_align_needed: ");
11709 printf (_("8-byte\n"));
11712 printf (_("16-byte\n"));
11715 printf ("??? (%d)\n", val
);
11720 case Tag_ABI_stack_align_preserved
:
11721 val
= read_uleb128 (p
, &len
);
11723 printf (" Tag_ABI_stack_align_preserved: ");
11727 printf (_("8-byte\n"));
11730 printf (_("16-byte\n"));
11733 printf ("??? (%d)\n", val
);
11739 val
= read_uleb128 (p
, &len
);
11741 printf (" Tag_ABI_DSBT: ");
11745 printf (_("DSBT addressing not used\n"));
11748 printf (_("DSBT addressing used\n"));
11751 printf ("??? (%d)\n", val
);
11757 val
= read_uleb128 (p
, &len
);
11759 printf (" Tag_ABI_PID: ");
11763 printf (_("Data addressing position-dependent\n"));
11766 printf (_("Data addressing position-independent, GOT near DP\n"));
11769 printf (_("Data addressing position-independent, GOT far from DP\n"));
11772 printf ("??? (%d)\n", val
);
11778 val
= read_uleb128 (p
, &len
);
11780 printf (" Tag_ABI_PIC: ");
11784 printf (_("Code addressing position-dependent\n"));
11787 printf (_("Code addressing position-independent\n"));
11790 printf ("??? (%d)\n", val
);
11795 case Tag_ABI_array_object_alignment
:
11796 val
= read_uleb128 (p
, &len
);
11798 printf (" Tag_ABI_array_object_alignment: ");
11802 printf (_("8-byte\n"));
11805 printf (_("4-byte\n"));
11808 printf (_("16-byte\n"));
11811 printf ("??? (%d)\n", val
);
11816 case Tag_ABI_array_object_align_expected
:
11817 val
= read_uleb128 (p
, &len
);
11819 printf (" Tag_ABI_array_object_align_expected: ");
11823 printf (_("8-byte\n"));
11826 printf (_("4-byte\n"));
11829 printf (_("16-byte\n"));
11832 printf ("??? (%d)\n", val
);
11837 case Tag_ABI_compatibility
:
11838 val
= read_uleb128 (p
, &len
);
11840 printf (" Tag_ABI_compatibility: ");
11841 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11842 p
+= strlen ((char *) p
) + 1;
11845 case Tag_ABI_conformance
:
11846 printf (" Tag_ABI_conformance: ");
11847 printf ("\"%s\"\n", p
);
11848 p
+= strlen ((char *) p
) + 1;
11852 printf (" Tag_unknown_%d: ", tag
);
11856 printf ("\"%s\"\n", p
);
11857 p
+= strlen ((char *) p
) + 1;
11861 val
= read_uleb128 (p
, &len
);
11863 printf ("%d (0x%x)\n", val
, val
);
11870 process_attributes (FILE * file
,
11871 const char * public_name
,
11872 unsigned int proc_type
,
11873 unsigned char * (* display_pub_attribute
) (unsigned char *),
11874 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11876 Elf_Internal_Shdr
* sect
;
11877 unsigned char * contents
;
11879 unsigned char * end
;
11880 bfd_vma section_len
;
11884 /* Find the section header so that we get the size. */
11885 for (i
= 0, sect
= section_headers
;
11886 i
< elf_header
.e_shnum
;
11889 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11892 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11893 sect
->sh_size
, _("attributes"));
11894 if (contents
== NULL
)
11900 len
= sect
->sh_size
- 1;
11906 bfd_boolean public_section
;
11907 bfd_boolean gnu_section
;
11909 section_len
= byte_get (p
, 4);
11912 if (section_len
> len
)
11914 printf (_("ERROR: Bad section length (%d > %d)\n"),
11915 (int) section_len
, (int) len
);
11919 len
-= section_len
;
11920 printf (_("Attribute Section: %s\n"), p
);
11922 if (public_name
&& streq ((char *) p
, public_name
))
11923 public_section
= TRUE
;
11925 public_section
= FALSE
;
11927 if (streq ((char *) p
, "gnu"))
11928 gnu_section
= TRUE
;
11930 gnu_section
= FALSE
;
11932 namelen
= strlen ((char *) p
) + 1;
11934 section_len
-= namelen
+ 4;
11936 while (section_len
> 0)
11942 size
= byte_get (p
, 4);
11943 if (size
> section_len
)
11945 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11946 (int) size
, (int) section_len
);
11947 size
= section_len
;
11950 section_len
-= size
;
11951 end
= p
+ size
- 1;
11957 printf (_("File Attributes\n"));
11960 printf (_("Section Attributes:"));
11963 printf (_("Symbol Attributes:"));
11969 val
= read_uleb128 (p
, &j
);
11973 printf (" %d", val
);
11978 printf (_("Unknown tag: %d\n"), tag
);
11979 public_section
= FALSE
;
11983 if (public_section
)
11986 p
= display_pub_attribute (p
);
11988 else if (gnu_section
)
11991 p
= display_gnu_attribute (p
,
11992 display_proc_gnu_attribute
);
11996 /* ??? Do something sensible, like dump hex. */
11997 printf (_(" Unknown section contexts\n"));
12004 printf (_("Unknown format '%c'\n"), *p
);
12012 process_arm_specific (FILE * file
)
12014 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12015 display_arm_attribute
, NULL
);
12019 process_power_specific (FILE * file
)
12021 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12022 display_power_gnu_attribute
);
12026 process_sparc_specific (FILE * file
)
12028 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12029 display_sparc_gnu_attribute
);
12033 process_tic6x_specific (FILE * file
)
12035 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12036 display_tic6x_attribute
, NULL
);
12039 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12040 Print the Address, Access and Initial fields of an entry at VMA ADDR
12041 and return the VMA of the next entry. */
12044 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12047 print_vma (addr
, LONG_HEX
);
12049 if (addr
< pltgot
+ 0xfff0)
12050 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12052 printf ("%10s", "");
12055 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12060 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12061 print_vma (entry
, LONG_HEX
);
12063 return addr
+ (is_32bit_elf
? 4 : 8);
12066 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12067 PLTGOT. Print the Address and Initial fields of an entry at VMA
12068 ADDR and return the VMA of the next entry. */
12071 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12074 print_vma (addr
, LONG_HEX
);
12077 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12082 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12083 print_vma (entry
, LONG_HEX
);
12085 return addr
+ (is_32bit_elf
? 4 : 8);
12089 process_mips_specific (FILE * file
)
12091 Elf_Internal_Dyn
* entry
;
12092 size_t liblist_offset
= 0;
12093 size_t liblistno
= 0;
12094 size_t conflictsno
= 0;
12095 size_t options_offset
= 0;
12096 size_t conflicts_offset
= 0;
12097 size_t pltrelsz
= 0;
12099 bfd_vma pltgot
= 0;
12100 bfd_vma mips_pltgot
= 0;
12101 bfd_vma jmprel
= 0;
12102 bfd_vma local_gotno
= 0;
12103 bfd_vma gotsym
= 0;
12104 bfd_vma symtabno
= 0;
12106 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12107 display_mips_gnu_attribute
);
12109 /* We have a lot of special sections. Thanks SGI! */
12110 if (dynamic_section
== NULL
)
12111 /* No information available. */
12114 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12115 switch (entry
->d_tag
)
12117 case DT_MIPS_LIBLIST
:
12119 = offset_from_vma (file
, entry
->d_un
.d_val
,
12120 liblistno
* sizeof (Elf32_External_Lib
));
12122 case DT_MIPS_LIBLISTNO
:
12123 liblistno
= entry
->d_un
.d_val
;
12125 case DT_MIPS_OPTIONS
:
12126 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12128 case DT_MIPS_CONFLICT
:
12130 = offset_from_vma (file
, entry
->d_un
.d_val
,
12131 conflictsno
* sizeof (Elf32_External_Conflict
));
12133 case DT_MIPS_CONFLICTNO
:
12134 conflictsno
= entry
->d_un
.d_val
;
12137 pltgot
= entry
->d_un
.d_ptr
;
12139 case DT_MIPS_LOCAL_GOTNO
:
12140 local_gotno
= entry
->d_un
.d_val
;
12142 case DT_MIPS_GOTSYM
:
12143 gotsym
= entry
->d_un
.d_val
;
12145 case DT_MIPS_SYMTABNO
:
12146 symtabno
= entry
->d_un
.d_val
;
12148 case DT_MIPS_PLTGOT
:
12149 mips_pltgot
= entry
->d_un
.d_ptr
;
12152 pltrel
= entry
->d_un
.d_val
;
12155 pltrelsz
= entry
->d_un
.d_val
;
12158 jmprel
= entry
->d_un
.d_ptr
;
12164 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12166 Elf32_External_Lib
* elib
;
12169 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12171 sizeof (Elf32_External_Lib
),
12172 _("liblist section data"));
12175 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12176 (unsigned long) liblistno
);
12177 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12180 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12187 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12188 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12189 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12190 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12191 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12193 tmp
= gmtime (&atime
);
12194 snprintf (timebuf
, sizeof (timebuf
),
12195 "%04u-%02u-%02uT%02u:%02u:%02u",
12196 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12197 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12199 printf ("%3lu: ", (unsigned long) cnt
);
12200 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12201 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12203 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12204 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12205 liblist
.l_version
);
12207 if (liblist
.l_flags
== 0)
12211 static const struct
12218 { " EXACT_MATCH", LL_EXACT_MATCH
},
12219 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12220 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12221 { " EXPORTS", LL_EXPORTS
},
12222 { " DELAY_LOAD", LL_DELAY_LOAD
},
12223 { " DELTA", LL_DELTA
}
12225 int flags
= liblist
.l_flags
;
12228 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12229 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12231 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12232 flags
^= l_flags_vals
[fcnt
].bit
;
12235 printf (" %#x", (unsigned int) flags
);
12245 if (options_offset
!= 0)
12247 Elf_External_Options
* eopt
;
12248 Elf_Internal_Shdr
* sect
= section_headers
;
12249 Elf_Internal_Options
* iopt
;
12250 Elf_Internal_Options
* option
;
12254 /* Find the section header so that we get the size. */
12255 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12258 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12259 sect
->sh_size
, _("options"));
12262 iopt
= (Elf_Internal_Options
*)
12263 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12266 error (_("Out of memory\n"));
12273 while (offset
< sect
->sh_size
)
12275 Elf_External_Options
* eoption
;
12277 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12279 option
->kind
= BYTE_GET (eoption
->kind
);
12280 option
->size
= BYTE_GET (eoption
->size
);
12281 option
->section
= BYTE_GET (eoption
->section
);
12282 option
->info
= BYTE_GET (eoption
->info
);
12284 offset
+= option
->size
;
12290 printf (_("\nSection '%s' contains %d entries:\n"),
12291 SECTION_NAME (sect
), cnt
);
12299 switch (option
->kind
)
12302 /* This shouldn't happen. */
12303 printf (" NULL %d %lx", option
->section
, option
->info
);
12306 printf (" REGINFO ");
12307 if (elf_header
.e_machine
== EM_MIPS
)
12310 Elf32_External_RegInfo
* ereg
;
12311 Elf32_RegInfo reginfo
;
12313 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12314 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12315 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12316 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12317 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12318 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12319 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12321 printf ("GPR %08lx GP 0x%lx\n",
12322 reginfo
.ri_gprmask
,
12323 (unsigned long) reginfo
.ri_gp_value
);
12324 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12325 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12326 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12331 Elf64_External_RegInfo
* ereg
;
12332 Elf64_Internal_RegInfo reginfo
;
12334 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12335 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12336 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12337 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12338 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12339 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12340 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12342 printf ("GPR %08lx GP 0x",
12343 reginfo
.ri_gprmask
);
12344 printf_vma (reginfo
.ri_gp_value
);
12347 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12348 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12349 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12353 case ODK_EXCEPTIONS
:
12354 fputs (" EXCEPTIONS fpe_min(", stdout
);
12355 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12356 fputs (") fpe_max(", stdout
);
12357 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12358 fputs (")", stdout
);
12360 if (option
->info
& OEX_PAGE0
)
12361 fputs (" PAGE0", stdout
);
12362 if (option
->info
& OEX_SMM
)
12363 fputs (" SMM", stdout
);
12364 if (option
->info
& OEX_FPDBUG
)
12365 fputs (" FPDBUG", stdout
);
12366 if (option
->info
& OEX_DISMISS
)
12367 fputs (" DISMISS", stdout
);
12370 fputs (" PAD ", stdout
);
12371 if (option
->info
& OPAD_PREFIX
)
12372 fputs (" PREFIX", stdout
);
12373 if (option
->info
& OPAD_POSTFIX
)
12374 fputs (" POSTFIX", stdout
);
12375 if (option
->info
& OPAD_SYMBOL
)
12376 fputs (" SYMBOL", stdout
);
12379 fputs (" HWPATCH ", stdout
);
12380 if (option
->info
& OHW_R4KEOP
)
12381 fputs (" R4KEOP", stdout
);
12382 if (option
->info
& OHW_R8KPFETCH
)
12383 fputs (" R8KPFETCH", stdout
);
12384 if (option
->info
& OHW_R5KEOP
)
12385 fputs (" R5KEOP", stdout
);
12386 if (option
->info
& OHW_R5KCVTL
)
12387 fputs (" R5KCVTL", stdout
);
12390 fputs (" FILL ", stdout
);
12391 /* XXX Print content of info word? */
12394 fputs (" TAGS ", stdout
);
12395 /* XXX Print content of info word? */
12398 fputs (" HWAND ", stdout
);
12399 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12400 fputs (" R4KEOP_CHECKED", stdout
);
12401 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12402 fputs (" R4KEOP_CLEAN", stdout
);
12405 fputs (" HWOR ", stdout
);
12406 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12407 fputs (" R4KEOP_CHECKED", stdout
);
12408 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12409 fputs (" R4KEOP_CLEAN", stdout
);
12412 printf (" GP_GROUP %#06lx self-contained %#06lx",
12413 option
->info
& OGP_GROUP
,
12414 (option
->info
& OGP_SELF
) >> 16);
12417 printf (" IDENT %#06lx self-contained %#06lx",
12418 option
->info
& OGP_GROUP
,
12419 (option
->info
& OGP_SELF
) >> 16);
12422 /* This shouldn't happen. */
12423 printf (" %3d ??? %d %lx",
12424 option
->kind
, option
->section
, option
->info
);
12428 len
= sizeof (* eopt
);
12429 while (len
< option
->size
)
12430 if (((char *) option
)[len
] >= ' '
12431 && ((char *) option
)[len
] < 0x7f)
12432 printf ("%c", ((char *) option
)[len
++]);
12434 printf ("\\%03o", ((char *) option
)[len
++]);
12436 fputs ("\n", stdout
);
12444 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12446 Elf32_Conflict
* iconf
;
12449 if (dynamic_symbols
== NULL
)
12451 error (_("conflict list found without a dynamic symbol table\n"));
12455 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12458 error (_("Out of memory\n"));
12464 Elf32_External_Conflict
* econf32
;
12466 econf32
= (Elf32_External_Conflict
*)
12467 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12468 sizeof (* econf32
), _("conflict"));
12472 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12473 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12479 Elf64_External_Conflict
* econf64
;
12481 econf64
= (Elf64_External_Conflict
*)
12482 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12483 sizeof (* econf64
), _("conflict"));
12487 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12488 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12493 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12494 (unsigned long) conflictsno
);
12495 puts (_(" Num: Index Value Name"));
12497 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12499 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12501 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12502 print_vma (psym
->st_value
, FULL_HEX
);
12504 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12505 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12507 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12514 if (pltgot
!= 0 && local_gotno
!= 0)
12516 bfd_vma ent
, local_end
, global_end
;
12518 unsigned char * data
;
12522 addr_size
= (is_32bit_elf
? 4 : 8);
12523 local_end
= pltgot
+ local_gotno
* addr_size
;
12524 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12526 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12527 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12528 global_end
- pltgot
, 1,
12529 _("Global Offset Table data"));
12533 printf (_("\nPrimary GOT:\n"));
12534 printf (_(" Canonical gp value: "));
12535 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12538 printf (_(" Reserved entries:\n"));
12539 printf (_(" %*s %10s %*s Purpose\n"),
12540 addr_size
* 2, _("Address"), _("Access"),
12541 addr_size
* 2, _("Initial"));
12542 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12543 printf (_(" Lazy resolver\n"));
12545 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12546 >> (addr_size
* 8 - 1)) != 0)
12548 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12549 printf (_(" Module pointer (GNU extension)\n"));
12553 if (ent
< local_end
)
12555 printf (_(" Local entries:\n"));
12556 printf (" %*s %10s %*s\n",
12557 addr_size
* 2, _("Address"), _("Access"),
12558 addr_size
* 2, _("Initial"));
12559 while (ent
< local_end
)
12561 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12567 if (gotsym
< symtabno
)
12571 printf (_(" Global entries:\n"));
12572 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12573 addr_size
* 2, _("Address"),
12575 addr_size
* 2, _("Initial"),
12576 addr_size
* 2, _("Sym.Val."),
12578 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12579 _("Ndx"), _("Name"));
12581 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12582 for (i
= gotsym
; i
< symtabno
; i
++)
12584 Elf_Internal_Sym
* psym
;
12586 psym
= dynamic_symbols
+ i
;
12587 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12589 print_vma (psym
->st_value
, LONG_HEX
);
12590 printf (" %-7s %3s ",
12591 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12592 get_symbol_index_type (psym
->st_shndx
));
12593 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12594 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12596 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12606 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12609 size_t offset
, rel_offset
;
12610 unsigned long count
, i
;
12611 unsigned char * data
;
12612 int addr_size
, sym_width
;
12613 Elf_Internal_Rela
* rels
;
12615 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12616 if (pltrel
== DT_RELA
)
12618 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12623 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12628 addr_size
= (is_32bit_elf
? 4 : 8);
12629 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12631 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12632 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12633 1, _("Procedure Linkage Table data"));
12637 printf ("\nPLT GOT:\n\n");
12638 printf (_(" Reserved entries:\n"));
12639 printf (_(" %*s %*s Purpose\n"),
12640 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12641 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12642 printf (_(" PLT lazy resolver\n"));
12643 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12644 printf (_(" Module pointer\n"));
12647 printf (_(" Entries:\n"));
12648 printf (" %*s %*s %*s %-7s %3s %s\n",
12649 addr_size
* 2, _("Address"),
12650 addr_size
* 2, _("Initial"),
12651 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12652 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12653 for (i
= 0; i
< count
; i
++)
12655 Elf_Internal_Sym
* psym
;
12657 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12658 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12660 print_vma (psym
->st_value
, LONG_HEX
);
12661 printf (" %-7s %3s ",
12662 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12663 get_symbol_index_type (psym
->st_shndx
));
12664 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12665 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12667 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12681 process_gnu_liblist (FILE * file
)
12683 Elf_Internal_Shdr
* section
;
12684 Elf_Internal_Shdr
* string_sec
;
12685 Elf32_External_Lib
* elib
;
12687 size_t strtab_size
;
12694 for (i
= 0, section
= section_headers
;
12695 i
< elf_header
.e_shnum
;
12698 switch (section
->sh_type
)
12700 case SHT_GNU_LIBLIST
:
12701 if (section
->sh_link
>= elf_header
.e_shnum
)
12704 elib
= (Elf32_External_Lib
*)
12705 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12706 _("liblist section data"));
12710 string_sec
= section_headers
+ section
->sh_link
;
12712 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12713 string_sec
->sh_size
,
12714 _("liblist string table"));
12716 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12722 strtab_size
= string_sec
->sh_size
;
12724 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12725 SECTION_NAME (section
),
12726 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12728 puts (_(" Library Time Stamp Checksum Version Flags"));
12730 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12738 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12739 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12740 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12741 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12742 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12744 tmp
= gmtime (&atime
);
12745 snprintf (timebuf
, sizeof (timebuf
),
12746 "%04u-%02u-%02uT%02u:%02u:%02u",
12747 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12748 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12750 printf ("%3lu: ", (unsigned long) cnt
);
12752 printf ("%-20s", liblist
.l_name
< strtab_size
12753 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12755 printf ("%-20.20s", liblist
.l_name
< strtab_size
12756 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12757 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12758 liblist
.l_version
, liblist
.l_flags
);
12769 static const char *
12770 get_note_type (unsigned e_type
)
12772 static char buff
[64];
12774 if (elf_header
.e_type
== ET_CORE
)
12778 return _("NT_AUXV (auxiliary vector)");
12780 return _("NT_PRSTATUS (prstatus structure)");
12782 return _("NT_FPREGSET (floating point registers)");
12784 return _("NT_PRPSINFO (prpsinfo structure)");
12785 case NT_TASKSTRUCT
:
12786 return _("NT_TASKSTRUCT (task structure)");
12788 return _("NT_PRXFPREG (user_xfpregs structure)");
12790 return _("NT_PPC_VMX (ppc Altivec registers)");
12792 return _("NT_PPC_VSX (ppc VSX registers)");
12794 return _("NT_386_TLS (x86 TLS information)");
12795 case NT_386_IOPERM
:
12796 return _("NT_386_IOPERM (x86 I/O permissions)");
12797 case NT_X86_XSTATE
:
12798 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12799 case NT_S390_HIGH_GPRS
:
12800 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12801 case NT_S390_TIMER
:
12802 return _("NT_S390_TIMER (s390 timer register)");
12803 case NT_S390_TODCMP
:
12804 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12805 case NT_S390_TODPREG
:
12806 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12808 return _("NT_S390_CTRS (s390 control registers)");
12809 case NT_S390_PREFIX
:
12810 return _("NT_S390_PREFIX (s390 prefix register)");
12811 case NT_S390_LAST_BREAK
:
12812 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12813 case NT_S390_SYSTEM_CALL
:
12814 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12816 return _("NT_ARM_VFP (arm VFP registers)");
12818 return _("NT_ARM_TLS (AArch TLS registers)");
12819 case NT_ARM_HW_BREAK
:
12820 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12821 case NT_ARM_HW_WATCH
:
12822 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12824 return _("NT_PSTATUS (pstatus structure)");
12826 return _("NT_FPREGS (floating point registers)");
12828 return _("NT_PSINFO (psinfo structure)");
12830 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12832 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12833 case NT_WIN32PSTATUS
:
12834 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12836 return _("NT_SIGINFO (siginfo_t data)");
12838 return _("NT_FILE (mapped files)");
12846 return _("NT_VERSION (version)");
12848 return _("NT_ARCH (architecture)");
12853 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12858 print_core_note (Elf_Internal_Note
*pnote
)
12860 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12861 bfd_vma count
, page_size
;
12862 unsigned char *descdata
, *filenames
, *descend
;
12864 if (pnote
->type
!= NT_FILE
)
12870 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12871 /* Still "successful". */
12876 if (pnote
->descsz
< 2 * addr_size
)
12878 printf (_(" Malformed note - too short for header\n"));
12882 descdata
= (unsigned char *) pnote
->descdata
;
12883 descend
= descdata
+ pnote
->descsz
;
12885 if (descdata
[pnote
->descsz
- 1] != '\0')
12887 printf (_(" Malformed note - does not end with \\0\n"));
12891 count
= byte_get (descdata
, addr_size
);
12892 descdata
+= addr_size
;
12894 page_size
= byte_get (descdata
, addr_size
);
12895 descdata
+= addr_size
;
12897 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12899 printf (_(" Malformed note - too short for supplied file count\n"));
12903 printf (_(" Page size: "));
12904 print_vma (page_size
, DEC
);
12907 printf (_(" %*s%*s%*s\n"),
12908 (int) (2 + 2 * addr_size
), _("Start"),
12909 (int) (4 + 2 * addr_size
), _("End"),
12910 (int) (4 + 2 * addr_size
), _("Page Offset"));
12911 filenames
= descdata
+ count
* 3 * addr_size
;
12912 while (--count
> 0)
12914 bfd_vma start
, end
, file_ofs
;
12916 if (filenames
== descend
)
12918 printf (_(" Malformed note - filenames end too early\n"));
12922 start
= byte_get (descdata
, addr_size
);
12923 descdata
+= addr_size
;
12924 end
= byte_get (descdata
, addr_size
);
12925 descdata
+= addr_size
;
12926 file_ofs
= byte_get (descdata
, addr_size
);
12927 descdata
+= addr_size
;
12930 print_vma (start
, FULL_HEX
);
12932 print_vma (end
, FULL_HEX
);
12934 print_vma (file_ofs
, FULL_HEX
);
12935 printf ("\n %s\n", filenames
);
12937 filenames
+= 1 + strlen ((char *) filenames
);
12943 static const char *
12944 get_gnu_elf_note_type (unsigned e_type
)
12946 static char buff
[64];
12950 case NT_GNU_ABI_TAG
:
12951 return _("NT_GNU_ABI_TAG (ABI version tag)");
12953 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12954 case NT_GNU_BUILD_ID
:
12955 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12956 case NT_GNU_GOLD_VERSION
:
12957 return _("NT_GNU_GOLD_VERSION (gold version)");
12962 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12967 print_gnu_note (Elf_Internal_Note
*pnote
)
12969 switch (pnote
->type
)
12971 case NT_GNU_BUILD_ID
:
12975 printf (_(" Build ID: "));
12976 for (i
= 0; i
< pnote
->descsz
; ++i
)
12977 printf ("%02x", pnote
->descdata
[i
] & 0xff);
12982 case NT_GNU_ABI_TAG
:
12984 unsigned long os
, major
, minor
, subminor
;
12985 const char *osname
;
12987 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
12988 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
12989 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
12990 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
12994 case GNU_ABI_TAG_LINUX
:
12997 case GNU_ABI_TAG_HURD
:
13000 case GNU_ABI_TAG_SOLARIS
:
13001 osname
= "Solaris";
13003 case GNU_ABI_TAG_FREEBSD
:
13004 osname
= "FreeBSD";
13006 case GNU_ABI_TAG_NETBSD
:
13010 osname
= "Unknown";
13014 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13015 major
, minor
, subminor
);
13023 static const char *
13024 get_netbsd_elfcore_note_type (unsigned e_type
)
13026 static char buff
[64];
13028 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13030 /* NetBSD core "procinfo" structure. */
13031 return _("NetBSD procinfo structure");
13034 /* As of Jan 2002 there are no other machine-independent notes
13035 defined for NetBSD core files. If the note type is less
13036 than the start of the machine-dependent note types, we don't
13039 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13041 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13045 switch (elf_header
.e_machine
)
13047 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13048 and PT_GETFPREGS == mach+2. */
13053 case EM_SPARC32PLUS
:
13057 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13058 return _("PT_GETREGS (reg structure)");
13059 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13060 return _("PT_GETFPREGS (fpreg structure)");
13066 /* On all other arch's, PT_GETREGS == mach+1 and
13067 PT_GETFPREGS == mach+3. */
13071 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13072 return _("PT_GETREGS (reg structure)");
13073 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13074 return _("PT_GETFPREGS (fpreg structure)");
13080 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13081 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13085 static const char *
13086 get_stapsdt_note_type (unsigned e_type
)
13088 static char buff
[64];
13093 return _("NT_STAPSDT (SystemTap probe descriptors)");
13099 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13104 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13106 int addr_size
= is_32bit_elf
? 4 : 8;
13107 char *data
= pnote
->descdata
;
13108 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13109 bfd_vma pc
, base_addr
, semaphore
;
13110 char *provider
, *probe
, *arg_fmt
;
13112 pc
= byte_get ((unsigned char *) data
, addr_size
);
13114 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13116 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13120 data
+= strlen (data
) + 1;
13122 data
+= strlen (data
) + 1;
13124 data
+= strlen (data
) + 1;
13126 printf (_(" Provider: %s\n"), provider
);
13127 printf (_(" Name: %s\n"), probe
);
13128 printf (_(" Location: "));
13129 print_vma (pc
, FULL_HEX
);
13130 printf (_(", Base: "));
13131 print_vma (base_addr
, FULL_HEX
);
13132 printf (_(", Semaphore: "));
13133 print_vma (semaphore
, FULL_HEX
);
13135 printf (_(" Arguments: %s\n"), arg_fmt
);
13137 return data
== data_end
;
13140 static const char *
13141 get_ia64_vms_note_type (unsigned e_type
)
13143 static char buff
[64];
13148 return _("NT_VMS_MHD (module header)");
13150 return _("NT_VMS_LNM (language name)");
13152 return _("NT_VMS_SRC (source files)");
13154 return "NT_VMS_TITLE";
13156 return _("NT_VMS_EIDC (consistency check)");
13157 case NT_VMS_FPMODE
:
13158 return _("NT_VMS_FPMODE (FP mode)");
13159 case NT_VMS_LINKTIME
:
13160 return "NT_VMS_LINKTIME";
13161 case NT_VMS_IMGNAM
:
13162 return _("NT_VMS_IMGNAM (image name)");
13164 return _("NT_VMS_IMGID (image id)");
13165 case NT_VMS_LINKID
:
13166 return _("NT_VMS_LINKID (link id)");
13167 case NT_VMS_IMGBID
:
13168 return _("NT_VMS_IMGBID (build id)");
13169 case NT_VMS_GSTNAM
:
13170 return _("NT_VMS_GSTNAM (sym table name)");
13171 case NT_VMS_ORIG_DYN
:
13172 return "NT_VMS_ORIG_DYN";
13173 case NT_VMS_PATCHTIME
:
13174 return "NT_VMS_PATCHTIME";
13176 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13182 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13184 switch (pnote
->type
)
13187 if (pnote
->descsz
> 36)
13189 size_t l
= strlen (pnote
->descdata
+ 34);
13190 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13191 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13192 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13193 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13196 printf (_(" Invalid size\n"));
13199 printf (_(" Language: %s\n"), pnote
->descdata
);
13202 case NT_VMS_FPMODE
:
13203 printf (_(" Floating Point mode: "));
13204 printf ("0x%016" BFD_VMA_FMT
"x\n",
13205 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13207 case NT_VMS_LINKTIME
:
13208 printf (_(" Link time: "));
13210 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13213 case NT_VMS_PATCHTIME
:
13214 printf (_(" Patch time: "));
13216 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13219 case NT_VMS_ORIG_DYN
:
13220 printf (_(" Major id: %u, minor id: %u\n"),
13221 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13222 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13223 printf (_(" Last modified : "));
13225 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13226 printf (_("\n Link flags : "));
13227 printf ("0x%016" BFD_VMA_FMT
"x\n",
13228 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13229 printf (_(" Header flags: 0x%08x\n"),
13230 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13231 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13234 case NT_VMS_IMGNAM
:
13235 printf (_(" Image name: %s\n"), pnote
->descdata
);
13237 case NT_VMS_GSTNAM
:
13238 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13241 printf (_(" Image id: %s\n"), pnote
->descdata
);
13243 case NT_VMS_LINKID
:
13244 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13252 /* Note that by the ELF standard, the name field is already null byte
13253 terminated, and namesz includes the terminating null byte.
13254 I.E. the value of namesz for the name "FSF" is 4.
13256 If the value of namesz is zero, there is no name present. */
13258 process_note (Elf_Internal_Note
* pnote
)
13260 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13263 if (pnote
->namesz
== 0)
13264 /* If there is no note name, then use the default set of
13265 note type strings. */
13266 nt
= get_note_type (pnote
->type
);
13268 else if (const_strneq (pnote
->namedata
, "GNU"))
13269 /* GNU-specific object file notes. */
13270 nt
= get_gnu_elf_note_type (pnote
->type
);
13272 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13273 /* NetBSD-specific core file notes. */
13274 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13276 else if (strneq (pnote
->namedata
, "SPU/", 4))
13278 /* SPU-specific core file notes. */
13279 nt
= pnote
->namedata
+ 4;
13283 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13284 /* VMS/ia64-specific file notes. */
13285 nt
= get_ia64_vms_note_type (pnote
->type
);
13287 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13288 nt
= get_stapsdt_note_type (pnote
->type
);
13291 /* Don't recognize this note name; just use the default set of
13292 note type strings. */
13293 nt
= get_note_type (pnote
->type
);
13295 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13297 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13298 return print_ia64_vms_note (pnote
);
13299 else if (const_strneq (pnote
->namedata
, "GNU"))
13300 return print_gnu_note (pnote
);
13301 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13302 return print_stapsdt_note (pnote
);
13303 else if (const_strneq (pnote
->namedata
, "CORE"))
13304 return print_core_note (pnote
);
13311 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13313 Elf_External_Note
* pnotes
;
13314 Elf_External_Note
* external
;
13320 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13322 if (pnotes
== NULL
)
13327 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13328 (unsigned long) offset
, (unsigned long) length
);
13329 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13331 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13333 Elf_External_Note
* next
;
13334 Elf_Internal_Note inote
;
13335 char * temp
= NULL
;
13337 if (!is_ia64_vms ())
13339 inote
.type
= BYTE_GET (external
->type
);
13340 inote
.namesz
= BYTE_GET (external
->namesz
);
13341 inote
.namedata
= external
->name
;
13342 inote
.descsz
= BYTE_GET (external
->descsz
);
13343 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13344 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13346 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13350 Elf64_External_VMS_Note
*vms_external
;
13352 vms_external
= (Elf64_External_VMS_Note
*)external
;
13353 inote
.type
= BYTE_GET (vms_external
->type
);
13354 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13355 inote
.namedata
= vms_external
->name
;
13356 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13357 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13358 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13360 next
= (Elf_External_Note
*)
13361 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13364 if ( ((char *) next
> ((char *) pnotes
) + length
)
13365 || ((char *) next
< (char *) pnotes
))
13367 warn (_("corrupt note found at offset %lx into core notes\n"),
13368 (unsigned long) ((char *) external
- (char *) pnotes
));
13369 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13370 inote
.type
, inote
.namesz
, inote
.descsz
);
13376 /* Prevent out-of-bounds indexing. */
13377 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13378 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13380 warn (_("corrupt note found at offset %lx into core notes\n"),
13381 (unsigned long) ((char *) external
- (char *) pnotes
));
13382 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13383 inote
.type
, inote
.namesz
, inote
.descsz
);
13387 /* Verify that name is null terminated. It appears that at least
13388 one version of Linux (RedHat 6.0) generates corefiles that don't
13389 comply with the ELF spec by failing to include the null byte in
13391 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13393 temp
= (char *) malloc (inote
.namesz
+ 1);
13397 error (_("Out of memory\n"));
13402 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13403 temp
[inote
.namesz
] = 0;
13405 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13406 inote
.namedata
= temp
;
13409 res
&= process_note (& inote
);
13424 process_corefile_note_segments (FILE * file
)
13426 Elf_Internal_Phdr
* segment
;
13430 if (! get_program_headers (file
))
13433 for (i
= 0, segment
= program_headers
;
13434 i
< elf_header
.e_phnum
;
13437 if (segment
->p_type
== PT_NOTE
)
13438 res
&= process_corefile_note_segment (file
,
13439 (bfd_vma
) segment
->p_offset
,
13440 (bfd_vma
) segment
->p_filesz
);
13447 process_note_sections (FILE * file
)
13449 Elf_Internal_Shdr
* section
;
13453 for (i
= 0, section
= section_headers
;
13454 i
< elf_header
.e_shnum
&& section
!= NULL
;
13456 if (section
->sh_type
== SHT_NOTE
)
13457 res
&= process_corefile_note_segment (file
,
13458 (bfd_vma
) section
->sh_offset
,
13459 (bfd_vma
) section
->sh_size
);
13465 process_notes (FILE * file
)
13467 /* If we have not been asked to display the notes then do nothing. */
13471 if (elf_header
.e_type
!= ET_CORE
)
13472 return process_note_sections (file
);
13474 /* No program headers means no NOTE segment. */
13475 if (elf_header
.e_phnum
> 0)
13476 return process_corefile_note_segments (file
);
13478 printf (_("No note segments present in the core file.\n"));
13483 process_arch_specific (FILE * file
)
13488 switch (elf_header
.e_machine
)
13491 return process_arm_specific (file
);
13493 case EM_MIPS_RS3_LE
:
13494 return process_mips_specific (file
);
13497 return process_power_specific (file
);
13500 case EM_SPARC32PLUS
:
13502 return process_sparc_specific (file
);
13505 return process_tic6x_specific (file
);
13514 get_file_header (FILE * file
)
13516 /* Read in the identity array. */
13517 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13520 /* Determine how to read the rest of the header. */
13521 switch (elf_header
.e_ident
[EI_DATA
])
13523 default: /* fall through */
13524 case ELFDATANONE
: /* fall through */
13526 byte_get
= byte_get_little_endian
;
13527 byte_put
= byte_put_little_endian
;
13530 byte_get
= byte_get_big_endian
;
13531 byte_put
= byte_put_big_endian
;
13535 /* For now we only support 32 bit and 64 bit ELF files. */
13536 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13538 /* Read in the rest of the header. */
13541 Elf32_External_Ehdr ehdr32
;
13543 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13546 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13547 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13548 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13549 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13550 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13551 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13552 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13553 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13554 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13555 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13556 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13557 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13558 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13562 Elf64_External_Ehdr ehdr64
;
13564 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13565 we will not be able to cope with the 64bit data found in
13566 64 ELF files. Detect this now and abort before we start
13567 overwriting things. */
13568 if (sizeof (bfd_vma
) < 8)
13570 error (_("This instance of readelf has been built without support for a\n\
13571 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13575 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13578 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13579 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13580 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13581 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13582 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13583 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13584 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13585 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13586 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13587 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13588 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13589 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13590 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13593 if (elf_header
.e_shoff
)
13595 /* There may be some extensions in the first section header. Don't
13596 bomb if we can't read it. */
13598 get_32bit_section_headers (file
, 1);
13600 get_64bit_section_headers (file
, 1);
13606 /* Process one ELF object file according to the command line options.
13607 This file may actually be stored in an archive. The file is
13608 positioned at the start of the ELF object. */
13611 process_object (char * file_name
, FILE * file
)
13615 if (! get_file_header (file
))
13617 error (_("%s: Failed to read file header\n"), file_name
);
13621 /* Initialise per file variables. */
13622 for (i
= ARRAY_SIZE (version_info
); i
--;)
13623 version_info
[i
] = 0;
13625 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13626 dynamic_info
[i
] = 0;
13627 dynamic_info_DT_GNU_HASH
= 0;
13629 /* Process the file. */
13631 printf (_("\nFile: %s\n"), file_name
);
13633 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13634 Note we do this even if cmdline_dump_sects is empty because we
13635 must make sure that the dump_sets array is zeroed out before each
13636 object file is processed. */
13637 if (num_dump_sects
> num_cmdline_dump_sects
)
13638 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13640 if (num_cmdline_dump_sects
> 0)
13642 if (num_dump_sects
== 0)
13643 /* A sneaky way of allocating the dump_sects array. */
13644 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13646 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13647 memcpy (dump_sects
, cmdline_dump_sects
,
13648 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13651 if (! process_file_header ())
13654 if (! process_section_headers (file
))
13656 /* Without loaded section headers we cannot process lots of
13658 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13660 if (! do_using_dynamic
)
13661 do_syms
= do_dyn_syms
= do_reloc
= 0;
13664 if (! process_section_groups (file
))
13666 /* Without loaded section groups we cannot process unwind. */
13670 if (process_program_headers (file
))
13671 process_dynamic_section (file
);
13673 process_relocs (file
);
13675 process_unwind (file
);
13677 process_symbol_table (file
);
13679 process_syminfo (file
);
13681 process_version_sections (file
);
13683 process_section_contents (file
);
13685 process_notes (file
);
13687 process_gnu_liblist (file
);
13689 process_arch_specific (file
);
13691 if (program_headers
)
13693 free (program_headers
);
13694 program_headers
= NULL
;
13697 if (section_headers
)
13699 free (section_headers
);
13700 section_headers
= NULL
;
13705 free (string_table
);
13706 string_table
= NULL
;
13707 string_table_length
= 0;
13710 if (dynamic_strings
)
13712 free (dynamic_strings
);
13713 dynamic_strings
= NULL
;
13714 dynamic_strings_length
= 0;
13717 if (dynamic_symbols
)
13719 free (dynamic_symbols
);
13720 dynamic_symbols
= NULL
;
13721 num_dynamic_syms
= 0;
13724 if (dynamic_syminfo
)
13726 free (dynamic_syminfo
);
13727 dynamic_syminfo
= NULL
;
13730 if (dynamic_section
)
13732 free (dynamic_section
);
13733 dynamic_section
= NULL
;
13736 if (section_headers_groups
)
13738 free (section_headers_groups
);
13739 section_headers_groups
= NULL
;
13742 if (section_groups
)
13744 struct group_list
* g
;
13745 struct group_list
* next
;
13747 for (i
= 0; i
< group_count
; i
++)
13749 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13756 free (section_groups
);
13757 section_groups
= NULL
;
13760 free_debug_memory ();
13765 /* Process an ELF archive.
13766 On entry the file is positioned just after the ARMAG string. */
13769 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13771 struct archive_info arch
;
13772 struct archive_info nested_arch
;
13778 /* The ARCH structure is used to hold information about this archive. */
13779 arch
.file_name
= NULL
;
13781 arch
.index_array
= NULL
;
13782 arch
.sym_table
= NULL
;
13783 arch
.longnames
= NULL
;
13785 /* The NESTED_ARCH structure is used as a single-item cache of information
13786 about a nested archive (when members of a thin archive reside within
13787 another regular archive file). */
13788 nested_arch
.file_name
= NULL
;
13789 nested_arch
.file
= NULL
;
13790 nested_arch
.index_array
= NULL
;
13791 nested_arch
.sym_table
= NULL
;
13792 nested_arch
.longnames
= NULL
;
13794 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13800 if (do_archive_index
)
13802 if (arch
.sym_table
== NULL
)
13803 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13807 unsigned long current_pos
;
13809 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13810 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13811 current_pos
= ftell (file
);
13813 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13815 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13817 char * member_name
;
13819 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13821 if (member_name
!= NULL
)
13823 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13825 if (qualified_name
!= NULL
)
13827 printf (_("Contents of binary %s at offset "), qualified_name
);
13828 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13830 free (qualified_name
);
13835 if (l
>= arch
.sym_size
)
13837 error (_("%s: end of the symbol table reached before the end of the index\n"),
13841 printf ("\t%s\n", arch
.sym_table
+ l
);
13842 l
+= strlen (arch
.sym_table
+ l
) + 1;
13845 if (arch
.uses_64bit_indicies
)
13850 if (l
< arch
.sym_size
)
13851 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13852 file_name
, arch
.sym_size
- l
);
13854 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13856 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13862 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13863 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13864 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13865 && !do_section_groups
&& !do_dyn_syms
)
13867 ret
= 0; /* Archive index only. */
13878 char * qualified_name
;
13880 /* Read the next archive header. */
13881 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13883 error (_("%s: failed to seek to next archive header\n"), file_name
);
13886 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13887 if (got
!= sizeof arch
.arhdr
)
13891 error (_("%s: failed to read archive header\n"), file_name
);
13895 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13897 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13902 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13904 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13905 if (archive_file_size
& 01)
13906 ++archive_file_size
;
13908 name
= get_archive_member_name (&arch
, &nested_arch
);
13911 error (_("%s: bad archive file name\n"), file_name
);
13915 namelen
= strlen (name
);
13917 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13918 if (qualified_name
== NULL
)
13920 error (_("%s: bad archive file name\n"), file_name
);
13925 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13927 /* This is a proxy for an external member of a thin archive. */
13928 FILE * member_file
;
13929 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13930 if (member_file_name
== NULL
)
13936 member_file
= fopen (member_file_name
, "rb");
13937 if (member_file
== NULL
)
13939 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13940 free (member_file_name
);
13945 archive_file_offset
= arch
.nested_member_origin
;
13947 ret
|= process_object (qualified_name
, member_file
);
13949 fclose (member_file
);
13950 free (member_file_name
);
13952 else if (is_thin_archive
)
13954 /* This is a proxy for a member of a nested archive. */
13955 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13957 /* The nested archive file will have been opened and setup by
13958 get_archive_member_name. */
13959 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13961 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13966 ret
|= process_object (qualified_name
, nested_arch
.file
);
13970 archive_file_offset
= arch
.next_arhdr_offset
;
13971 arch
.next_arhdr_offset
+= archive_file_size
;
13973 ret
|= process_object (qualified_name
, file
);
13976 if (dump_sects
!= NULL
)
13980 num_dump_sects
= 0;
13983 free (qualified_name
);
13987 if (nested_arch
.file
!= NULL
)
13988 fclose (nested_arch
.file
);
13989 release_archive (&nested_arch
);
13990 release_archive (&arch
);
13996 process_file (char * file_name
)
13999 struct stat statbuf
;
14000 char armag
[SARMAG
];
14003 if (stat (file_name
, &statbuf
) < 0)
14005 if (errno
== ENOENT
)
14006 error (_("'%s': No such file\n"), file_name
);
14008 error (_("Could not locate '%s'. System error message: %s\n"),
14009 file_name
, strerror (errno
));
14013 if (! S_ISREG (statbuf
.st_mode
))
14015 error (_("'%s' is not an ordinary file\n"), file_name
);
14019 file
= fopen (file_name
, "rb");
14022 error (_("Input file '%s' is not readable.\n"), file_name
);
14026 if (fread (armag
, SARMAG
, 1, file
) != 1)
14028 error (_("%s: Failed to read file's magic number\n"), file_name
);
14033 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14034 ret
= process_archive (file_name
, file
, FALSE
);
14035 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14036 ret
= process_archive (file_name
, file
, TRUE
);
14039 if (do_archive_index
)
14040 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14044 archive_file_size
= archive_file_offset
= 0;
14045 ret
= process_object (file_name
, file
);
14053 #ifdef SUPPORT_DISASSEMBLY
14054 /* Needed by the i386 disassembler. For extra credit, someone could
14055 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14059 print_address (unsigned int addr
, FILE * outfile
)
14061 fprintf (outfile
,"0x%8.8x", addr
);
14064 /* Needed by the i386 disassembler. */
14066 db_task_printsym (unsigned int addr
)
14068 print_address (addr
, stderr
);
14073 main (int argc
, char ** argv
)
14077 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14078 setlocale (LC_MESSAGES
, "");
14080 #if defined (HAVE_SETLOCALE)
14081 setlocale (LC_CTYPE
, "");
14083 bindtextdomain (PACKAGE
, LOCALEDIR
);
14084 textdomain (PACKAGE
);
14086 expandargv (&argc
, &argv
);
14088 parse_args (argc
, argv
);
14090 if (num_dump_sects
> 0)
14092 /* Make a copy of the dump_sects array. */
14093 cmdline_dump_sects
= (dump_type
*)
14094 malloc (num_dump_sects
* sizeof (* dump_sects
));
14095 if (cmdline_dump_sects
== NULL
)
14096 error (_("Out of memory allocating dump request table.\n"));
14099 memcpy (cmdline_dump_sects
, dump_sects
,
14100 num_dump_sects
* sizeof (* dump_sects
));
14101 num_cmdline_dump_sects
= num_dump_sects
;
14105 if (optind
< (argc
- 1))
14109 while (optind
< argc
)
14110 err
|= process_file (argv
[optind
++]);
14112 if (dump_sects
!= NULL
)
14114 if (cmdline_dump_sects
!= NULL
)
14115 free (cmdline_dump_sects
);