1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files.
58 Only do this if we believe that the compiler can support a 64 bit
59 data type. For now we only rely on GCC being able to do this. */
68 #include "elf/common.h"
69 #include "elf/external.h"
70 #include "elf/internal.h"
73 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
81 /* Undo the effects of #including reloc-macros.h. */
83 #undef START_RELOC_NUMBERS
87 #undef END_RELOC_NUMBERS
88 #undef _RELOC_MACROS_H
90 /* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
94 #define RELOC_MACROS_GEN_FUNC
96 #include "elf/aarch64.h"
97 #include "elf/alpha.h"
101 #include "elf/bfin.h"
102 #include "elf/cr16.h"
103 #include "elf/cris.h"
105 #include "elf/d10v.h"
106 #include "elf/d30v.h"
108 #include "elf/epiphany.h"
109 #include "elf/fr30.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/mcore.h"
127 #include "elf/metag.h"
128 #include "elf/microblaze.h"
129 #include "elf/mips.h"
130 #include "elf/mmix.h"
131 #include "elf/mn10200.h"
132 #include "elf/mn10300.h"
133 #include "elf/moxie.h"
135 #include "elf/msp430.h"
136 #include "elf/or32.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
163 char * program_name
= "readelf";
164 static long archive_file_offset
;
165 static unsigned long archive_file_size
;
166 static unsigned long dynamic_addr
;
167 static bfd_size_type dynamic_size
;
168 static unsigned int dynamic_nent
;
169 static char * dynamic_strings
;
170 static unsigned long dynamic_strings_length
;
171 static char * string_table
;
172 static unsigned long string_table_length
;
173 static unsigned long num_dynamic_syms
;
174 static Elf_Internal_Sym
* dynamic_symbols
;
175 static Elf_Internal_Syminfo
* dynamic_syminfo
;
176 static unsigned long dynamic_syminfo_offset
;
177 static unsigned int dynamic_syminfo_nent
;
178 static char program_interpreter
[PATH_MAX
];
179 static bfd_vma dynamic_info
[DT_ENCODING
];
180 static bfd_vma dynamic_info_DT_GNU_HASH
;
181 static bfd_vma version_info
[16];
182 static Elf_Internal_Ehdr elf_header
;
183 static Elf_Internal_Shdr
* section_headers
;
184 static Elf_Internal_Phdr
* program_headers
;
185 static Elf_Internal_Dyn
* dynamic_section
;
186 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
187 static int show_name
;
188 static int do_dynamic
;
190 static int do_dyn_syms
;
192 static int do_sections
;
193 static int do_section_groups
;
194 static int do_section_details
;
195 static int do_segments
;
196 static int do_unwind
;
197 static int do_using_dynamic
;
198 static int do_header
;
200 static int do_version
;
201 static int do_histogram
;
202 static int do_debugging
;
205 static int do_archive_index
;
206 static int is_32bit_elf
;
210 struct group_list
* next
;
211 unsigned int section_index
;
216 struct group_list
* root
;
217 unsigned int group_index
;
220 static size_t group_count
;
221 static struct group
* section_groups
;
222 static struct group
** section_headers_groups
;
225 /* Flag bits indicating particular types of dump. */
226 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
227 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
230 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
232 typedef unsigned char dump_type
;
234 /* A linked list of the section names for which dumps were requested. */
235 struct dump_list_entry
239 struct dump_list_entry
* next
;
241 static struct dump_list_entry
* dump_sects_byname
;
243 /* A dynamic array of flags indicating for which sections a dump
244 has been requested via command line switches. */
245 static dump_type
* cmdline_dump_sects
= NULL
;
246 static unsigned int num_cmdline_dump_sects
= 0;
248 /* A dynamic array of flags indicating for which sections a dump of
249 some kind has been requested. It is reset on a per-object file
250 basis and then initialised from the cmdline_dump_sects array,
251 the results of interpreting the -w switch, and the
252 dump_sects_byname list. */
253 static dump_type
* dump_sects
= NULL
;
254 static unsigned int num_dump_sects
= 0;
257 /* How to print a vma value. */
258 typedef enum print_mode
272 #define SECTION_NAME(X) \
273 ((X) == NULL ? _("<none>") \
274 : string_table == NULL ? _("<no-name>") \
275 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
276 : string_table + (X)->sh_name))
278 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
280 #define GET_ELF_SYMBOLS(file, section, sym_count) \
281 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
282 : get_64bit_elf_symbols (file, section, sym_count))
284 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
285 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
286 already been called and verified that the string exists. */
287 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
289 #define REMOVE_ARCH_BITS(ADDR) \
292 if (elf_header.e_machine == EM_ARM) \
297 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
298 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
299 using malloc and fill that. In either case return the pointer to the start of
300 the retrieved data or NULL if something went wrong. If something does go wrong
301 emit an error message using REASON as part of the context. */
304 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
309 if (size
== 0 || nmemb
== 0)
312 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
314 error (_("Unable to seek to 0x%lx for %s\n"),
315 (unsigned long) archive_file_offset
+ offset
, reason
);
322 /* Check for overflow. */
323 if (nmemb
< (~(size_t) 0 - 1) / size
)
324 /* + 1 so that we can '\0' terminate invalid string table sections. */
325 mvar
= malloc (size
* nmemb
+ 1);
329 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
330 (unsigned long)(size
* nmemb
), reason
);
334 ((char *) mvar
)[size
* nmemb
] = '\0';
337 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
339 error (_("Unable to read in 0x%lx bytes of %s\n"),
340 (unsigned long)(size
* nmemb
), reason
);
349 /* Print a VMA value. */
352 print_vma (bfd_vma vma
, print_mode mode
)
365 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
372 return printf ("%5" BFD_VMA_FMT
"d", vma
);
380 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
383 return printf ("%" BFD_VMA_FMT
"d", vma
);
386 return printf ("%" BFD_VMA_FMT
"u", vma
);
391 /* Display a symbol on stdout. Handles the display of control characters and
392 multibye characters (assuming the host environment supports them).
394 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
396 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
397 padding as necessary.
399 Returns the number of emitted characters. */
402 print_symbol (int width
, const char *symbol
)
404 bfd_boolean extra_padding
= FALSE
;
406 #ifdef HAVE_MBSTATE_T
413 /* Keep the width positive. This also helps. */
415 extra_padding
= TRUE
;
419 /* Set the remaining width to a very large value.
420 This simplifies the code below. */
421 width_remaining
= INT_MAX
;
423 width_remaining
= width
;
425 #ifdef HAVE_MBSTATE_T
426 /* Initialise the multibyte conversion state. */
427 memset (& state
, 0, sizeof (state
));
430 while (width_remaining
)
433 const char c
= *symbol
++;
438 /* Do not print control characters directly as they can affect terminal
439 settings. Such characters usually appear in the names generated
440 by the assembler for local labels. */
443 if (width_remaining
< 2)
446 printf ("^%c", c
+ 0x40);
447 width_remaining
-= 2;
450 else if (ISPRINT (c
))
458 #ifdef HAVE_MBSTATE_T
461 /* Let printf do the hard work of displaying multibyte characters. */
462 printf ("%.1s", symbol
- 1);
466 #ifdef HAVE_MBSTATE_T
467 /* Try to find out how many bytes made up the character that was
468 just printed. Advance the symbol pointer past the bytes that
470 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
474 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
479 if (extra_padding
&& num_printed
< width
)
481 /* Fill in the remaining spaces. */
482 printf ("%-*s", width
- num_printed
, " ");
489 /* Return a pointer to section NAME, or NULL if no such section exists. */
491 static Elf_Internal_Shdr
*
492 find_section (const char * name
)
496 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
497 if (streq (SECTION_NAME (section_headers
+ i
), name
))
498 return section_headers
+ i
;
503 /* Return a pointer to a section containing ADDR, or NULL if no such
506 static Elf_Internal_Shdr
*
507 find_section_by_address (bfd_vma addr
)
511 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
513 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
514 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
521 /* Return a pointer to section NAME, or NULL if no such section exists,
522 restricted to the list of sections given in SET. */
524 static Elf_Internal_Shdr
*
525 find_section_in_set (const char * name
, unsigned int * set
)
531 while ((i
= *set
++) > 0)
532 if (streq (SECTION_NAME (section_headers
+ i
), name
))
533 return section_headers
+ i
;
536 return find_section (name
);
539 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
543 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
545 return read_leb128 (data
, length_return
, 0);
548 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
549 This OS has so many departures from the ELF standard that we test it at
555 return elf_header
.e_machine
== EM_IA_64
556 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
559 /* Guess the relocation size commonly used by the specific machines. */
562 guess_is_rela (unsigned int e_machine
)
566 /* Targets that use REL relocations. */
583 /* Targets that use RELA relocations. */
587 case EM_ADAPTEVA_EPIPHANY
:
589 case EM_ALTERA_NIOS2
:
608 case EM_LATTICEMICO32
:
617 case EM_CYGNUS_MN10200
:
619 case EM_CYGNUS_MN10300
:
650 case EM_MICROBLAZE_OLD
:
671 warn (_("Don't know about relocations on this machine architecture\n"));
677 slurp_rela_relocs (FILE * file
,
678 unsigned long rel_offset
,
679 unsigned long rel_size
,
680 Elf_Internal_Rela
** relasp
,
681 unsigned long * nrelasp
)
683 Elf_Internal_Rela
* relas
;
684 unsigned long nrelas
;
689 Elf32_External_Rela
* erelas
;
691 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
692 rel_size
, _("32-bit relocation data"));
696 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
698 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
699 sizeof (Elf_Internal_Rela
));
704 error (_("out of memory parsing relocs\n"));
708 for (i
= 0; i
< nrelas
; i
++)
710 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
711 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
712 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
719 Elf64_External_Rela
* erelas
;
721 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
722 rel_size
, _("64-bit relocation data"));
726 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
728 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
729 sizeof (Elf_Internal_Rela
));
734 error (_("out of memory parsing relocs\n"));
738 for (i
= 0; i
< nrelas
; i
++)
740 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
741 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
742 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
744 /* The #ifdef BFD64 below is to prevent a compile time
745 warning. We know that if we do not have a 64 bit data
746 type that we will never execute this code anyway. */
748 if (elf_header
.e_machine
== EM_MIPS
749 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
751 /* In little-endian objects, r_info isn't really a
752 64-bit little-endian value: it has a 32-bit
753 little-endian symbol index followed by four
754 individual byte fields. Reorder INFO
756 bfd_vma inf
= relas
[i
].r_info
;
757 inf
= (((inf
& 0xffffffff) << 32)
758 | ((inf
>> 56) & 0xff)
759 | ((inf
>> 40) & 0xff00)
760 | ((inf
>> 24) & 0xff0000)
761 | ((inf
>> 8) & 0xff000000));
762 relas
[i
].r_info
= inf
;
775 slurp_rel_relocs (FILE * file
,
776 unsigned long rel_offset
,
777 unsigned long rel_size
,
778 Elf_Internal_Rela
** relsp
,
779 unsigned long * nrelsp
)
781 Elf_Internal_Rela
* rels
;
787 Elf32_External_Rel
* erels
;
789 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
790 rel_size
, _("32-bit relocation data"));
794 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
796 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
801 error (_("out of memory parsing relocs\n"));
805 for (i
= 0; i
< nrels
; i
++)
807 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
808 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
809 rels
[i
].r_addend
= 0;
816 Elf64_External_Rel
* erels
;
818 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
819 rel_size
, _("64-bit relocation data"));
823 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
825 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
830 error (_("out of memory parsing relocs\n"));
834 for (i
= 0; i
< nrels
; i
++)
836 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
837 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
838 rels
[i
].r_addend
= 0;
840 /* The #ifdef BFD64 below is to prevent a compile time
841 warning. We know that if we do not have a 64 bit data
842 type that we will never execute this code anyway. */
844 if (elf_header
.e_machine
== EM_MIPS
845 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
847 /* In little-endian objects, r_info isn't really a
848 64-bit little-endian value: it has a 32-bit
849 little-endian symbol index followed by four
850 individual byte fields. Reorder INFO
852 bfd_vma inf
= rels
[i
].r_info
;
853 inf
= (((inf
& 0xffffffff) << 32)
854 | ((inf
>> 56) & 0xff)
855 | ((inf
>> 40) & 0xff00)
856 | ((inf
>> 24) & 0xff0000)
857 | ((inf
>> 8) & 0xff000000));
858 rels
[i
].r_info
= inf
;
870 /* Returns the reloc type extracted from the reloc info field. */
873 get_reloc_type (bfd_vma reloc_info
)
876 return ELF32_R_TYPE (reloc_info
);
878 switch (elf_header
.e_machine
)
881 /* Note: We assume that reloc_info has already been adjusted for us. */
882 return ELF64_MIPS_R_TYPE (reloc_info
);
885 return ELF64_R_TYPE_ID (reloc_info
);
888 return ELF64_R_TYPE (reloc_info
);
892 /* Return the symbol index extracted from the reloc info field. */
895 get_reloc_symindex (bfd_vma reloc_info
)
897 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
900 /* Display the contents of the relocation data found at the specified
904 dump_relocations (FILE * file
,
905 unsigned long rel_offset
,
906 unsigned long rel_size
,
907 Elf_Internal_Sym
* symtab
,
910 unsigned long strtablen
,
914 Elf_Internal_Rela
* rels
;
916 if (is_rela
== UNKNOWN
)
917 is_rela
= guess_is_rela (elf_header
.e_machine
);
921 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
926 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
935 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
937 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
942 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
944 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
952 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
954 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
959 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
961 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
965 for (i
= 0; i
< rel_size
; i
++)
970 bfd_vma symtab_index
;
973 offset
= rels
[i
].r_offset
;
974 inf
= rels
[i
].r_info
;
976 type
= get_reloc_type (inf
);
977 symtab_index
= get_reloc_symindex (inf
);
981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset
& 0xffffffff,
983 (unsigned long) inf
& 0xffffffff);
987 #if BFD_HOST_64BIT_LONG
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
992 #elif BFD_HOST_64BIT_LONG_LONG
995 ? "%16.16llx %16.16llx "
996 : "%12.12llx %12.12llx ",
1000 ? "%16.16I64x %16.16I64x "
1001 : "%12.12I64x %12.12I64x ",
1006 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1007 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1008 _bfd_int64_high (offset
),
1009 _bfd_int64_low (offset
),
1010 _bfd_int64_high (inf
),
1011 _bfd_int64_low (inf
));
1015 switch (elf_header
.e_machine
)
1022 rtype
= elf_aarch64_reloc_type (type
);
1026 case EM_CYGNUS_M32R
:
1027 rtype
= elf_m32r_reloc_type (type
);
1032 rtype
= elf_i386_reloc_type (type
);
1037 rtype
= elf_m68hc11_reloc_type (type
);
1041 rtype
= elf_m68k_reloc_type (type
);
1045 rtype
= elf_i960_reloc_type (type
);
1050 rtype
= elf_avr_reloc_type (type
);
1053 case EM_OLD_SPARCV9
:
1054 case EM_SPARC32PLUS
:
1057 rtype
= elf_sparc_reloc_type (type
);
1061 rtype
= elf_spu_reloc_type (type
);
1065 rtype
= v800_reloc_type (type
);
1068 case EM_CYGNUS_V850
:
1069 rtype
= v850_reloc_type (type
);
1073 case EM_CYGNUS_D10V
:
1074 rtype
= elf_d10v_reloc_type (type
);
1078 case EM_CYGNUS_D30V
:
1079 rtype
= elf_d30v_reloc_type (type
);
1083 rtype
= elf_dlx_reloc_type (type
);
1087 rtype
= elf_sh_reloc_type (type
);
1091 case EM_CYGNUS_MN10300
:
1092 rtype
= elf_mn10300_reloc_type (type
);
1096 case EM_CYGNUS_MN10200
:
1097 rtype
= elf_mn10200_reloc_type (type
);
1101 case EM_CYGNUS_FR30
:
1102 rtype
= elf_fr30_reloc_type (type
);
1106 rtype
= elf_frv_reloc_type (type
);
1110 rtype
= elf_mcore_reloc_type (type
);
1114 rtype
= elf_mmix_reloc_type (type
);
1118 rtype
= elf_moxie_reloc_type (type
);
1123 rtype
= elf_msp430_reloc_type (type
);
1127 rtype
= elf_ppc_reloc_type (type
);
1131 rtype
= elf_ppc64_reloc_type (type
);
1135 case EM_MIPS_RS3_LE
:
1136 rtype
= elf_mips_reloc_type (type
);
1140 rtype
= elf_alpha_reloc_type (type
);
1144 rtype
= elf_arm_reloc_type (type
);
1148 rtype
= elf_arc_reloc_type (type
);
1152 rtype
= elf_hppa_reloc_type (type
);
1158 rtype
= elf_h8_reloc_type (type
);
1163 rtype
= elf_or32_reloc_type (type
);
1168 rtype
= elf_pj_reloc_type (type
);
1171 rtype
= elf_ia64_reloc_type (type
);
1175 rtype
= elf_cris_reloc_type (type
);
1179 rtype
= elf_i860_reloc_type (type
);
1185 rtype
= elf_x86_64_reloc_type (type
);
1189 rtype
= i370_reloc_type (type
);
1194 rtype
= elf_s390_reloc_type (type
);
1198 rtype
= elf_score_reloc_type (type
);
1202 rtype
= elf_xstormy16_reloc_type (type
);
1206 rtype
= elf_crx_reloc_type (type
);
1210 rtype
= elf_vax_reloc_type (type
);
1213 case EM_ADAPTEVA_EPIPHANY
:
1214 rtype
= elf_epiphany_reloc_type (type
);
1219 rtype
= elf_ip2k_reloc_type (type
);
1223 rtype
= elf_iq2000_reloc_type (type
);
1228 rtype
= elf_xtensa_reloc_type (type
);
1231 case EM_LATTICEMICO32
:
1232 rtype
= elf_lm32_reloc_type (type
);
1237 rtype
= elf_m32c_reloc_type (type
);
1241 rtype
= elf_mt_reloc_type (type
);
1245 rtype
= elf_bfin_reloc_type (type
);
1249 rtype
= elf_mep_reloc_type (type
);
1253 rtype
= elf_cr16_reloc_type (type
);
1257 case EM_MICROBLAZE_OLD
:
1258 rtype
= elf_microblaze_reloc_type (type
);
1262 rtype
= elf_rl78_reloc_type (type
);
1266 rtype
= elf_rx_reloc_type (type
);
1270 rtype
= elf_metag_reloc_type (type
);
1275 rtype
= elf_xc16x_reloc_type (type
);
1279 rtype
= elf_tic6x_reloc_type (type
);
1283 rtype
= elf_tilegx_reloc_type (type
);
1287 rtype
= elf_tilepro_reloc_type (type
);
1291 rtype
= elf_xgate_reloc_type (type
);
1296 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1298 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1300 if (elf_header
.e_machine
== EM_ALPHA
1302 && streq (rtype
, "R_ALPHA_LITUSE")
1305 switch (rels
[i
].r_addend
)
1307 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1308 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1309 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1310 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1311 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1312 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1313 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1314 default: rtype
= NULL
;
1317 printf (" (%s)", rtype
);
1321 printf (_("<unknown addend: %lx>"),
1322 (unsigned long) rels
[i
].r_addend
);
1325 else if (symtab_index
)
1327 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1328 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1331 Elf_Internal_Sym
* psym
;
1333 psym
= symtab
+ symtab_index
;
1337 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1341 unsigned int width
= is_32bit_elf
? 8 : 14;
1343 /* Relocations against GNU_IFUNC symbols do not use the value
1344 of the symbol as the address to relocate against. Instead
1345 they invoke the function named by the symbol and use its
1346 result as the address for relocation.
1348 To indicate this to the user, do not display the value of
1349 the symbol in the "Symbols's Value" field. Instead show
1350 its name followed by () as a hint that the symbol is
1354 || psym
->st_name
== 0
1355 || psym
->st_name
>= strtablen
)
1358 name
= strtab
+ psym
->st_name
;
1360 len
= print_symbol (width
, name
);
1361 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1365 print_vma (psym
->st_value
, LONG_HEX
);
1367 printf (is_32bit_elf
? " " : " ");
1370 if (psym
->st_name
== 0)
1372 const char * sec_name
= "<null>";
1375 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1377 if (psym
->st_shndx
< elf_header
.e_shnum
)
1379 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1380 else if (psym
->st_shndx
== SHN_ABS
)
1382 else if (psym
->st_shndx
== SHN_COMMON
)
1383 sec_name
= "COMMON";
1384 else if ((elf_header
.e_machine
== EM_MIPS
1385 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1386 || (elf_header
.e_machine
== EM_TI_C6000
1387 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1388 sec_name
= "SCOMMON";
1389 else if (elf_header
.e_machine
== EM_MIPS
1390 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1391 sec_name
= "SUNDEF";
1392 else if ((elf_header
.e_machine
== EM_X86_64
1393 || elf_header
.e_machine
== EM_L1OM
1394 || elf_header
.e_machine
== EM_K1OM
)
1395 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1396 sec_name
= "LARGE_COMMON";
1397 else if (elf_header
.e_machine
== EM_IA_64
1398 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1399 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1400 sec_name
= "ANSI_COM";
1401 else if (is_ia64_vms ()
1402 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1403 sec_name
= "VMS_SYMVEC";
1406 sprintf (name_buf
, "<section 0x%x>",
1407 (unsigned int) psym
->st_shndx
);
1408 sec_name
= name_buf
;
1411 print_symbol (22, sec_name
);
1413 else if (strtab
== NULL
)
1414 printf (_("<string table index: %3ld>"), psym
->st_name
);
1415 else if (psym
->st_name
>= strtablen
)
1416 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1418 print_symbol (22, strtab
+ psym
->st_name
);
1422 bfd_signed_vma off
= rels
[i
].r_addend
;
1425 printf (" - %" BFD_VMA_FMT
"x", - off
);
1427 printf (" + %" BFD_VMA_FMT
"x", off
);
1433 bfd_signed_vma off
= rels
[i
].r_addend
;
1435 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1437 printf ("-%" BFD_VMA_FMT
"x", - off
);
1439 printf ("%" BFD_VMA_FMT
"x", off
);
1442 if (elf_header
.e_machine
== EM_SPARCV9
1444 && streq (rtype
, "R_SPARC_OLO10"))
1445 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1450 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1452 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1453 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1454 const char * rtype2
= elf_mips_reloc_type (type2
);
1455 const char * rtype3
= elf_mips_reloc_type (type3
);
1457 printf (" Type2: ");
1460 printf (_("unrecognized: %-7lx"),
1461 (unsigned long) type2
& 0xffffffff);
1463 printf ("%-17.17s", rtype2
);
1465 printf ("\n Type3: ");
1468 printf (_("unrecognized: %-7lx"),
1469 (unsigned long) type3
& 0xffffffff);
1471 printf ("%-17.17s", rtype3
);
1482 get_mips_dynamic_type (unsigned long type
)
1486 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1487 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1488 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1489 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1490 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1491 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1492 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1493 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1494 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1495 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1496 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1497 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1498 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1499 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1500 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1501 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1502 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1503 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1504 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1505 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1506 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1507 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1508 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1509 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1510 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1511 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1512 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1513 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1514 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1515 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1516 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1517 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1518 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1519 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1520 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1521 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1522 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1523 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1524 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1525 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1526 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1527 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1528 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1529 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1530 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1537 get_sparc64_dynamic_type (unsigned long type
)
1541 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1548 get_ppc_dynamic_type (unsigned long type
)
1552 case DT_PPC_GOT
: return "PPC_GOT";
1553 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1560 get_ppc64_dynamic_type (unsigned long type
)
1564 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1565 case DT_PPC64_OPD
: return "PPC64_OPD";
1566 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1567 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1574 get_parisc_dynamic_type (unsigned long type
)
1578 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1579 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1580 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1581 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1582 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1583 case DT_HP_PREINIT
: return "HP_PREINIT";
1584 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1585 case DT_HP_NEEDED
: return "HP_NEEDED";
1586 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1587 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1588 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1589 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1590 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1591 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1592 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1593 case DT_HP_FILTERED
: return "HP_FILTERED";
1594 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1595 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1596 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1597 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1598 case DT_PLT
: return "PLT";
1599 case DT_PLT_SIZE
: return "PLT_SIZE";
1600 case DT_DLT
: return "DLT";
1601 case DT_DLT_SIZE
: return "DLT_SIZE";
1608 get_ia64_dynamic_type (unsigned long type
)
1612 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1613 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1614 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1615 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1616 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1617 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1618 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1619 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1620 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1621 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1622 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1623 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1624 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1625 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1626 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1627 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1628 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1629 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1630 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1631 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1632 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1633 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1634 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1635 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1636 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1637 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1638 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1639 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1640 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1641 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1642 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1649 get_alpha_dynamic_type (unsigned long type
)
1653 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1660 get_score_dynamic_type (unsigned long type
)
1664 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1665 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1666 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1667 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1668 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1669 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1676 get_tic6x_dynamic_type (unsigned long type
)
1680 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1681 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1682 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1683 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1684 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1685 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1692 get_dynamic_type (unsigned long type
)
1694 static char buff
[64];
1698 case DT_NULL
: return "NULL";
1699 case DT_NEEDED
: return "NEEDED";
1700 case DT_PLTRELSZ
: return "PLTRELSZ";
1701 case DT_PLTGOT
: return "PLTGOT";
1702 case DT_HASH
: return "HASH";
1703 case DT_STRTAB
: return "STRTAB";
1704 case DT_SYMTAB
: return "SYMTAB";
1705 case DT_RELA
: return "RELA";
1706 case DT_RELASZ
: return "RELASZ";
1707 case DT_RELAENT
: return "RELAENT";
1708 case DT_STRSZ
: return "STRSZ";
1709 case DT_SYMENT
: return "SYMENT";
1710 case DT_INIT
: return "INIT";
1711 case DT_FINI
: return "FINI";
1712 case DT_SONAME
: return "SONAME";
1713 case DT_RPATH
: return "RPATH";
1714 case DT_SYMBOLIC
: return "SYMBOLIC";
1715 case DT_REL
: return "REL";
1716 case DT_RELSZ
: return "RELSZ";
1717 case DT_RELENT
: return "RELENT";
1718 case DT_PLTREL
: return "PLTREL";
1719 case DT_DEBUG
: return "DEBUG";
1720 case DT_TEXTREL
: return "TEXTREL";
1721 case DT_JMPREL
: return "JMPREL";
1722 case DT_BIND_NOW
: return "BIND_NOW";
1723 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1724 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1725 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1726 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1727 case DT_RUNPATH
: return "RUNPATH";
1728 case DT_FLAGS
: return "FLAGS";
1730 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1731 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1733 case DT_CHECKSUM
: return "CHECKSUM";
1734 case DT_PLTPADSZ
: return "PLTPADSZ";
1735 case DT_MOVEENT
: return "MOVEENT";
1736 case DT_MOVESZ
: return "MOVESZ";
1737 case DT_FEATURE
: return "FEATURE";
1738 case DT_POSFLAG_1
: return "POSFLAG_1";
1739 case DT_SYMINSZ
: return "SYMINSZ";
1740 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1742 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1743 case DT_CONFIG
: return "CONFIG";
1744 case DT_DEPAUDIT
: return "DEPAUDIT";
1745 case DT_AUDIT
: return "AUDIT";
1746 case DT_PLTPAD
: return "PLTPAD";
1747 case DT_MOVETAB
: return "MOVETAB";
1748 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1750 case DT_VERSYM
: return "VERSYM";
1752 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1753 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1754 case DT_RELACOUNT
: return "RELACOUNT";
1755 case DT_RELCOUNT
: return "RELCOUNT";
1756 case DT_FLAGS_1
: return "FLAGS_1";
1757 case DT_VERDEF
: return "VERDEF";
1758 case DT_VERDEFNUM
: return "VERDEFNUM";
1759 case DT_VERNEED
: return "VERNEED";
1760 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1762 case DT_AUXILIARY
: return "AUXILIARY";
1763 case DT_USED
: return "USED";
1764 case DT_FILTER
: return "FILTER";
1766 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1767 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1768 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1769 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1770 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1771 case DT_GNU_HASH
: return "GNU_HASH";
1774 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1776 const char * result
;
1778 switch (elf_header
.e_machine
)
1781 case EM_MIPS_RS3_LE
:
1782 result
= get_mips_dynamic_type (type
);
1785 result
= get_sparc64_dynamic_type (type
);
1788 result
= get_ppc_dynamic_type (type
);
1791 result
= get_ppc64_dynamic_type (type
);
1794 result
= get_ia64_dynamic_type (type
);
1797 result
= get_alpha_dynamic_type (type
);
1800 result
= get_score_dynamic_type (type
);
1803 result
= get_tic6x_dynamic_type (type
);
1813 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1815 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1816 || (elf_header
.e_machine
== EM_PARISC
1817 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1819 const char * result
;
1821 switch (elf_header
.e_machine
)
1824 result
= get_parisc_dynamic_type (type
);
1827 result
= get_ia64_dynamic_type (type
);
1837 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1841 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1848 get_file_type (unsigned e_type
)
1850 static char buff
[32];
1854 case ET_NONE
: return _("NONE (None)");
1855 case ET_REL
: return _("REL (Relocatable file)");
1856 case ET_EXEC
: return _("EXEC (Executable file)");
1857 case ET_DYN
: return _("DYN (Shared object file)");
1858 case ET_CORE
: return _("CORE (Core file)");
1861 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1862 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1863 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1864 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1866 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1872 get_machine_name (unsigned e_machine
)
1874 static char buff
[64]; /* XXX */
1878 case EM_NONE
: return _("None");
1879 case EM_AARCH64
: return "AArch64";
1880 case EM_M32
: return "WE32100";
1881 case EM_SPARC
: return "Sparc";
1882 case EM_SPU
: return "SPU";
1883 case EM_386
: return "Intel 80386";
1884 case EM_68K
: return "MC68000";
1885 case EM_88K
: return "MC88000";
1886 case EM_486
: return "Intel 80486";
1887 case EM_860
: return "Intel 80860";
1888 case EM_MIPS
: return "MIPS R3000";
1889 case EM_S370
: return "IBM System/370";
1890 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1891 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1892 case EM_PARISC
: return "HPPA";
1893 case EM_PPC_OLD
: return "Power PC (old)";
1894 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1895 case EM_960
: return "Intel 90860";
1896 case EM_PPC
: return "PowerPC";
1897 case EM_PPC64
: return "PowerPC64";
1898 case EM_FR20
: return "Fujitsu FR20";
1899 case EM_RH32
: return "TRW RH32";
1900 case EM_MCORE
: return "MCORE";
1901 case EM_ARM
: return "ARM";
1902 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1903 case EM_SH
: return "Renesas / SuperH SH";
1904 case EM_SPARCV9
: return "Sparc v9";
1905 case EM_TRICORE
: return "Siemens Tricore";
1906 case EM_ARC
: return "ARC";
1907 case EM_H8_300
: return "Renesas H8/300";
1908 case EM_H8_300H
: return "Renesas H8/300H";
1909 case EM_H8S
: return "Renesas H8S";
1910 case EM_H8_500
: return "Renesas H8/500";
1911 case EM_IA_64
: return "Intel IA-64";
1912 case EM_MIPS_X
: return "Stanford MIPS-X";
1913 case EM_COLDFIRE
: return "Motorola Coldfire";
1914 case EM_ALPHA
: return "Alpha";
1915 case EM_CYGNUS_D10V
:
1916 case EM_D10V
: return "d10v";
1917 case EM_CYGNUS_D30V
:
1918 case EM_D30V
: return "d30v";
1919 case EM_CYGNUS_M32R
:
1920 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1921 case EM_CYGNUS_V850
:
1922 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1923 case EM_V850
: return "Renesas V850";
1924 case EM_CYGNUS_MN10300
:
1925 case EM_MN10300
: return "mn10300";
1926 case EM_CYGNUS_MN10200
:
1927 case EM_MN10200
: return "mn10200";
1928 case EM_MOXIE
: return "Moxie";
1929 case EM_CYGNUS_FR30
:
1930 case EM_FR30
: return "Fujitsu FR30";
1931 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1933 case EM_PJ
: return "picoJava";
1934 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1935 case EM_PCP
: return "Siemens PCP";
1936 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1937 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1938 case EM_STARCORE
: return "Motorola Star*Core processor";
1939 case EM_ME16
: return "Toyota ME16 processor";
1940 case EM_ST100
: return "STMicroelectronics ST100 processor";
1941 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1942 case EM_PDSP
: return "Sony DSP processor";
1943 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1944 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1945 case EM_FX66
: return "Siemens FX66 microcontroller";
1946 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1947 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1948 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1949 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1950 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1951 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1952 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1953 case EM_SVX
: return "Silicon Graphics SVx";
1954 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1955 case EM_VAX
: return "Digital VAX";
1957 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1958 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1959 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1960 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1961 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1962 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1963 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1964 case EM_PRISM
: return "Vitesse Prism";
1965 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1966 case EM_L1OM
: return "Intel L1OM";
1967 case EM_K1OM
: return "Intel K1OM";
1969 case EM_S390
: return "IBM S/390";
1970 case EM_SCORE
: return "SUNPLUS S+Core";
1971 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1973 case EM_OR32
: return "OpenRISC";
1974 case EM_ARC_A5
: return "ARC International ARCompact processor";
1975 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1976 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
1977 case EM_DLX
: return "OpenDLX";
1979 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1980 case EM_IQ2000
: return "Vitesse IQ2000";
1982 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1983 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1984 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1985 case EM_NS32K
: return "National Semiconductor 32000 series";
1986 case EM_TPC
: return "Tenor Network TPC processor";
1987 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1988 case EM_MAX
: return "MAX Processor";
1989 case EM_CR
: return "National Semiconductor CompactRISC";
1990 case EM_F2MC16
: return "Fujitsu F2MC16";
1991 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1992 case EM_LATTICEMICO32
: return "Lattice Mico32";
1994 case EM_M32C
: return "Renesas M32c";
1995 case EM_MT
: return "Morpho Techologies MT processor";
1996 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1997 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1998 case EM_SEP
: return "Sharp embedded microprocessor";
1999 case EM_ARCA
: return "Arca RISC microprocessor";
2000 case EM_UNICORE
: return "Unicore";
2001 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2002 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2003 case EM_NIOS32
: return "Altera Nios";
2004 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2006 case EM_XC16X
: return "Infineon Technologies xc16x";
2007 case EM_M16C
: return "Renesas M16C series microprocessors";
2008 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2009 case EM_CE
: return "Freescale Communication Engine RISC core";
2010 case EM_TSK3000
: return "Altium TSK3000 core";
2011 case EM_RS08
: return "Freescale RS08 embedded processor";
2012 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2013 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2014 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2015 case EM_SE_C17
: return "Seiko Epson C17 family";
2016 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2017 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2018 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2019 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2020 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2021 case EM_R32C
: return "Renesas R32C series microprocessors";
2022 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2023 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2024 case EM_8051
: return "Intel 8051 and variants";
2025 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2026 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2027 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2028 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2029 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2030 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2031 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2032 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2035 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2036 case EM_RL78
: return "Renesas RL78";
2037 case EM_RX
: return "Renesas RX";
2038 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2039 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2040 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2041 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2042 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2043 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2044 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2045 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2046 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2047 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2048 case EM_CUDA
: return "NVIDIA CUDA architecture";
2049 case EM_XGATE
: return "Motorola XGATE embedded processor";
2051 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2057 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2062 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2063 e_flags
&= ~ EF_ARM_EABIMASK
;
2065 /* Handle "generic" ARM flags. */
2066 if (e_flags
& EF_ARM_RELEXEC
)
2068 strcat (buf
, ", relocatable executable");
2069 e_flags
&= ~ EF_ARM_RELEXEC
;
2072 if (e_flags
& EF_ARM_HASENTRY
)
2074 strcat (buf
, ", has entry point");
2075 e_flags
&= ~ EF_ARM_HASENTRY
;
2078 /* Now handle EABI specific flags. */
2082 strcat (buf
, ", <unrecognized EABI>");
2087 case EF_ARM_EABI_VER1
:
2088 strcat (buf
, ", Version1 EABI");
2093 /* Process flags one bit at a time. */
2094 flag
= e_flags
& - e_flags
;
2099 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2100 strcat (buf
, ", sorted symbol tables");
2110 case EF_ARM_EABI_VER2
:
2111 strcat (buf
, ", Version2 EABI");
2116 /* Process flags one bit at a time. */
2117 flag
= e_flags
& - e_flags
;
2122 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2123 strcat (buf
, ", sorted symbol tables");
2126 case EF_ARM_DYNSYMSUSESEGIDX
:
2127 strcat (buf
, ", dynamic symbols use segment index");
2130 case EF_ARM_MAPSYMSFIRST
:
2131 strcat (buf
, ", mapping symbols precede others");
2141 case EF_ARM_EABI_VER3
:
2142 strcat (buf
, ", Version3 EABI");
2145 case EF_ARM_EABI_VER4
:
2146 strcat (buf
, ", Version4 EABI");
2151 /* Process flags one bit at a time. */
2152 flag
= e_flags
& - e_flags
;
2158 strcat (buf
, ", BE8");
2162 strcat (buf
, ", LE8");
2173 case EF_ARM_EABI_VER5
:
2174 strcat (buf
, ", Version5 EABI");
2179 /* Process flags one bit at a time. */
2180 flag
= e_flags
& - e_flags
;
2186 strcat (buf
, ", BE8");
2190 strcat (buf
, ", LE8");
2193 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2194 strcat (buf
, ", soft-float ABI");
2197 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2198 strcat (buf
, ", hard-float ABI");
2208 case EF_ARM_EABI_UNKNOWN
:
2209 strcat (buf
, ", GNU EABI");
2214 /* Process flags one bit at a time. */
2215 flag
= e_flags
& - e_flags
;
2220 case EF_ARM_INTERWORK
:
2221 strcat (buf
, ", interworking enabled");
2224 case EF_ARM_APCS_26
:
2225 strcat (buf
, ", uses APCS/26");
2228 case EF_ARM_APCS_FLOAT
:
2229 strcat (buf
, ", uses APCS/float");
2233 strcat (buf
, ", position independent");
2237 strcat (buf
, ", 8 bit structure alignment");
2240 case EF_ARM_NEW_ABI
:
2241 strcat (buf
, ", uses new ABI");
2244 case EF_ARM_OLD_ABI
:
2245 strcat (buf
, ", uses old ABI");
2248 case EF_ARM_SOFT_FLOAT
:
2249 strcat (buf
, ", software FP");
2252 case EF_ARM_VFP_FLOAT
:
2253 strcat (buf
, ", VFP");
2256 case EF_ARM_MAVERICK_FLOAT
:
2257 strcat (buf
, ", Maverick FP");
2268 strcat (buf
,_(", <unknown>"));
2272 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2274 static char buf
[1024];
2286 decode_ARM_machine_flags (e_flags
, buf
);
2290 if (e_flags
& EF_BFIN_PIC
)
2291 strcat (buf
, ", PIC");
2293 if (e_flags
& EF_BFIN_FDPIC
)
2294 strcat (buf
, ", FDPIC");
2296 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2297 strcat (buf
, ", code in L1");
2299 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2300 strcat (buf
, ", data in L1");
2305 switch (e_flags
& EF_FRV_CPU_MASK
)
2307 case EF_FRV_CPU_GENERIC
:
2311 strcat (buf
, ", fr???");
2314 case EF_FRV_CPU_FR300
:
2315 strcat (buf
, ", fr300");
2318 case EF_FRV_CPU_FR400
:
2319 strcat (buf
, ", fr400");
2321 case EF_FRV_CPU_FR405
:
2322 strcat (buf
, ", fr405");
2325 case EF_FRV_CPU_FR450
:
2326 strcat (buf
, ", fr450");
2329 case EF_FRV_CPU_FR500
:
2330 strcat (buf
, ", fr500");
2332 case EF_FRV_CPU_FR550
:
2333 strcat (buf
, ", fr550");
2336 case EF_FRV_CPU_SIMPLE
:
2337 strcat (buf
, ", simple");
2339 case EF_FRV_CPU_TOMCAT
:
2340 strcat (buf
, ", tomcat");
2346 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2347 strcat (buf
, ", m68000");
2348 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2349 strcat (buf
, ", cpu32");
2350 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2351 strcat (buf
, ", fido_a");
2354 char const * isa
= _("unknown");
2355 char const * mac
= _("unknown mac");
2356 char const * additional
= NULL
;
2358 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2360 case EF_M68K_CF_ISA_A_NODIV
:
2362 additional
= ", nodiv";
2364 case EF_M68K_CF_ISA_A
:
2367 case EF_M68K_CF_ISA_A_PLUS
:
2370 case EF_M68K_CF_ISA_B_NOUSP
:
2372 additional
= ", nousp";
2374 case EF_M68K_CF_ISA_B
:
2377 case EF_M68K_CF_ISA_C
:
2380 case EF_M68K_CF_ISA_C_NODIV
:
2382 additional
= ", nodiv";
2385 strcat (buf
, ", cf, isa ");
2388 strcat (buf
, additional
);
2389 if (e_flags
& EF_M68K_CF_FLOAT
)
2390 strcat (buf
, ", float");
2391 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2396 case EF_M68K_CF_MAC
:
2399 case EF_M68K_CF_EMAC
:
2402 case EF_M68K_CF_EMAC_B
:
2415 if (e_flags
& EF_PPC_EMB
)
2416 strcat (buf
, ", emb");
2418 if (e_flags
& EF_PPC_RELOCATABLE
)
2419 strcat (buf
, _(", relocatable"));
2421 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2422 strcat (buf
, _(", relocatable-lib"));
2426 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2427 strcat (buf
, ", RH850 ABI");
2429 if (e_flags
& EF_V800_850E3
)
2430 strcat (buf
, ", V3 architecture");
2432 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2433 strcat (buf
, ", FPU not used");
2435 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2436 strcat (buf
, ", regmode: COMMON");
2438 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2439 strcat (buf
, ", r4 not used");
2441 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2442 strcat (buf
, ", r30 not used");
2444 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2445 strcat (buf
, ", r5 not used");
2447 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2448 strcat (buf
, ", r2 not used");
2450 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2452 switch (e_flags
& - e_flags
)
2454 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2455 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2456 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2457 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2458 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2459 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2460 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2461 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2462 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2463 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2464 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2465 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2466 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2467 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2468 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2469 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2476 case EM_CYGNUS_V850
:
2477 switch (e_flags
& EF_V850_ARCH
)
2479 case E_V850E2V3_ARCH
:
2480 strcat (buf
, ", v850e2v3");
2483 strcat (buf
, ", v850e2");
2486 strcat (buf
, ", v850e1");
2489 strcat (buf
, ", v850e");
2492 strcat (buf
, ", v850");
2495 strcat (buf
, _(", unknown v850 architecture variant"));
2501 case EM_CYGNUS_M32R
:
2502 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2503 strcat (buf
, ", m32r");
2507 case EM_MIPS_RS3_LE
:
2508 if (e_flags
& EF_MIPS_NOREORDER
)
2509 strcat (buf
, ", noreorder");
2511 if (e_flags
& EF_MIPS_PIC
)
2512 strcat (buf
, ", pic");
2514 if (e_flags
& EF_MIPS_CPIC
)
2515 strcat (buf
, ", cpic");
2517 if (e_flags
& EF_MIPS_UCODE
)
2518 strcat (buf
, ", ugen_reserved");
2520 if (e_flags
& EF_MIPS_ABI2
)
2521 strcat (buf
, ", abi2");
2523 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2524 strcat (buf
, ", odk first");
2526 if (e_flags
& EF_MIPS_32BITMODE
)
2527 strcat (buf
, ", 32bitmode");
2529 switch ((e_flags
& EF_MIPS_MACH
))
2531 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2532 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2533 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2534 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2535 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2536 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2537 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2538 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2539 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2540 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2541 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2542 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2543 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2544 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2545 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2546 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2548 /* We simply ignore the field in this case to avoid confusion:
2549 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2552 default: strcat (buf
, _(", unknown CPU")); break;
2555 switch ((e_flags
& EF_MIPS_ABI
))
2557 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2558 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2559 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2560 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2562 /* We simply ignore the field in this case to avoid confusion:
2563 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2564 This means it is likely to be an o32 file, but not for
2567 default: strcat (buf
, _(", unknown ABI")); break;
2570 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2571 strcat (buf
, ", mdmx");
2573 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2574 strcat (buf
, ", mips16");
2576 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2577 strcat (buf
, ", micromips");
2579 switch ((e_flags
& EF_MIPS_ARCH
))
2581 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2582 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2583 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2584 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2585 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2586 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2587 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2588 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2589 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2590 default: strcat (buf
, _(", unknown ISA")); break;
2595 switch ((e_flags
& EF_SH_MACH_MASK
))
2597 case EF_SH1
: strcat (buf
, ", sh1"); break;
2598 case EF_SH2
: strcat (buf
, ", sh2"); break;
2599 case EF_SH3
: strcat (buf
, ", sh3"); break;
2600 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2601 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2602 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2603 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2604 case EF_SH4
: strcat (buf
, ", sh4"); break;
2605 case EF_SH5
: strcat (buf
, ", sh5"); break;
2606 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2607 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2608 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2609 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2610 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2611 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2612 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2613 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2614 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2615 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2616 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2617 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2618 default: strcat (buf
, _(", unknown ISA")); break;
2621 if (e_flags
& EF_SH_PIC
)
2622 strcat (buf
, ", pic");
2624 if (e_flags
& EF_SH_FDPIC
)
2625 strcat (buf
, ", fdpic");
2629 if (e_flags
& EF_SPARC_32PLUS
)
2630 strcat (buf
, ", v8+");
2632 if (e_flags
& EF_SPARC_SUN_US1
)
2633 strcat (buf
, ", ultrasparcI");
2635 if (e_flags
& EF_SPARC_SUN_US3
)
2636 strcat (buf
, ", ultrasparcIII");
2638 if (e_flags
& EF_SPARC_HAL_R1
)
2639 strcat (buf
, ", halr1");
2641 if (e_flags
& EF_SPARC_LEDATA
)
2642 strcat (buf
, ", ledata");
2644 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2645 strcat (buf
, ", tso");
2647 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2648 strcat (buf
, ", pso");
2650 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2651 strcat (buf
, ", rmo");
2655 switch (e_flags
& EF_PARISC_ARCH
)
2657 case EFA_PARISC_1_0
:
2658 strcpy (buf
, ", PA-RISC 1.0");
2660 case EFA_PARISC_1_1
:
2661 strcpy (buf
, ", PA-RISC 1.1");
2663 case EFA_PARISC_2_0
:
2664 strcpy (buf
, ", PA-RISC 2.0");
2669 if (e_flags
& EF_PARISC_TRAPNIL
)
2670 strcat (buf
, ", trapnil");
2671 if (e_flags
& EF_PARISC_EXT
)
2672 strcat (buf
, ", ext");
2673 if (e_flags
& EF_PARISC_LSB
)
2674 strcat (buf
, ", lsb");
2675 if (e_flags
& EF_PARISC_WIDE
)
2676 strcat (buf
, ", wide");
2677 if (e_flags
& EF_PARISC_NO_KABP
)
2678 strcat (buf
, ", no kabp");
2679 if (e_flags
& EF_PARISC_LAZYSWAP
)
2680 strcat (buf
, ", lazyswap");
2685 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2686 strcat (buf
, ", new calling convention");
2688 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2689 strcat (buf
, ", gnu calling convention");
2693 if ((e_flags
& EF_IA_64_ABI64
))
2694 strcat (buf
, ", 64-bit");
2696 strcat (buf
, ", 32-bit");
2697 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2698 strcat (buf
, ", reduced fp model");
2699 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2700 strcat (buf
, ", no function descriptors, constant gp");
2701 else if ((e_flags
& EF_IA_64_CONS_GP
))
2702 strcat (buf
, ", constant gp");
2703 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2704 strcat (buf
, ", absolute");
2705 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2707 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2708 strcat (buf
, ", vms_linkages");
2709 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2711 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2713 case EF_IA_64_VMS_COMCOD_WARNING
:
2714 strcat (buf
, ", warning");
2716 case EF_IA_64_VMS_COMCOD_ERROR
:
2717 strcat (buf
, ", error");
2719 case EF_IA_64_VMS_COMCOD_ABORT
:
2720 strcat (buf
, ", abort");
2729 if ((e_flags
& EF_VAX_NONPIC
))
2730 strcat (buf
, ", non-PIC");
2731 if ((e_flags
& EF_VAX_DFLOAT
))
2732 strcat (buf
, ", D-Float");
2733 if ((e_flags
& EF_VAX_GFLOAT
))
2734 strcat (buf
, ", G-Float");
2738 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2739 strcat (buf
, ", 64-bit doubles");
2740 if (e_flags
& E_FLAG_RX_DSP
)
2741 strcat (buf
, ", dsp");
2742 if (e_flags
& E_FLAG_RX_PID
)
2743 strcat (buf
, ", pid");
2744 if (e_flags
& E_FLAG_RX_ABI
)
2745 strcat (buf
, ", RX ABI");
2749 if (e_flags
& EF_S390_HIGH_GPRS
)
2750 strcat (buf
, ", highgprs");
2754 if ((e_flags
& EF_C6000_REL
))
2755 strcat (buf
, ", relocatable module");
2764 get_osabi_name (unsigned int osabi
)
2766 static char buff
[32];
2770 case ELFOSABI_NONE
: return "UNIX - System V";
2771 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2772 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2773 case ELFOSABI_GNU
: return "UNIX - GNU";
2774 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2775 case ELFOSABI_AIX
: return "UNIX - AIX";
2776 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2777 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2778 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2779 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2780 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2781 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2782 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2783 case ELFOSABI_AROS
: return "AROS";
2784 case ELFOSABI_FENIXOS
: return "FenixOS";
2787 switch (elf_header
.e_machine
)
2792 case ELFOSABI_ARM
: return "ARM";
2802 case ELFOSABI_STANDALONE
: return _("Standalone App");
2811 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2812 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2821 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2827 get_aarch64_segment_type (unsigned long type
)
2831 case PT_AARCH64_ARCHEXT
:
2832 return "AARCH64_ARCHEXT";
2841 get_arm_segment_type (unsigned long type
)
2855 get_mips_segment_type (unsigned long type
)
2859 case PT_MIPS_REGINFO
:
2861 case PT_MIPS_RTPROC
:
2863 case PT_MIPS_OPTIONS
:
2873 get_parisc_segment_type (unsigned long type
)
2877 case PT_HP_TLS
: return "HP_TLS";
2878 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2879 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2880 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2881 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2882 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2883 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2884 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2885 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2886 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2887 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2888 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2889 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2890 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2891 case PT_HP_STACK
: return "HP_STACK";
2892 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2893 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2894 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2895 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2904 get_ia64_segment_type (unsigned long type
)
2908 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2909 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2910 case PT_HP_TLS
: return "HP_TLS";
2911 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2912 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2913 case PT_IA_64_HP_STACK
: return "HP_STACK";
2922 get_tic6x_segment_type (unsigned long type
)
2926 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2935 get_segment_type (unsigned long p_type
)
2937 static char buff
[32];
2941 case PT_NULL
: return "NULL";
2942 case PT_LOAD
: return "LOAD";
2943 case PT_DYNAMIC
: return "DYNAMIC";
2944 case PT_INTERP
: return "INTERP";
2945 case PT_NOTE
: return "NOTE";
2946 case PT_SHLIB
: return "SHLIB";
2947 case PT_PHDR
: return "PHDR";
2948 case PT_TLS
: return "TLS";
2950 case PT_GNU_EH_FRAME
:
2951 return "GNU_EH_FRAME";
2952 case PT_GNU_STACK
: return "GNU_STACK";
2953 case PT_GNU_RELRO
: return "GNU_RELRO";
2956 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2958 const char * result
;
2960 switch (elf_header
.e_machine
)
2963 result
= get_aarch64_segment_type (p_type
);
2966 result
= get_arm_segment_type (p_type
);
2969 case EM_MIPS_RS3_LE
:
2970 result
= get_mips_segment_type (p_type
);
2973 result
= get_parisc_segment_type (p_type
);
2976 result
= get_ia64_segment_type (p_type
);
2979 result
= get_tic6x_segment_type (p_type
);
2989 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2991 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2993 const char * result
;
2995 switch (elf_header
.e_machine
)
2998 result
= get_parisc_segment_type (p_type
);
3001 result
= get_ia64_segment_type (p_type
);
3011 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3014 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3021 get_mips_section_type_name (unsigned int sh_type
)
3025 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3026 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3027 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3028 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3029 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3030 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3031 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3032 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3033 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3034 case SHT_MIPS_RELD
: return "MIPS_RELD";
3035 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3036 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3037 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3038 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3039 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3040 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3041 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3042 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3043 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3044 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3045 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3046 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3047 case SHT_MIPS_LINE
: return "MIPS_LINE";
3048 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3049 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3050 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3051 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3052 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3053 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3054 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3055 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3056 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3057 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3058 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3059 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3060 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3061 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3062 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3063 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3071 get_parisc_section_type_name (unsigned int sh_type
)
3075 case SHT_PARISC_EXT
: return "PARISC_EXT";
3076 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3077 case SHT_PARISC_DOC
: return "PARISC_DOC";
3078 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3079 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3080 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3081 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3089 get_ia64_section_type_name (unsigned int sh_type
)
3091 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3092 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3093 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3097 case SHT_IA_64_EXT
: return "IA_64_EXT";
3098 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3099 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3100 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3101 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3102 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3103 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3104 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3105 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3106 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3114 get_x86_64_section_type_name (unsigned int sh_type
)
3118 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3126 get_aarch64_section_type_name (unsigned int sh_type
)
3130 case SHT_AARCH64_ATTRIBUTES
:
3131 return "AARCH64_ATTRIBUTES";
3139 get_arm_section_type_name (unsigned int sh_type
)
3143 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3144 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3145 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3146 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3147 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3155 get_tic6x_section_type_name (unsigned int sh_type
)
3159 case SHT_C6000_UNWIND
:
3160 return "C6000_UNWIND";
3161 case SHT_C6000_PREEMPTMAP
:
3162 return "C6000_PREEMPTMAP";
3163 case SHT_C6000_ATTRIBUTES
:
3164 return "C6000_ATTRIBUTES";
3169 case SHT_TI_HANDLER
:
3170 return "TI_HANDLER";
3171 case SHT_TI_INITINFO
:
3172 return "TI_INITINFO";
3173 case SHT_TI_PHATTRS
:
3174 return "TI_PHATTRS";
3182 get_section_type_name (unsigned int sh_type
)
3184 static char buff
[32];
3188 case SHT_NULL
: return "NULL";
3189 case SHT_PROGBITS
: return "PROGBITS";
3190 case SHT_SYMTAB
: return "SYMTAB";
3191 case SHT_STRTAB
: return "STRTAB";
3192 case SHT_RELA
: return "RELA";
3193 case SHT_HASH
: return "HASH";
3194 case SHT_DYNAMIC
: return "DYNAMIC";
3195 case SHT_NOTE
: return "NOTE";
3196 case SHT_NOBITS
: return "NOBITS";
3197 case SHT_REL
: return "REL";
3198 case SHT_SHLIB
: return "SHLIB";
3199 case SHT_DYNSYM
: return "DYNSYM";
3200 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3201 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3202 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3203 case SHT_GNU_HASH
: return "GNU_HASH";
3204 case SHT_GROUP
: return "GROUP";
3205 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3206 case SHT_GNU_verdef
: return "VERDEF";
3207 case SHT_GNU_verneed
: return "VERNEED";
3208 case SHT_GNU_versym
: return "VERSYM";
3209 case 0x6ffffff0: return "VERSYM";
3210 case 0x6ffffffc: return "VERDEF";
3211 case 0x7ffffffd: return "AUXILIARY";
3212 case 0x7fffffff: return "FILTER";
3213 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3216 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3218 const char * result
;
3220 switch (elf_header
.e_machine
)
3223 case EM_MIPS_RS3_LE
:
3224 result
= get_mips_section_type_name (sh_type
);
3227 result
= get_parisc_section_type_name (sh_type
);
3230 result
= get_ia64_section_type_name (sh_type
);
3235 result
= get_x86_64_section_type_name (sh_type
);
3238 result
= get_aarch64_section_type_name (sh_type
);
3241 result
= get_arm_section_type_name (sh_type
);
3244 result
= get_tic6x_section_type_name (sh_type
);
3254 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3256 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3258 const char * result
;
3260 switch (elf_header
.e_machine
)
3263 result
= get_ia64_section_type_name (sh_type
);
3273 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3275 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3276 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3278 /* This message is probably going to be displayed in a 15
3279 character wide field, so put the hex value first. */
3280 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3286 #define OPTION_DEBUG_DUMP 512
3287 #define OPTION_DYN_SYMS 513
3288 #define OPTION_DWARF_DEPTH 514
3289 #define OPTION_DWARF_START 515
3290 #define OPTION_DWARF_CHECK 516
3292 static struct option options
[] =
3294 {"all", no_argument
, 0, 'a'},
3295 {"file-header", no_argument
, 0, 'h'},
3296 {"program-headers", no_argument
, 0, 'l'},
3297 {"headers", no_argument
, 0, 'e'},
3298 {"histogram", no_argument
, 0, 'I'},
3299 {"segments", no_argument
, 0, 'l'},
3300 {"sections", no_argument
, 0, 'S'},
3301 {"section-headers", no_argument
, 0, 'S'},
3302 {"section-groups", no_argument
, 0, 'g'},
3303 {"section-details", no_argument
, 0, 't'},
3304 {"full-section-name",no_argument
, 0, 'N'},
3305 {"symbols", no_argument
, 0, 's'},
3306 {"syms", no_argument
, 0, 's'},
3307 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3308 {"relocs", no_argument
, 0, 'r'},
3309 {"notes", no_argument
, 0, 'n'},
3310 {"dynamic", no_argument
, 0, 'd'},
3311 {"arch-specific", no_argument
, 0, 'A'},
3312 {"version-info", no_argument
, 0, 'V'},
3313 {"use-dynamic", no_argument
, 0, 'D'},
3314 {"unwind", no_argument
, 0, 'u'},
3315 {"archive-index", no_argument
, 0, 'c'},
3316 {"hex-dump", required_argument
, 0, 'x'},
3317 {"relocated-dump", required_argument
, 0, 'R'},
3318 {"string-dump", required_argument
, 0, 'p'},
3319 #ifdef SUPPORT_DISASSEMBLY
3320 {"instruction-dump", required_argument
, 0, 'i'},
3322 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3324 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3325 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3326 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3328 {"version", no_argument
, 0, 'v'},
3329 {"wide", no_argument
, 0, 'W'},
3330 {"help", no_argument
, 0, 'H'},
3331 {0, no_argument
, 0, 0}
3335 usage (FILE * stream
)
3337 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3338 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3339 fprintf (stream
, _(" Options are:\n\
3340 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3341 -h --file-header Display the ELF file header\n\
3342 -l --program-headers Display the program headers\n\
3343 --segments An alias for --program-headers\n\
3344 -S --section-headers Display the sections' header\n\
3345 --sections An alias for --section-headers\n\
3346 -g --section-groups Display the section groups\n\
3347 -t --section-details Display the section details\n\
3348 -e --headers Equivalent to: -h -l -S\n\
3349 -s --syms Display the symbol table\n\
3350 --symbols An alias for --syms\n\
3351 --dyn-syms Display the dynamic symbol table\n\
3352 -n --notes Display the core notes (if present)\n\
3353 -r --relocs Display the relocations (if present)\n\
3354 -u --unwind Display the unwind info (if present)\n\
3355 -d --dynamic Display the dynamic section (if present)\n\
3356 -V --version-info Display the version sections (if present)\n\
3357 -A --arch-specific Display architecture specific information (if any)\n\
3358 -c --archive-index Display the symbol/file index in an archive\n\
3359 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3360 -x --hex-dump=<number|name>\n\
3361 Dump the contents of section <number|name> as bytes\n\
3362 -p --string-dump=<number|name>\n\
3363 Dump the contents of section <number|name> as strings\n\
3364 -R --relocated-dump=<number|name>\n\
3365 Dump the contents of section <number|name> as relocated bytes\n\
3366 -w[lLiaprmfFsoRt] or\n\
3367 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3368 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3369 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3371 Display the contents of DWARF2 debug sections\n"));
3372 fprintf (stream
, _("\
3373 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3374 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3376 #ifdef SUPPORT_DISASSEMBLY
3377 fprintf (stream
, _("\
3378 -i --instruction-dump=<number|name>\n\
3379 Disassemble the contents of section <number|name>\n"));
3381 fprintf (stream
, _("\
3382 -I --histogram Display histogram of bucket list lengths\n\
3383 -W --wide Allow output width to exceed 80 characters\n\
3384 @<file> Read options from <file>\n\
3385 -H --help Display this information\n\
3386 -v --version Display the version number of readelf\n"));
3388 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3389 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3391 exit (stream
== stdout
? 0 : 1);
3394 /* Record the fact that the user wants the contents of section number
3395 SECTION to be displayed using the method(s) encoded as flags bits
3396 in TYPE. Note, TYPE can be zero if we are creating the array for
3400 request_dump_bynumber (unsigned int section
, dump_type type
)
3402 if (section
>= num_dump_sects
)
3404 dump_type
* new_dump_sects
;
3406 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3407 sizeof (* dump_sects
));
3409 if (new_dump_sects
== NULL
)
3410 error (_("Out of memory allocating dump request table.\n"));
3413 /* Copy current flag settings. */
3414 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3418 dump_sects
= new_dump_sects
;
3419 num_dump_sects
= section
+ 1;
3424 dump_sects
[section
] |= type
;
3429 /* Request a dump by section name. */
3432 request_dump_byname (const char * section
, dump_type type
)
3434 struct dump_list_entry
* new_request
;
3436 new_request
= (struct dump_list_entry
*)
3437 malloc (sizeof (struct dump_list_entry
));
3439 error (_("Out of memory allocating dump request table.\n"));
3441 new_request
->name
= strdup (section
);
3442 if (!new_request
->name
)
3443 error (_("Out of memory allocating dump request table.\n"));
3445 new_request
->type
= type
;
3447 new_request
->next
= dump_sects_byname
;
3448 dump_sects_byname
= new_request
;
3452 request_dump (dump_type type
)
3458 section
= strtoul (optarg
, & cp
, 0);
3460 if (! *cp
&& section
>= 0)
3461 request_dump_bynumber (section
, type
);
3463 request_dump_byname (optarg
, type
);
3468 parse_args (int argc
, char ** argv
)
3475 while ((c
= getopt_long
3476 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3494 do_section_groups
++;
3502 do_section_groups
++;
3507 do_section_details
++;
3551 request_dump (HEX_DUMP
);
3554 request_dump (STRING_DUMP
);
3557 request_dump (RELOC_DUMP
);
3564 dwarf_select_sections_all ();
3569 dwarf_select_sections_by_letters (optarg
);
3572 case OPTION_DEBUG_DUMP
:
3579 dwarf_select_sections_by_names (optarg
);
3582 case OPTION_DWARF_DEPTH
:
3586 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3589 case OPTION_DWARF_START
:
3593 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3596 case OPTION_DWARF_CHECK
:
3599 case OPTION_DYN_SYMS
:
3602 #ifdef SUPPORT_DISASSEMBLY
3604 request_dump (DISASS_DUMP
);
3608 print_version (program_name
);
3617 /* xgettext:c-format */
3618 error (_("Invalid option '-%c'\n"), c
);
3625 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3626 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3627 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3628 && !do_section_groups
&& !do_archive_index
3633 warn (_("Nothing to do.\n"));
3639 get_elf_class (unsigned int elf_class
)
3641 static char buff
[32];
3645 case ELFCLASSNONE
: return _("none");
3646 case ELFCLASS32
: return "ELF32";
3647 case ELFCLASS64
: return "ELF64";
3649 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3655 get_data_encoding (unsigned int encoding
)
3657 static char buff
[32];
3661 case ELFDATANONE
: return _("none");
3662 case ELFDATA2LSB
: return _("2's complement, little endian");
3663 case ELFDATA2MSB
: return _("2's complement, big endian");
3665 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3670 /* Decode the data held in 'elf_header'. */
3673 process_file_header (void)
3675 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3676 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3677 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3678 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3681 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3685 init_dwarf_regnames (elf_header
.e_machine
);
3691 printf (_("ELF Header:\n"));
3692 printf (_(" Magic: "));
3693 for (i
= 0; i
< EI_NIDENT
; i
++)
3694 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3696 printf (_(" Class: %s\n"),
3697 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3698 printf (_(" Data: %s\n"),
3699 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3700 printf (_(" Version: %d %s\n"),
3701 elf_header
.e_ident
[EI_VERSION
],
3702 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3704 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3705 ? _("<unknown: %lx>")
3707 printf (_(" OS/ABI: %s\n"),
3708 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3709 printf (_(" ABI Version: %d\n"),
3710 elf_header
.e_ident
[EI_ABIVERSION
]);
3711 printf (_(" Type: %s\n"),
3712 get_file_type (elf_header
.e_type
));
3713 printf (_(" Machine: %s\n"),
3714 get_machine_name (elf_header
.e_machine
));
3715 printf (_(" Version: 0x%lx\n"),
3716 (unsigned long) elf_header
.e_version
);
3718 printf (_(" Entry point address: "));
3719 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3720 printf (_("\n Start of program headers: "));
3721 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3722 printf (_(" (bytes into file)\n Start of section headers: "));
3723 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3724 printf (_(" (bytes into file)\n"));
3726 printf (_(" Flags: 0x%lx%s\n"),
3727 (unsigned long) elf_header
.e_flags
,
3728 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3729 printf (_(" Size of this header: %ld (bytes)\n"),
3730 (long) elf_header
.e_ehsize
);
3731 printf (_(" Size of program headers: %ld (bytes)\n"),
3732 (long) elf_header
.e_phentsize
);
3733 printf (_(" Number of program headers: %ld"),
3734 (long) elf_header
.e_phnum
);
3735 if (section_headers
!= NULL
3736 && elf_header
.e_phnum
== PN_XNUM
3737 && section_headers
[0].sh_info
!= 0)
3738 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3739 putc ('\n', stdout
);
3740 printf (_(" Size of section headers: %ld (bytes)\n"),
3741 (long) elf_header
.e_shentsize
);
3742 printf (_(" Number of section headers: %ld"),
3743 (long) elf_header
.e_shnum
);
3744 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3745 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3746 putc ('\n', stdout
);
3747 printf (_(" Section header string table index: %ld"),
3748 (long) elf_header
.e_shstrndx
);
3749 if (section_headers
!= NULL
3750 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3751 printf (" (%u)", section_headers
[0].sh_link
);
3752 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3753 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3754 printf (_(" <corrupt: out of range>"));
3755 putc ('\n', stdout
);
3758 if (section_headers
!= NULL
)
3760 if (elf_header
.e_phnum
== PN_XNUM
3761 && section_headers
[0].sh_info
!= 0)
3762 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3763 if (elf_header
.e_shnum
== SHN_UNDEF
)
3764 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3765 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3766 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3767 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3768 elf_header
.e_shstrndx
= SHN_UNDEF
;
3769 free (section_headers
);
3770 section_headers
= NULL
;
3778 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3780 Elf32_External_Phdr
* phdrs
;
3781 Elf32_External_Phdr
* external
;
3782 Elf_Internal_Phdr
* internal
;
3785 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3786 elf_header
.e_phentsize
,
3788 _("program headers"));
3792 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3793 i
< elf_header
.e_phnum
;
3794 i
++, internal
++, external
++)
3796 internal
->p_type
= BYTE_GET (external
->p_type
);
3797 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3798 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3799 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3800 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3801 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3802 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3803 internal
->p_align
= BYTE_GET (external
->p_align
);
3812 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3814 Elf64_External_Phdr
* phdrs
;
3815 Elf64_External_Phdr
* external
;
3816 Elf_Internal_Phdr
* internal
;
3819 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3820 elf_header
.e_phentsize
,
3822 _("program headers"));
3826 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3827 i
< elf_header
.e_phnum
;
3828 i
++, internal
++, external
++)
3830 internal
->p_type
= BYTE_GET (external
->p_type
);
3831 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3832 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3833 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3834 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3835 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3836 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3837 internal
->p_align
= BYTE_GET (external
->p_align
);
3845 /* Returns 1 if the program headers were read into `program_headers'. */
3848 get_program_headers (FILE * file
)
3850 Elf_Internal_Phdr
* phdrs
;
3852 /* Check cache of prior read. */
3853 if (program_headers
!= NULL
)
3856 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3857 sizeof (Elf_Internal_Phdr
));
3861 error (_("Out of memory\n"));
3866 ? get_32bit_program_headers (file
, phdrs
)
3867 : get_64bit_program_headers (file
, phdrs
))
3869 program_headers
= phdrs
;
3877 /* Returns 1 if the program headers were loaded. */
3880 process_program_headers (FILE * file
)
3882 Elf_Internal_Phdr
* segment
;
3885 if (elf_header
.e_phnum
== 0)
3887 /* PR binutils/12467. */
3888 if (elf_header
.e_phoff
!= 0)
3889 warn (_("possibly corrupt ELF header - it has a non-zero program"
3890 " header offset, but no program headers"));
3891 else if (do_segments
)
3892 printf (_("\nThere are no program headers in this file.\n"));
3896 if (do_segments
&& !do_header
)
3898 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3899 printf (_("Entry point "));
3900 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3901 printf (_("\nThere are %d program headers, starting at offset "),
3902 elf_header
.e_phnum
);
3903 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3907 if (! get_program_headers (file
))
3912 if (elf_header
.e_phnum
> 1)
3913 printf (_("\nProgram Headers:\n"));
3915 printf (_("\nProgram Headers:\n"));
3919 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3922 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3926 (_(" Type Offset VirtAddr PhysAddr\n"));
3928 (_(" FileSiz MemSiz Flags Align\n"));
3935 for (i
= 0, segment
= program_headers
;
3936 i
< elf_header
.e_phnum
;
3941 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3945 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3946 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3947 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3948 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3949 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3951 (segment
->p_flags
& PF_R
? 'R' : ' '),
3952 (segment
->p_flags
& PF_W
? 'W' : ' '),
3953 (segment
->p_flags
& PF_X
? 'E' : ' '));
3954 printf ("%#lx", (unsigned long) segment
->p_align
);
3958 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3959 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3962 print_vma (segment
->p_offset
, FULL_HEX
);
3966 print_vma (segment
->p_vaddr
, FULL_HEX
);
3968 print_vma (segment
->p_paddr
, FULL_HEX
);
3971 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3972 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3975 print_vma (segment
->p_filesz
, FULL_HEX
);
3979 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3980 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3983 print_vma (segment
->p_memsz
, FULL_HEX
);
3987 (segment
->p_flags
& PF_R
? 'R' : ' '),
3988 (segment
->p_flags
& PF_W
? 'W' : ' '),
3989 (segment
->p_flags
& PF_X
? 'E' : ' '));
3991 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3992 printf ("%#lx", (unsigned long) segment
->p_align
);
3995 print_vma (segment
->p_align
, PREFIX_HEX
);
4000 print_vma (segment
->p_offset
, FULL_HEX
);
4002 print_vma (segment
->p_vaddr
, FULL_HEX
);
4004 print_vma (segment
->p_paddr
, FULL_HEX
);
4006 print_vma (segment
->p_filesz
, FULL_HEX
);
4008 print_vma (segment
->p_memsz
, FULL_HEX
);
4010 (segment
->p_flags
& PF_R
? 'R' : ' '),
4011 (segment
->p_flags
& PF_W
? 'W' : ' '),
4012 (segment
->p_flags
& PF_X
? 'E' : ' '));
4013 print_vma (segment
->p_align
, HEX
);
4017 switch (segment
->p_type
)
4021 error (_("more than one dynamic segment\n"));
4023 /* By default, assume that the .dynamic section is the first
4024 section in the DYNAMIC segment. */
4025 dynamic_addr
= segment
->p_offset
;
4026 dynamic_size
= segment
->p_filesz
;
4028 /* Try to locate the .dynamic section. If there is
4029 a section header table, we can easily locate it. */
4030 if (section_headers
!= NULL
)
4032 Elf_Internal_Shdr
* sec
;
4034 sec
= find_section (".dynamic");
4035 if (sec
== NULL
|| sec
->sh_size
== 0)
4037 /* A corresponding .dynamic section is expected, but on
4038 IA-64/OpenVMS it is OK for it to be missing. */
4039 if (!is_ia64_vms ())
4040 error (_("no .dynamic section in the dynamic segment\n"));
4044 if (sec
->sh_type
== SHT_NOBITS
)
4050 dynamic_addr
= sec
->sh_offset
;
4051 dynamic_size
= sec
->sh_size
;
4053 if (dynamic_addr
< segment
->p_offset
4054 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4055 warn (_("the .dynamic section is not contained"
4056 " within the dynamic segment\n"));
4057 else if (dynamic_addr
> segment
->p_offset
)
4058 warn (_("the .dynamic section is not the first section"
4059 " in the dynamic segment.\n"));
4064 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4066 error (_("Unable to find program interpreter name\n"));
4070 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4072 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4073 error (_("Internal error: failed to create format string to display program interpreter\n"));
4075 program_interpreter
[0] = 0;
4076 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4077 error (_("Unable to read program interpreter name\n"));
4080 printf (_("\n [Requesting program interpreter: %s]"),
4081 program_interpreter
);
4087 putc ('\n', stdout
);
4090 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4092 printf (_("\n Section to Segment mapping:\n"));
4093 printf (_(" Segment Sections...\n"));
4095 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4098 Elf_Internal_Shdr
* section
;
4100 segment
= program_headers
+ i
;
4101 section
= section_headers
+ 1;
4103 printf (" %2.2d ", i
);
4105 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4107 if (!ELF_TBSS_SPECIAL (section
, segment
)
4108 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4109 printf ("%s ", SECTION_NAME (section
));
4120 /* Find the file offset corresponding to VMA by using the program headers. */
4123 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4125 Elf_Internal_Phdr
* seg
;
4127 if (! get_program_headers (file
))
4129 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4133 for (seg
= program_headers
;
4134 seg
< program_headers
+ elf_header
.e_phnum
;
4137 if (seg
->p_type
!= PT_LOAD
)
4140 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4141 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4142 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4145 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4146 (unsigned long) vma
);
4152 get_32bit_section_headers (FILE * file
, unsigned int num
)
4154 Elf32_External_Shdr
* shdrs
;
4155 Elf_Internal_Shdr
* internal
;
4158 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4159 elf_header
.e_shentsize
, num
,
4160 _("section headers"));
4164 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4165 sizeof (Elf_Internal_Shdr
));
4167 if (section_headers
== NULL
)
4169 error (_("Out of memory\n"));
4173 for (i
= 0, internal
= section_headers
;
4177 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4178 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4179 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4180 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4181 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4182 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4183 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4184 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4185 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4186 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4195 get_64bit_section_headers (FILE * file
, unsigned int num
)
4197 Elf64_External_Shdr
* shdrs
;
4198 Elf_Internal_Shdr
* internal
;
4201 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4202 elf_header
.e_shentsize
, num
,
4203 _("section headers"));
4207 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4208 sizeof (Elf_Internal_Shdr
));
4210 if (section_headers
== NULL
)
4212 error (_("Out of memory\n"));
4216 for (i
= 0, internal
= section_headers
;
4220 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4221 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4222 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4223 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4224 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4225 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4226 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4227 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4228 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4229 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4237 static Elf_Internal_Sym
*
4238 get_32bit_elf_symbols (FILE * file
,
4239 Elf_Internal_Shdr
* section
,
4240 unsigned long * num_syms_return
)
4242 unsigned long number
= 0;
4243 Elf32_External_Sym
* esyms
= NULL
;
4244 Elf_External_Sym_Shndx
* shndx
= NULL
;
4245 Elf_Internal_Sym
* isyms
= NULL
;
4246 Elf_Internal_Sym
* psym
;
4249 /* Run some sanity checks first. */
4250 if (section
->sh_entsize
== 0)
4252 error (_("sh_entsize is zero\n"));
4256 number
= section
->sh_size
/ section
->sh_entsize
;
4258 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4260 error (_("Invalid sh_entsize\n"));
4264 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4265 section
->sh_size
, _("symbols"));
4270 if (symtab_shndx_hdr
!= NULL
4271 && (symtab_shndx_hdr
->sh_link
4272 == (unsigned long) (section
- section_headers
)))
4274 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4275 symtab_shndx_hdr
->sh_offset
,
4276 1, symtab_shndx_hdr
->sh_size
,
4277 _("symbol table section indicies"));
4282 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4286 error (_("Out of memory\n"));
4290 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4292 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4293 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4294 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4295 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4296 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4298 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4299 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4300 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4301 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4302 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4311 if (num_syms_return
!= NULL
)
4312 * num_syms_return
= isyms
== NULL
? 0 : number
;
4317 static Elf_Internal_Sym
*
4318 get_64bit_elf_symbols (FILE * file
,
4319 Elf_Internal_Shdr
* section
,
4320 unsigned long * num_syms_return
)
4322 unsigned long number
= 0;
4323 Elf64_External_Sym
* esyms
= NULL
;
4324 Elf_External_Sym_Shndx
* shndx
= NULL
;
4325 Elf_Internal_Sym
* isyms
= NULL
;
4326 Elf_Internal_Sym
* psym
;
4329 /* Run some sanity checks first. */
4330 if (section
->sh_entsize
== 0)
4332 error (_("sh_entsize is zero\n"));
4336 number
= section
->sh_size
/ section
->sh_entsize
;
4338 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4340 error (_("Invalid sh_entsize\n"));
4344 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4345 section
->sh_size
, _("symbols"));
4349 if (symtab_shndx_hdr
!= NULL
4350 && (symtab_shndx_hdr
->sh_link
4351 == (unsigned long) (section
- section_headers
)))
4353 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4354 symtab_shndx_hdr
->sh_offset
,
4355 1, symtab_shndx_hdr
->sh_size
,
4356 _("symbol table section indicies"));
4361 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4365 error (_("Out of memory\n"));
4369 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4371 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4372 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4373 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4374 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4376 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4378 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4379 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4380 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4382 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4383 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4392 if (num_syms_return
!= NULL
)
4393 * num_syms_return
= isyms
== NULL
? 0 : number
;
4399 get_elf_section_flags (bfd_vma sh_flags
)
4401 static char buff
[1024];
4403 int field_size
= is_32bit_elf
? 8 : 16;
4405 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4406 bfd_vma os_flags
= 0;
4407 bfd_vma proc_flags
= 0;
4408 bfd_vma unknown_flags
= 0;
4416 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4417 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4418 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4419 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4420 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4421 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4422 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4423 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4424 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4425 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4426 /* IA-64 specific. */
4427 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4428 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4429 /* IA-64 OpenVMS specific. */
4430 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4431 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4432 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4433 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4434 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4435 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4437 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4438 /* SPARC specific. */
4439 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4442 if (do_section_details
)
4444 sprintf (buff
, "[%*.*lx]: ",
4445 field_size
, field_size
, (unsigned long) sh_flags
);
4446 p
+= field_size
+ 4;
4453 flag
= sh_flags
& - sh_flags
;
4456 if (do_section_details
)
4460 case SHF_WRITE
: sindex
= 0; break;
4461 case SHF_ALLOC
: sindex
= 1; break;
4462 case SHF_EXECINSTR
: sindex
= 2; break;
4463 case SHF_MERGE
: sindex
= 3; break;
4464 case SHF_STRINGS
: sindex
= 4; break;
4465 case SHF_INFO_LINK
: sindex
= 5; break;
4466 case SHF_LINK_ORDER
: sindex
= 6; break;
4467 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4468 case SHF_GROUP
: sindex
= 8; break;
4469 case SHF_TLS
: sindex
= 9; break;
4470 case SHF_EXCLUDE
: sindex
= 18; break;
4474 switch (elf_header
.e_machine
)
4477 if (flag
== SHF_IA_64_SHORT
)
4479 else if (flag
== SHF_IA_64_NORECOV
)
4482 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4485 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4486 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4487 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4488 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4489 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4490 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4501 case EM_OLD_SPARCV9
:
4502 case EM_SPARC32PLUS
:
4505 if (flag
== SHF_ORDERED
)
4515 if (p
!= buff
+ field_size
+ 4)
4517 if (size
< (10 + 2))
4524 size
-= flags
[sindex
].len
;
4525 p
= stpcpy (p
, flags
[sindex
].str
);
4527 else if (flag
& SHF_MASKOS
)
4529 else if (flag
& SHF_MASKPROC
)
4532 unknown_flags
|= flag
;
4538 case SHF_WRITE
: *p
= 'W'; break;
4539 case SHF_ALLOC
: *p
= 'A'; break;
4540 case SHF_EXECINSTR
: *p
= 'X'; break;
4541 case SHF_MERGE
: *p
= 'M'; break;
4542 case SHF_STRINGS
: *p
= 'S'; break;
4543 case SHF_INFO_LINK
: *p
= 'I'; break;
4544 case SHF_LINK_ORDER
: *p
= 'L'; break;
4545 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4546 case SHF_GROUP
: *p
= 'G'; break;
4547 case SHF_TLS
: *p
= 'T'; break;
4548 case SHF_EXCLUDE
: *p
= 'E'; break;
4551 if ((elf_header
.e_machine
== EM_X86_64
4552 || elf_header
.e_machine
== EM_L1OM
4553 || elf_header
.e_machine
== EM_K1OM
)
4554 && flag
== SHF_X86_64_LARGE
)
4556 else if (flag
& SHF_MASKOS
)
4559 sh_flags
&= ~ SHF_MASKOS
;
4561 else if (flag
& SHF_MASKPROC
)
4564 sh_flags
&= ~ SHF_MASKPROC
;
4574 if (do_section_details
)
4578 size
-= 5 + field_size
;
4579 if (p
!= buff
+ field_size
+ 4)
4587 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4588 (unsigned long) os_flags
);
4589 p
+= 5 + field_size
;
4593 size
-= 7 + field_size
;
4594 if (p
!= buff
+ field_size
+ 4)
4602 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4603 (unsigned long) proc_flags
);
4604 p
+= 7 + field_size
;
4608 size
-= 10 + field_size
;
4609 if (p
!= buff
+ field_size
+ 4)
4617 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4618 (unsigned long) unknown_flags
);
4619 p
+= 10 + field_size
;
4628 process_section_headers (FILE * file
)
4630 Elf_Internal_Shdr
* section
;
4633 section_headers
= NULL
;
4635 if (elf_header
.e_shnum
== 0)
4637 /* PR binutils/12467. */
4638 if (elf_header
.e_shoff
!= 0)
4639 warn (_("possibly corrupt ELF file header - it has a non-zero"
4640 " section header offset, but no section headers\n"));
4641 else if (do_sections
)
4642 printf (_("\nThere are no sections in this file.\n"));
4647 if (do_sections
&& !do_header
)
4648 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4649 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4653 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4656 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4659 /* Read in the string table, so that we have names to display. */
4660 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4661 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4663 section
= section_headers
+ elf_header
.e_shstrndx
;
4665 if (section
->sh_size
!= 0)
4667 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4668 1, section
->sh_size
,
4671 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4675 /* Scan the sections for the dynamic symbol table
4676 and dynamic string table and debug sections. */
4677 dynamic_symbols
= NULL
;
4678 dynamic_strings
= NULL
;
4679 dynamic_syminfo
= NULL
;
4680 symtab_shndx_hdr
= NULL
;
4682 eh_addr_size
= is_32bit_elf
? 4 : 8;
4683 switch (elf_header
.e_machine
)
4686 case EM_MIPS_RS3_LE
:
4687 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4688 FDE addresses. However, the ABI also has a semi-official ILP32
4689 variant for which the normal FDE address size rules apply.
4691 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4692 section, where XX is the size of longs in bits. Unfortunately,
4693 earlier compilers provided no way of distinguishing ILP32 objects
4694 from LP64 objects, so if there's any doubt, we should assume that
4695 the official LP64 form is being used. */
4696 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4697 && find_section (".gcc_compiled_long32") == NULL
)
4703 switch (elf_header
.e_flags
& EF_H8_MACH
)
4705 case E_H8_MACH_H8300
:
4706 case E_H8_MACH_H8300HN
:
4707 case E_H8_MACH_H8300SN
:
4708 case E_H8_MACH_H8300SXN
:
4711 case E_H8_MACH_H8300H
:
4712 case E_H8_MACH_H8300S
:
4713 case E_H8_MACH_H8300SX
:
4721 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4723 case EF_M32C_CPU_M16C
:
4730 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4733 size_t expected_entsize \
4734 = is_32bit_elf ? size32 : size64; \
4735 if (section->sh_entsize != expected_entsize) \
4736 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4737 i, (unsigned long int) section->sh_entsize, \
4738 (unsigned long int) expected_entsize); \
4739 section->sh_entsize = expected_entsize; \
4742 #define CHECK_ENTSIZE(section, i, type) \
4743 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4744 sizeof (Elf64_External_##type))
4746 for (i
= 0, section
= section_headers
;
4747 i
< elf_header
.e_shnum
;
4750 char * name
= SECTION_NAME (section
);
4752 if (section
->sh_type
== SHT_DYNSYM
)
4754 if (dynamic_symbols
!= NULL
)
4756 error (_("File contains multiple dynamic symbol tables\n"));
4760 CHECK_ENTSIZE (section
, i
, Sym
);
4761 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4763 else if (section
->sh_type
== SHT_STRTAB
4764 && streq (name
, ".dynstr"))
4766 if (dynamic_strings
!= NULL
)
4768 error (_("File contains multiple dynamic string tables\n"));
4772 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4773 1, section
->sh_size
,
4774 _("dynamic strings"));
4775 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4777 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4779 if (symtab_shndx_hdr
!= NULL
)
4781 error (_("File contains multiple symtab shndx tables\n"));
4784 symtab_shndx_hdr
= section
;
4786 else if (section
->sh_type
== SHT_SYMTAB
)
4787 CHECK_ENTSIZE (section
, i
, Sym
);
4788 else if (section
->sh_type
== SHT_GROUP
)
4789 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4790 else if (section
->sh_type
== SHT_REL
)
4791 CHECK_ENTSIZE (section
, i
, Rel
);
4792 else if (section
->sh_type
== SHT_RELA
)
4793 CHECK_ENTSIZE (section
, i
, Rela
);
4794 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4795 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4796 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4797 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4798 || do_debug_addr
|| do_debug_cu_index
)
4799 && (const_strneq (name
, ".debug_")
4800 || const_strneq (name
, ".zdebug_")))
4803 name
+= sizeof (".zdebug_") - 1;
4805 name
+= sizeof (".debug_") - 1;
4808 || (do_debug_info
&& const_strneq (name
, "info"))
4809 || (do_debug_info
&& const_strneq (name
, "types"))
4810 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4811 || (do_debug_lines
&& const_strneq (name
, "line"))
4812 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4813 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4814 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4815 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4816 || (do_debug_frames
&& const_strneq (name
, "frame"))
4817 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4818 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4819 || (do_debug_str
&& const_strneq (name
, "str"))
4820 || (do_debug_loc
&& const_strneq (name
, "loc"))
4821 || (do_debug_addr
&& const_strneq (name
, "addr"))
4822 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4823 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4825 request_dump_bynumber (i
, DEBUG_DUMP
);
4827 /* Linkonce section to be combined with .debug_info at link time. */
4828 else if ((do_debugging
|| do_debug_info
)
4829 && const_strneq (name
, ".gnu.linkonce.wi."))
4830 request_dump_bynumber (i
, DEBUG_DUMP
);
4831 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4832 request_dump_bynumber (i
, DEBUG_DUMP
);
4833 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4834 request_dump_bynumber (i
, DEBUG_DUMP
);
4835 /* Trace sections for Itanium VMS. */
4836 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4837 || do_trace_aranges
)
4838 && const_strneq (name
, ".trace_"))
4840 name
+= sizeof (".trace_") - 1;
4843 || (do_trace_info
&& streq (name
, "info"))
4844 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4845 || (do_trace_aranges
&& streq (name
, "aranges"))
4847 request_dump_bynumber (i
, DEBUG_DUMP
);
4855 if (elf_header
.e_shnum
> 1)
4856 printf (_("\nSection Headers:\n"));
4858 printf (_("\nSection Header:\n"));
4862 if (do_section_details
)
4864 printf (_(" [Nr] Name\n"));
4865 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4869 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4873 if (do_section_details
)
4875 printf (_(" [Nr] Name\n"));
4876 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4880 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4884 if (do_section_details
)
4886 printf (_(" [Nr] Name\n"));
4887 printf (_(" Type Address Offset Link\n"));
4888 printf (_(" Size EntSize Info Align\n"));
4892 printf (_(" [Nr] Name Type Address Offset\n"));
4893 printf (_(" Size EntSize Flags Link Info Align\n"));
4897 if (do_section_details
)
4898 printf (_(" Flags\n"));
4900 for (i
= 0, section
= section_headers
;
4901 i
< elf_header
.e_shnum
;
4904 printf (" [%2u] ", i
);
4905 if (do_section_details
)
4907 print_symbol (INT_MAX
, SECTION_NAME (section
));
4912 print_symbol (-17, SECTION_NAME (section
));
4915 printf (do_wide
? " %-15s " : " %-15.15s ",
4916 get_section_type_name (section
->sh_type
));
4920 const char * link_too_big
= NULL
;
4922 print_vma (section
->sh_addr
, LONG_HEX
);
4924 printf ( " %6.6lx %6.6lx %2.2lx",
4925 (unsigned long) section
->sh_offset
,
4926 (unsigned long) section
->sh_size
,
4927 (unsigned long) section
->sh_entsize
);
4929 if (do_section_details
)
4930 fputs (" ", stdout
);
4932 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4934 if (section
->sh_link
>= elf_header
.e_shnum
)
4937 /* The sh_link value is out of range. Normally this indicates
4938 an error but it can have special values in Solaris binaries. */
4939 switch (elf_header
.e_machine
)
4946 case EM_OLD_SPARCV9
:
4947 case EM_SPARC32PLUS
:
4950 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4951 link_too_big
= "BEFORE";
4952 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4953 link_too_big
= "AFTER";
4960 if (do_section_details
)
4962 if (link_too_big
!= NULL
&& * link_too_big
)
4963 printf ("<%s> ", link_too_big
);
4965 printf ("%2u ", section
->sh_link
);
4966 printf ("%3u %2lu\n", section
->sh_info
,
4967 (unsigned long) section
->sh_addralign
);
4970 printf ("%2u %3u %2lu\n",
4973 (unsigned long) section
->sh_addralign
);
4975 if (link_too_big
&& ! * link_too_big
)
4976 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4977 i
, section
->sh_link
);
4981 print_vma (section
->sh_addr
, LONG_HEX
);
4983 if ((long) section
->sh_offset
== section
->sh_offset
)
4984 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4988 print_vma (section
->sh_offset
, LONG_HEX
);
4991 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4992 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4996 print_vma (section
->sh_size
, LONG_HEX
);
4999 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5000 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5004 print_vma (section
->sh_entsize
, LONG_HEX
);
5007 if (do_section_details
)
5008 fputs (" ", stdout
);
5010 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5012 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5014 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5015 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5018 print_vma (section
->sh_addralign
, DEC
);
5022 else if (do_section_details
)
5024 printf (" %-15.15s ",
5025 get_section_type_name (section
->sh_type
));
5026 print_vma (section
->sh_addr
, LONG_HEX
);
5027 if ((long) section
->sh_offset
== section
->sh_offset
)
5028 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5032 print_vma (section
->sh_offset
, LONG_HEX
);
5034 printf (" %u\n ", section
->sh_link
);
5035 print_vma (section
->sh_size
, LONG_HEX
);
5037 print_vma (section
->sh_entsize
, LONG_HEX
);
5039 printf (" %-16u %lu\n",
5041 (unsigned long) section
->sh_addralign
);
5046 print_vma (section
->sh_addr
, LONG_HEX
);
5047 if ((long) section
->sh_offset
== section
->sh_offset
)
5048 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5052 print_vma (section
->sh_offset
, LONG_HEX
);
5055 print_vma (section
->sh_size
, LONG_HEX
);
5057 print_vma (section
->sh_entsize
, LONG_HEX
);
5059 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5061 printf (" %2u %3u %lu\n",
5064 (unsigned long) section
->sh_addralign
);
5067 if (do_section_details
)
5068 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5071 if (!do_section_details
)
5073 if (elf_header
.e_machine
== EM_X86_64
5074 || elf_header
.e_machine
== EM_L1OM
5075 || elf_header
.e_machine
== EM_K1OM
)
5076 printf (_("Key to Flags:\n\
5077 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5078 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5079 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5081 printf (_("Key to Flags:\n\
5082 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5083 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5084 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5091 get_group_flags (unsigned int flags
)
5093 static char buff
[32];
5103 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5110 process_section_groups (FILE * file
)
5112 Elf_Internal_Shdr
* section
;
5114 struct group
* group
;
5115 Elf_Internal_Shdr
* symtab_sec
;
5116 Elf_Internal_Shdr
* strtab_sec
;
5117 Elf_Internal_Sym
* symtab
;
5118 unsigned long num_syms
;
5122 /* Don't process section groups unless needed. */
5123 if (!do_unwind
&& !do_section_groups
)
5126 if (elf_header
.e_shnum
== 0)
5128 if (do_section_groups
)
5129 printf (_("\nThere are no sections to group in this file.\n"));
5134 if (section_headers
== NULL
)
5136 error (_("Section headers are not available!\n"));
5137 /* PR 13622: This can happen with a corrupt ELF header. */
5141 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5142 sizeof (struct group
*));
5144 if (section_headers_groups
== NULL
)
5146 error (_("Out of memory\n"));
5150 /* Scan the sections for the group section. */
5152 for (i
= 0, section
= section_headers
;
5153 i
< elf_header
.e_shnum
;
5155 if (section
->sh_type
== SHT_GROUP
)
5158 if (group_count
== 0)
5160 if (do_section_groups
)
5161 printf (_("\nThere are no section groups in this file.\n"));
5166 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5168 if (section_groups
== NULL
)
5170 error (_("Out of memory\n"));
5180 for (i
= 0, section
= section_headers
, group
= section_groups
;
5181 i
< elf_header
.e_shnum
;
5184 if (section
->sh_type
== SHT_GROUP
)
5186 char * name
= SECTION_NAME (section
);
5188 unsigned char * start
;
5189 unsigned char * indices
;
5190 unsigned int entry
, j
, size
;
5191 Elf_Internal_Shdr
* sec
;
5192 Elf_Internal_Sym
* sym
;
5194 /* Get the symbol table. */
5195 if (section
->sh_link
>= elf_header
.e_shnum
5196 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5199 error (_("Bad sh_link in group section `%s'\n"), name
);
5203 if (symtab_sec
!= sec
)
5208 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5213 error (_("Corrupt header in group section `%s'\n"), name
);
5217 if (section
->sh_info
>= num_syms
)
5219 error (_("Bad sh_info in group section `%s'\n"), name
);
5223 sym
= symtab
+ section
->sh_info
;
5225 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5227 if (sym
->st_shndx
== 0
5228 || sym
->st_shndx
>= elf_header
.e_shnum
)
5230 error (_("Bad sh_info in group section `%s'\n"), name
);
5234 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5243 /* Get the string table. */
5244 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5253 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5258 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5259 1, strtab_sec
->sh_size
,
5261 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5263 group_name
= sym
->st_name
< strtab_size
5264 ? strtab
+ sym
->st_name
: _("<corrupt>");
5267 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5268 1, section
->sh_size
,
5274 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5275 entry
= byte_get (indices
, 4);
5278 if (do_section_groups
)
5280 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5281 get_group_flags (entry
), i
, name
, group_name
, size
);
5283 printf (_(" [Index] Name\n"));
5286 group
->group_index
= i
;
5288 for (j
= 0; j
< size
; j
++)
5290 struct group_list
* g
;
5292 entry
= byte_get (indices
, 4);
5295 if (entry
>= elf_header
.e_shnum
)
5297 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5298 entry
, i
, elf_header
.e_shnum
- 1);
5302 if (section_headers_groups
[entry
] != NULL
)
5306 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5308 section_headers_groups
[entry
]->group_index
);
5313 /* Intel C/C++ compiler may put section 0 in a
5314 section group. We just warn it the first time
5315 and ignore it afterwards. */
5316 static int warned
= 0;
5319 error (_("section 0 in group section [%5u]\n"),
5320 section_headers_groups
[entry
]->group_index
);
5326 section_headers_groups
[entry
] = group
;
5328 if (do_section_groups
)
5330 sec
= section_headers
+ entry
;
5331 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5334 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5335 g
->section_index
= entry
;
5336 g
->next
= group
->root
;
5354 /* Data used to display dynamic fixups. */
5356 struct ia64_vms_dynfixup
5358 bfd_vma needed_ident
; /* Library ident number. */
5359 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5360 bfd_vma fixup_needed
; /* Index of the library. */
5361 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5362 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5365 /* Data used to display dynamic relocations. */
5367 struct ia64_vms_dynimgrela
5369 bfd_vma img_rela_cnt
; /* Number of relocations. */
5370 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5373 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5377 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5378 const char *strtab
, unsigned int strtab_sz
)
5380 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5382 const char *lib_name
;
5384 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5385 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5386 _("dynamic section image fixups"));
5390 if (fixup
->needed
< strtab_sz
)
5391 lib_name
= strtab
+ fixup
->needed
;
5394 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5395 (unsigned long) fixup
->needed
);
5398 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5399 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5401 (_("Seg Offset Type SymVec DataType\n"));
5403 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5408 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5409 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5410 type
= BYTE_GET (imfs
[i
].type
);
5411 rtype
= elf_ia64_reloc_type (type
);
5413 printf (" 0x%08x ", type
);
5415 printf (" %-32s ", rtype
);
5416 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5417 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5423 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5426 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5428 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5431 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5432 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5433 _("dynamic section image relocations"));
5437 printf (_("\nImage relocs\n"));
5439 (_("Seg Offset Type Addend Seg Sym Off\n"));
5441 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5446 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5447 printf ("%08" BFD_VMA_FMT
"x ",
5448 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5449 type
= BYTE_GET (imrs
[i
].type
);
5450 rtype
= elf_ia64_reloc_type (type
);
5452 printf ("0x%08x ", type
);
5454 printf ("%-31s ", rtype
);
5455 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5456 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5457 printf ("%08" BFD_VMA_FMT
"x\n",
5458 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5464 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5467 process_ia64_vms_dynamic_relocs (FILE *file
)
5469 struct ia64_vms_dynfixup fixup
;
5470 struct ia64_vms_dynimgrela imgrela
;
5471 Elf_Internal_Dyn
*entry
;
5473 bfd_vma strtab_off
= 0;
5474 bfd_vma strtab_sz
= 0;
5475 char *strtab
= NULL
;
5477 memset (&fixup
, 0, sizeof (fixup
));
5478 memset (&imgrela
, 0, sizeof (imgrela
));
5480 /* Note: the order of the entries is specified by the OpenVMS specs. */
5481 for (entry
= dynamic_section
;
5482 entry
< dynamic_section
+ dynamic_nent
;
5485 switch (entry
->d_tag
)
5487 case DT_IA_64_VMS_STRTAB_OFFSET
:
5488 strtab_off
= entry
->d_un
.d_val
;
5491 strtab_sz
= entry
->d_un
.d_val
;
5493 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5494 1, strtab_sz
, _("dynamic string section"));
5497 case DT_IA_64_VMS_NEEDED_IDENT
:
5498 fixup
.needed_ident
= entry
->d_un
.d_val
;
5501 fixup
.needed
= entry
->d_un
.d_val
;
5503 case DT_IA_64_VMS_FIXUP_NEEDED
:
5504 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5506 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5507 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5509 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5510 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5512 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5515 case DT_IA_64_VMS_IMG_RELA_CNT
:
5516 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5518 case DT_IA_64_VMS_IMG_RELA_OFF
:
5519 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5521 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5541 } dynamic_relocations
[] =
5543 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5544 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5545 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5548 /* Process the reloc section. */
5551 process_relocs (FILE * file
)
5553 unsigned long rel_size
;
5554 unsigned long rel_offset
;
5560 if (do_using_dynamic
)
5564 int has_dynamic_reloc
;
5567 has_dynamic_reloc
= 0;
5569 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5571 is_rela
= dynamic_relocations
[i
].rela
;
5572 name
= dynamic_relocations
[i
].name
;
5573 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5574 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5576 has_dynamic_reloc
|= rel_size
;
5578 if (is_rela
== UNKNOWN
)
5580 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5581 switch (dynamic_info
[DT_PLTREL
])
5595 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5596 name
, rel_offset
, rel_size
);
5598 dump_relocations (file
,
5599 offset_from_vma (file
, rel_offset
, rel_size
),
5601 dynamic_symbols
, num_dynamic_syms
,
5602 dynamic_strings
, dynamic_strings_length
, is_rela
);
5607 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5609 if (! has_dynamic_reloc
)
5610 printf (_("\nThere are no dynamic relocations in this file.\n"));
5614 Elf_Internal_Shdr
* section
;
5618 for (i
= 0, section
= section_headers
;
5619 i
< elf_header
.e_shnum
;
5622 if ( section
->sh_type
!= SHT_RELA
5623 && section
->sh_type
!= SHT_REL
)
5626 rel_offset
= section
->sh_offset
;
5627 rel_size
= section
->sh_size
;
5631 Elf_Internal_Shdr
* strsec
;
5634 printf (_("\nRelocation section "));
5636 if (string_table
== NULL
)
5637 printf ("%d", section
->sh_name
);
5639 printf ("'%s'", SECTION_NAME (section
));
5641 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5642 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5644 is_rela
= section
->sh_type
== SHT_RELA
;
5646 if (section
->sh_link
!= 0
5647 && section
->sh_link
< elf_header
.e_shnum
)
5649 Elf_Internal_Shdr
* symsec
;
5650 Elf_Internal_Sym
* symtab
;
5651 unsigned long nsyms
;
5652 unsigned long strtablen
= 0;
5653 char * strtab
= NULL
;
5655 symsec
= section_headers
+ section
->sh_link
;
5656 if (symsec
->sh_type
!= SHT_SYMTAB
5657 && symsec
->sh_type
!= SHT_DYNSYM
)
5660 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5665 if (symsec
->sh_link
!= 0
5666 && symsec
->sh_link
< elf_header
.e_shnum
)
5668 strsec
= section_headers
+ symsec
->sh_link
;
5670 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5673 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5676 dump_relocations (file
, rel_offset
, rel_size
,
5677 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5683 dump_relocations (file
, rel_offset
, rel_size
,
5684 NULL
, 0, NULL
, 0, is_rela
);
5691 printf (_("\nThere are no relocations in this file.\n"));
5697 /* Process the unwind section. */
5699 #include "unwind-ia64.h"
5701 /* An absolute address consists of a section and an offset. If the
5702 section is NULL, the offset itself is the address, otherwise, the
5703 address equals to LOAD_ADDRESS(section) + offset. */
5707 unsigned short section
;
5711 #define ABSADDR(a) \
5713 ? section_headers [(a).section].sh_addr + (a).offset \
5716 struct ia64_unw_table_entry
5718 struct absaddr start
;
5720 struct absaddr info
;
5723 struct ia64_unw_aux_info
5726 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5727 unsigned long table_len
; /* Length of unwind table. */
5728 unsigned char * info
; /* Unwind info. */
5729 unsigned long info_size
; /* Size of unwind info. */
5730 bfd_vma info_addr
; /* starting address of unwind info. */
5731 bfd_vma seg_base
; /* Starting address of segment. */
5732 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5733 unsigned long nsyms
; /* Number of symbols. */
5734 char * strtab
; /* The string table. */
5735 unsigned long strtab_size
; /* Size of string table. */
5739 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5740 unsigned long nsyms
,
5741 const char * strtab
,
5742 unsigned long strtab_size
,
5743 struct absaddr addr
,
5744 const char ** symname
,
5747 bfd_vma dist
= 0x100000;
5748 Elf_Internal_Sym
* sym
;
5749 Elf_Internal_Sym
* best
= NULL
;
5752 REMOVE_ARCH_BITS (addr
.offset
);
5754 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5756 bfd_vma value
= sym
->st_value
;
5758 REMOVE_ARCH_BITS (value
);
5760 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5761 && sym
->st_name
!= 0
5762 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5763 && addr
.offset
>= value
5764 && addr
.offset
- value
< dist
)
5767 dist
= addr
.offset
- value
;
5775 *symname
= (best
->st_name
>= strtab_size
5776 ? _("<corrupt>") : strtab
+ best
->st_name
);
5782 *offset
= addr
.offset
;
5786 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5788 struct ia64_unw_table_entry
* tp
;
5791 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5795 const unsigned char * dp
;
5796 const unsigned char * head
;
5797 const char * procname
;
5799 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5800 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5802 fputs ("\n<", stdout
);
5806 fputs (procname
, stdout
);
5809 printf ("+%lx", (unsigned long) offset
);
5812 fputs (">: [", stdout
);
5813 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5814 fputc ('-', stdout
);
5815 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5816 printf ("], info at +0x%lx\n",
5817 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5819 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5820 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5822 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5823 (unsigned) UNW_VER (stamp
),
5824 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5825 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5826 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5827 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5829 if (UNW_VER (stamp
) != 1)
5831 printf (_("\tUnknown version.\n"));
5836 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5837 dp
= unw_decode (dp
, in_body
, & in_body
);
5842 slurp_ia64_unwind_table (FILE * file
,
5843 struct ia64_unw_aux_info
* aux
,
5844 Elf_Internal_Shdr
* sec
)
5846 unsigned long size
, nrelas
, i
;
5847 Elf_Internal_Phdr
* seg
;
5848 struct ia64_unw_table_entry
* tep
;
5849 Elf_Internal_Shdr
* relsec
;
5850 Elf_Internal_Rela
* rela
;
5851 Elf_Internal_Rela
* rp
;
5852 unsigned char * table
;
5854 Elf_Internal_Sym
* sym
;
5855 const char * relname
;
5857 /* First, find the starting address of the segment that includes
5860 if (elf_header
.e_phnum
)
5862 if (! get_program_headers (file
))
5865 for (seg
= program_headers
;
5866 seg
< program_headers
+ elf_header
.e_phnum
;
5869 if (seg
->p_type
!= PT_LOAD
)
5872 if (sec
->sh_addr
>= seg
->p_vaddr
5873 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5875 aux
->seg_base
= seg
->p_vaddr
;
5881 /* Second, build the unwind table from the contents of the unwind section: */
5882 size
= sec
->sh_size
;
5883 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5888 aux
->table
= (struct ia64_unw_table_entry
*)
5889 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5891 for (tp
= table
; tp
< table
+ size
; ++tep
)
5893 tep
->start
.section
= SHN_UNDEF
;
5894 tep
->end
.section
= SHN_UNDEF
;
5895 tep
->info
.section
= SHN_UNDEF
;
5896 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5897 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5898 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5899 tep
->start
.offset
+= aux
->seg_base
;
5900 tep
->end
.offset
+= aux
->seg_base
;
5901 tep
->info
.offset
+= aux
->seg_base
;
5905 /* Third, apply any relocations to the unwind table: */
5906 for (relsec
= section_headers
;
5907 relsec
< section_headers
+ elf_header
.e_shnum
;
5910 if (relsec
->sh_type
!= SHT_RELA
5911 || relsec
->sh_info
>= elf_header
.e_shnum
5912 || section_headers
+ relsec
->sh_info
!= sec
)
5915 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5919 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5921 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5922 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5924 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5926 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5930 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5932 switch (rp
->r_offset
/eh_addr_size
% 3)
5935 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5936 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5939 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5940 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5943 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5944 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5954 aux
->table_len
= size
/ (3 * eh_addr_size
);
5959 ia64_process_unwind (FILE * file
)
5961 Elf_Internal_Shdr
* sec
;
5962 Elf_Internal_Shdr
* unwsec
= NULL
;
5963 Elf_Internal_Shdr
* strsec
;
5964 unsigned long i
, unwcount
= 0, unwstart
= 0;
5965 struct ia64_unw_aux_info aux
;
5967 memset (& aux
, 0, sizeof (aux
));
5969 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5971 if (sec
->sh_type
== SHT_SYMTAB
5972 && sec
->sh_link
< elf_header
.e_shnum
)
5974 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
5976 strsec
= section_headers
+ sec
->sh_link
;
5977 assert (aux
.strtab
== NULL
);
5978 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5981 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5983 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5988 printf (_("\nThere are no unwind sections in this file.\n"));
5990 while (unwcount
-- > 0)
5995 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5996 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5997 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6004 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6006 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6008 /* We need to find which section group it is in. */
6009 struct group_list
* g
= section_headers_groups
[i
]->root
;
6011 for (; g
!= NULL
; g
= g
->next
)
6013 sec
= section_headers
+ g
->section_index
;
6015 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6020 i
= elf_header
.e_shnum
;
6022 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6024 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6025 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6026 suffix
= SECTION_NAME (unwsec
) + len
;
6027 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6029 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6030 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6035 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6036 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6037 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6038 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6040 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6041 suffix
= SECTION_NAME (unwsec
) + len
;
6042 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6044 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6045 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6049 if (i
== elf_header
.e_shnum
)
6051 printf (_("\nCould not find unwind info section for "));
6053 if (string_table
== NULL
)
6054 printf ("%d", unwsec
->sh_name
);
6056 printf (_("'%s'"), SECTION_NAME (unwsec
));
6060 aux
.info_addr
= sec
->sh_addr
;
6061 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6064 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6066 printf (_("\nUnwind section "));
6068 if (string_table
== NULL
)
6069 printf ("%d", unwsec
->sh_name
);
6071 printf (_("'%s'"), SECTION_NAME (unwsec
));
6073 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6074 (unsigned long) unwsec
->sh_offset
,
6075 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6077 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6079 if (aux
.table_len
> 0)
6080 dump_ia64_unwind (& aux
);
6083 free ((char *) aux
.table
);
6085 free ((char *) aux
.info
);
6094 free ((char *) aux
.strtab
);
6097 struct hppa_unw_table_entry
6099 struct absaddr start
;
6101 unsigned int Cannot_unwind
:1; /* 0 */
6102 unsigned int Millicode
:1; /* 1 */
6103 unsigned int Millicode_save_sr0
:1; /* 2 */
6104 unsigned int Region_description
:2; /* 3..4 */
6105 unsigned int reserved1
:1; /* 5 */
6106 unsigned int Entry_SR
:1; /* 6 */
6107 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6108 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6109 unsigned int Args_stored
:1; /* 16 */
6110 unsigned int Variable_Frame
:1; /* 17 */
6111 unsigned int Separate_Package_Body
:1; /* 18 */
6112 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6113 unsigned int Stack_Overflow_Check
:1; /* 20 */
6114 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6115 unsigned int Ada_Region
:1; /* 22 */
6116 unsigned int cxx_info
:1; /* 23 */
6117 unsigned int cxx_try_catch
:1; /* 24 */
6118 unsigned int sched_entry_seq
:1; /* 25 */
6119 unsigned int reserved2
:1; /* 26 */
6120 unsigned int Save_SP
:1; /* 27 */
6121 unsigned int Save_RP
:1; /* 28 */
6122 unsigned int Save_MRP_in_frame
:1; /* 29 */
6123 unsigned int extn_ptr_defined
:1; /* 30 */
6124 unsigned int Cleanup_defined
:1; /* 31 */
6126 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6127 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6128 unsigned int Large_frame
:1; /* 2 */
6129 unsigned int Pseudo_SP_Set
:1; /* 3 */
6130 unsigned int reserved4
:1; /* 4 */
6131 unsigned int Total_frame_size
:27; /* 5..31 */
6134 struct hppa_unw_aux_info
6136 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6137 unsigned long table_len
; /* Length of unwind table. */
6138 bfd_vma seg_base
; /* Starting address of segment. */
6139 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6140 unsigned long nsyms
; /* Number of symbols. */
6141 char * strtab
; /* The string table. */
6142 unsigned long strtab_size
; /* Size of string table. */
6146 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6148 struct hppa_unw_table_entry
* tp
;
6150 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6153 const char * procname
;
6155 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6156 aux
->strtab_size
, tp
->start
, &procname
,
6159 fputs ("\n<", stdout
);
6163 fputs (procname
, stdout
);
6166 printf ("+%lx", (unsigned long) offset
);
6169 fputs (">: [", stdout
);
6170 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6171 fputc ('-', stdout
);
6172 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6175 #define PF(_m) if (tp->_m) printf (#_m " ");
6176 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6179 PF(Millicode_save_sr0
);
6180 /* PV(Region_description); */
6186 PF(Separate_Package_Body
);
6187 PF(Frame_Extension_Millicode
);
6188 PF(Stack_Overflow_Check
);
6189 PF(Two_Instruction_SP_Increment
);
6193 PF(sched_entry_seq
);
6196 PF(Save_MRP_in_frame
);
6197 PF(extn_ptr_defined
);
6198 PF(Cleanup_defined
);
6199 PF(MPE_XL_interrupt_marker
);
6200 PF(HP_UX_interrupt_marker
);
6203 PV(Total_frame_size
);
6212 slurp_hppa_unwind_table (FILE * file
,
6213 struct hppa_unw_aux_info
* aux
,
6214 Elf_Internal_Shdr
* sec
)
6216 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6217 Elf_Internal_Phdr
* seg
;
6218 struct hppa_unw_table_entry
* tep
;
6219 Elf_Internal_Shdr
* relsec
;
6220 Elf_Internal_Rela
* rela
;
6221 Elf_Internal_Rela
* rp
;
6222 unsigned char * table
;
6224 Elf_Internal_Sym
* sym
;
6225 const char * relname
;
6227 /* First, find the starting address of the segment that includes
6230 if (elf_header
.e_phnum
)
6232 if (! get_program_headers (file
))
6235 for (seg
= program_headers
;
6236 seg
< program_headers
+ elf_header
.e_phnum
;
6239 if (seg
->p_type
!= PT_LOAD
)
6242 if (sec
->sh_addr
>= seg
->p_vaddr
6243 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6245 aux
->seg_base
= seg
->p_vaddr
;
6251 /* Second, build the unwind table from the contents of the unwind
6253 size
= sec
->sh_size
;
6254 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6260 nentries
= size
/ unw_ent_size
;
6261 size
= unw_ent_size
* nentries
;
6263 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6264 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6266 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6268 unsigned int tmp1
, tmp2
;
6270 tep
->start
.section
= SHN_UNDEF
;
6271 tep
->end
.section
= SHN_UNDEF
;
6273 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6274 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6275 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6276 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6278 tep
->start
.offset
+= aux
->seg_base
;
6279 tep
->end
.offset
+= aux
->seg_base
;
6281 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6282 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6283 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6284 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6285 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6286 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6287 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6288 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6289 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6290 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6291 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6292 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6293 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6294 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6295 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6296 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6297 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6298 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6299 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6300 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6301 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6302 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6303 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6304 tep
->Cleanup_defined
= tmp1
& 0x1;
6306 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6307 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6308 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6309 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6310 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6311 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6315 /* Third, apply any relocations to the unwind table. */
6316 for (relsec
= section_headers
;
6317 relsec
< section_headers
+ elf_header
.e_shnum
;
6320 if (relsec
->sh_type
!= SHT_RELA
6321 || relsec
->sh_info
>= elf_header
.e_shnum
6322 || section_headers
+ relsec
->sh_info
!= sec
)
6325 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6329 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6331 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6332 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6334 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6335 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6337 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6341 i
= rp
->r_offset
/ unw_ent_size
;
6343 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6346 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6347 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6350 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6351 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6361 aux
->table_len
= nentries
;
6367 hppa_process_unwind (FILE * file
)
6369 struct hppa_unw_aux_info aux
;
6370 Elf_Internal_Shdr
* unwsec
= NULL
;
6371 Elf_Internal_Shdr
* strsec
;
6372 Elf_Internal_Shdr
* sec
;
6375 if (string_table
== NULL
)
6378 memset (& aux
, 0, sizeof (aux
));
6380 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6382 if (sec
->sh_type
== SHT_SYMTAB
6383 && sec
->sh_link
< elf_header
.e_shnum
)
6385 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6387 strsec
= section_headers
+ sec
->sh_link
;
6388 assert (aux
.strtab
== NULL
);
6389 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6392 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6394 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6399 printf (_("\nThere are no unwind sections in this file.\n"));
6401 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6403 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6405 printf (_("\nUnwind section "));
6406 printf (_("'%s'"), SECTION_NAME (sec
));
6408 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6409 (unsigned long) sec
->sh_offset
,
6410 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6412 slurp_hppa_unwind_table (file
, &aux
, sec
);
6413 if (aux
.table_len
> 0)
6414 dump_hppa_unwind (&aux
);
6417 free ((char *) aux
.table
);
6425 free ((char *) aux
.strtab
);
6430 unsigned char * data
; /* The unwind data. */
6431 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6432 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6433 unsigned long nrelas
; /* The number of relocations. */
6434 unsigned int rel_type
; /* REL or RELA ? */
6435 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6438 struct arm_unw_aux_info
6440 FILE * file
; /* The file containing the unwind sections. */
6441 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6442 unsigned long nsyms
; /* Number of symbols. */
6443 char * strtab
; /* The file's string table. */
6444 unsigned long strtab_size
; /* Size of string table. */
6448 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6449 bfd_vma fn
, struct absaddr addr
)
6451 const char *procname
;
6454 if (addr
.section
== SHN_UNDEF
)
6457 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6458 aux
->strtab_size
, addr
, &procname
,
6461 print_vma (fn
, PREFIX_HEX
);
6465 fputs (" <", stdout
);
6466 fputs (procname
, stdout
);
6469 printf ("+0x%lx", (unsigned long) sym_offset
);
6470 fputc ('>', stdout
);
6477 arm_free_section (struct arm_section
*arm_sec
)
6479 if (arm_sec
->data
!= NULL
)
6480 free (arm_sec
->data
);
6482 if (arm_sec
->rela
!= NULL
)
6483 free (arm_sec
->rela
);
6486 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6487 cached section and install SEC instead.
6488 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6489 and return its valued in * WORDP, relocating if necessary.
6490 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6491 relocation's offset in ADDR.
6492 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6493 into the string table of the symbol associated with the reloc. If no
6494 reloc was applied store -1 there.
6495 5) Return TRUE upon success, FALSE otherwise. */
6498 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6499 struct arm_section
* arm_sec
,
6500 Elf_Internal_Shdr
* sec
,
6501 bfd_vma word_offset
,
6502 unsigned int * wordp
,
6503 struct absaddr
* addr
,
6506 Elf_Internal_Rela
*rp
;
6507 Elf_Internal_Sym
*sym
;
6508 const char * relname
;
6510 bfd_boolean wrapped
;
6512 addr
->section
= SHN_UNDEF
;
6515 if (sym_name
!= NULL
)
6516 *sym_name
= (bfd_vma
) -1;
6518 /* If necessary, update the section cache. */
6519 if (sec
!= arm_sec
->sec
)
6521 Elf_Internal_Shdr
*relsec
;
6523 arm_free_section (arm_sec
);
6526 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6527 sec
->sh_size
, _("unwind data"));
6528 arm_sec
->rela
= NULL
;
6529 arm_sec
->nrelas
= 0;
6531 for (relsec
= section_headers
;
6532 relsec
< section_headers
+ elf_header
.e_shnum
;
6535 if (relsec
->sh_info
>= elf_header
.e_shnum
6536 || section_headers
+ relsec
->sh_info
!= sec
)
6539 arm_sec
->rel_type
= relsec
->sh_type
;
6540 if (relsec
->sh_type
== SHT_REL
)
6542 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6544 & arm_sec
->rela
, & arm_sec
->nrelas
))
6548 else if (relsec
->sh_type
== SHT_RELA
)
6550 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6552 & arm_sec
->rela
, & arm_sec
->nrelas
))
6557 warn (_("unexpected relocation type (%d) for section %d"),
6558 relsec
->sh_type
, relsec
->sh_info
);
6561 arm_sec
->next_rela
= arm_sec
->rela
;
6564 /* If there is no unwind data we can do nothing. */
6565 if (arm_sec
->data
== NULL
)
6568 /* Get the word at the required offset. */
6569 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6571 /* Look through the relocs to find the one that applies to the provided offset. */
6573 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6575 bfd_vma prelval
, offset
;
6577 if (rp
->r_offset
> word_offset
&& !wrapped
)
6582 if (rp
->r_offset
> word_offset
)
6585 if (rp
->r_offset
& 3)
6587 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6588 (unsigned long) rp
->r_offset
);
6592 if (rp
->r_offset
< word_offset
)
6595 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6597 if (arm_sec
->rel_type
== SHT_REL
)
6599 offset
= word
& 0x7fffffff;
6600 if (offset
& 0x40000000)
6601 offset
|= ~ (bfd_vma
) 0x7fffffff;
6603 else if (arm_sec
->rel_type
== SHT_RELA
)
6604 offset
= rp
->r_addend
;
6608 offset
+= sym
->st_value
;
6609 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6611 /* Check that we are processing the expected reloc type. */
6612 if (elf_header
.e_machine
== EM_ARM
)
6614 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6616 if (streq (relname
, "R_ARM_NONE"))
6619 if (! streq (relname
, "R_ARM_PREL31"))
6621 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6625 else if (elf_header
.e_machine
== EM_TI_C6000
)
6627 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6629 if (streq (relname
, "R_C6000_NONE"))
6632 if (! streq (relname
, "R_C6000_PREL31"))
6634 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6641 /* This function currently only supports ARM and TI unwinders. */
6644 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6645 addr
->section
= sym
->st_shndx
;
6646 addr
->offset
= offset
;
6648 * sym_name
= sym
->st_name
;
6653 arm_sec
->next_rela
= rp
;
6658 static const char *tic6x_unwind_regnames
[16] =
6660 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6661 "A14", "A13", "A12", "A11", "A10",
6662 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6666 decode_tic6x_unwind_regmask (unsigned int mask
)
6670 for (i
= 12; mask
; mask
>>= 1, i
--)
6674 fputs (tic6x_unwind_regnames
[i
], stdout
);
6676 fputs (", ", stdout
);
6682 if (remaining == 0 && more_words) \
6685 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6686 data_offset, & word, & addr, NULL)) \
6692 #define GET_OP(OP) \
6697 (OP) = word >> 24; \
6702 printf (_("[Truncated opcode]\n")); \
6705 printf ("0x%02x ", OP)
6708 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6709 unsigned int word
, unsigned int remaining
,
6710 unsigned int more_words
,
6711 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6712 struct arm_section
*data_arm_sec
)
6714 struct absaddr addr
;
6716 /* Decode the unwinding instructions. */
6719 unsigned int op
, op2
;
6728 printf (" 0x%02x ", op
);
6730 if ((op
& 0xc0) == 0x00)
6732 int offset
= ((op
& 0x3f) << 2) + 4;
6734 printf (" vsp = vsp + %d", offset
);
6736 else if ((op
& 0xc0) == 0x40)
6738 int offset
= ((op
& 0x3f) << 2) + 4;
6740 printf (" vsp = vsp - %d", offset
);
6742 else if ((op
& 0xf0) == 0x80)
6745 if (op
== 0x80 && op2
== 0)
6746 printf (_("Refuse to unwind"));
6749 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6754 for (i
= 0; i
< 12; i
++)
6755 if (mask
& (1 << i
))
6761 printf ("r%d", 4 + i
);
6766 else if ((op
& 0xf0) == 0x90)
6768 if (op
== 0x9d || op
== 0x9f)
6769 printf (_(" [Reserved]"));
6771 printf (" vsp = r%d", op
& 0x0f);
6773 else if ((op
& 0xf0) == 0xa0)
6775 int end
= 4 + (op
& 0x07);
6780 for (i
= 4; i
<= end
; i
++)
6796 else if (op
== 0xb0)
6797 printf (_(" finish"));
6798 else if (op
== 0xb1)
6801 if (op2
== 0 || (op2
& 0xf0) != 0)
6802 printf (_("[Spare]"));
6805 unsigned int mask
= op2
& 0x0f;
6810 for (i
= 0; i
< 12; i
++)
6811 if (mask
& (1 << i
))
6822 else if (op
== 0xb2)
6824 unsigned char buf
[9];
6825 unsigned int i
, len
;
6826 unsigned long offset
;
6828 for (i
= 0; i
< sizeof (buf
); i
++)
6831 if ((buf
[i
] & 0x80) == 0)
6834 assert (i
< sizeof (buf
));
6835 offset
= read_uleb128 (buf
, &len
);
6836 assert (len
== i
+ 1);
6837 offset
= offset
* 4 + 0x204;
6838 printf ("vsp = vsp + %ld", offset
);
6840 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6842 unsigned int first
, last
;
6849 printf ("pop {D%d", first
);
6851 printf ("-D%d", first
+ last
);
6854 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6856 unsigned int count
= op
& 0x07;
6860 printf ("-D%d", 8 + count
);
6863 else if (op
>= 0xc0 && op
<= 0xc5)
6865 unsigned int count
= op
& 0x07;
6867 printf (" pop {wR10");
6869 printf ("-wR%d", 10 + count
);
6872 else if (op
== 0xc6)
6874 unsigned int first
, last
;
6879 printf ("pop {wR%d", first
);
6881 printf ("-wR%d", first
+ last
);
6884 else if (op
== 0xc7)
6887 if (op2
== 0 || (op2
& 0xf0) != 0)
6888 printf (_("[Spare]"));
6891 unsigned int mask
= op2
& 0x0f;
6896 for (i
= 0; i
< 4; i
++)
6897 if (mask
& (1 << i
))
6903 printf ("wCGR%d", i
);
6909 printf (_(" [unsupported opcode]"));
6915 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6916 unsigned int word
, unsigned int remaining
,
6917 unsigned int more_words
,
6918 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6919 struct arm_section
*data_arm_sec
)
6921 struct absaddr addr
;
6923 /* Decode the unwinding instructions. */
6926 unsigned int op
, op2
;
6935 printf (" 0x%02x ", op
);
6937 if ((op
& 0xc0) == 0x00)
6939 int offset
= ((op
& 0x3f) << 3) + 8;
6940 printf (" sp = sp + %d", offset
);
6942 else if ((op
& 0xc0) == 0x80)
6945 if (op
== 0x80 && op2
== 0)
6946 printf (_("Refuse to unwind"));
6949 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6951 printf ("pop compact {");
6955 decode_tic6x_unwind_regmask (mask
);
6959 else if ((op
& 0xf0) == 0xc0)
6967 unsigned int offset
;
6971 /* Scan entire instruction first so that GET_OP output is not
6972 interleaved with disassembly. */
6974 for (i
= 0; nregs
< (op
& 0xf); i
++)
6980 regpos
[nregs
].offset
= i
* 2;
6981 regpos
[nregs
].reg
= reg
;
6988 regpos
[nregs
].offset
= i
* 2 + 1;
6989 regpos
[nregs
].reg
= reg
;
6994 printf (_("pop frame {"));
6996 for (i
= i
* 2; i
> 0; i
--)
6998 if (regpos
[reg
].offset
== i
- 1)
7000 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7007 fputs (name
, stdout
);
7014 else if (op
== 0xd0)
7015 printf (" MOV FP, SP");
7016 else if (op
== 0xd1)
7017 printf (" __c6xabi_pop_rts");
7018 else if (op
== 0xd2)
7020 unsigned char buf
[9];
7021 unsigned int i
, len
;
7022 unsigned long offset
;
7024 for (i
= 0; i
< sizeof (buf
); i
++)
7027 if ((buf
[i
] & 0x80) == 0)
7030 assert (i
< sizeof (buf
));
7031 offset
= read_uleb128 (buf
, &len
);
7032 assert (len
== i
+ 1);
7033 offset
= offset
* 8 + 0x408;
7034 printf (_("sp = sp + %ld"), offset
);
7036 else if ((op
& 0xf0) == 0xe0)
7038 if ((op
& 0x0f) == 7)
7041 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7045 printf (_(" [unsupported opcode]"));
7052 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7056 offset
= word
& 0x7fffffff;
7057 if (offset
& 0x40000000)
7058 offset
|= ~ (bfd_vma
) 0x7fffffff;
7060 if (elf_header
.e_machine
== EM_TI_C6000
)
7063 return offset
+ where
;
7067 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7069 unsigned int remaining
,
7070 bfd_vma data_offset
,
7071 Elf_Internal_Shdr
* data_sec
,
7072 struct arm_section
* data_arm_sec
)
7075 unsigned int more_words
= 0;
7076 struct absaddr addr
;
7077 bfd_vma sym_name
= (bfd_vma
) -1;
7081 /* Fetch the first word.
7082 Note - when decoding an object file the address extracted
7083 here will always be 0. So we also pass in the sym_name
7084 parameter so that we can find the symbol associated with
7085 the personality routine. */
7086 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7087 & word
, & addr
, & sym_name
))
7093 if ((word
& 0x80000000) == 0)
7095 /* Expand prel31 for personality routine. */
7097 const char *procname
;
7099 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7100 printf (_(" Personality routine: "));
7102 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7103 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7105 procname
= aux
->strtab
+ sym_name
;
7106 print_vma (fn
, PREFIX_HEX
);
7109 fputs (" <", stdout
);
7110 fputs (procname
, stdout
);
7111 fputc ('>', stdout
);
7115 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7116 fputc ('\n', stdout
);
7118 /* The GCC personality routines use the standard compact
7119 encoding, starting with one byte giving the number of
7121 if (procname
!= NULL
7122 && (const_strneq (procname
, "__gcc_personality_v0")
7123 || const_strneq (procname
, "__gxx_personality_v0")
7124 || const_strneq (procname
, "__gcj_personality_v0")
7125 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7132 printf (_(" [Truncated data]\n"));
7135 more_words
= word
>> 24;
7145 /* ARM EHABI Section 6.3:
7147 An exception-handling table entry for the compact model looks like:
7151 1 0 index Data for personalityRoutine[index] */
7153 if (elf_header
.e_machine
== EM_ARM
7154 && (word
& 0x70000000))
7155 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7157 per_index
= (word
>> 24) & 0x7f;
7158 printf (_(" Compact model index: %d\n"), per_index
);
7165 else if (per_index
< 3)
7167 more_words
= (word
>> 16) & 0xff;
7173 switch (elf_header
.e_machine
)
7178 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7179 data_offset
, data_sec
, data_arm_sec
);
7183 warn (_("Unknown ARM compact model index encountered\n"));
7184 printf (_(" [reserved]\n"));
7191 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7192 data_offset
, data_sec
, data_arm_sec
);
7194 else if (per_index
< 5)
7196 if (((word
>> 17) & 0x7f) == 0x7f)
7197 printf (_(" Restore stack from frame pointer\n"));
7199 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7200 printf (_(" Registers restored: "));
7202 printf (" (compact) ");
7203 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7205 printf (_(" Return register: %s\n"),
7206 tic6x_unwind_regnames
[word
& 0xf]);
7209 printf (_(" [reserved (%d)]\n"), per_index
);
7213 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7214 elf_header
.e_machine
);
7217 /* Decode the descriptors. Not implemented. */
7221 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7223 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7224 unsigned int i
, exidx_len
;
7226 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7227 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7228 exidx_len
= exidx_sec
->sh_size
/ 8;
7230 for (i
= 0; i
< exidx_len
; i
++)
7232 unsigned int exidx_fn
, exidx_entry
;
7233 struct absaddr fn_addr
, entry_addr
;
7236 fputc ('\n', stdout
);
7238 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7239 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7240 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7241 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7243 arm_free_section (& exidx_arm_sec
);
7244 arm_free_section (& extab_arm_sec
);
7248 /* ARM EHABI, Section 5:
7249 An index table entry consists of 2 words.
7250 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7251 if (exidx_fn
& 0x80000000)
7252 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7254 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7256 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7257 fputs (": ", stdout
);
7259 if (exidx_entry
== 1)
7261 print_vma (exidx_entry
, PREFIX_HEX
);
7262 fputs (" [cantunwind]\n", stdout
);
7264 else if (exidx_entry
& 0x80000000)
7266 print_vma (exidx_entry
, PREFIX_HEX
);
7267 fputc ('\n', stdout
);
7268 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7272 bfd_vma table
, table_offset
= 0;
7273 Elf_Internal_Shdr
*table_sec
;
7275 fputs ("@", stdout
);
7276 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7277 print_vma (table
, PREFIX_HEX
);
7280 /* Locate the matching .ARM.extab. */
7281 if (entry_addr
.section
!= SHN_UNDEF
7282 && entry_addr
.section
< elf_header
.e_shnum
)
7284 table_sec
= section_headers
+ entry_addr
.section
;
7285 table_offset
= entry_addr
.offset
;
7289 table_sec
= find_section_by_address (table
);
7290 if (table_sec
!= NULL
)
7291 table_offset
= table
- table_sec
->sh_addr
;
7293 if (table_sec
== NULL
)
7295 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7296 (unsigned long) table
);
7299 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7306 arm_free_section (&exidx_arm_sec
);
7307 arm_free_section (&extab_arm_sec
);
7310 /* Used for both ARM and C6X unwinding tables. */
7313 arm_process_unwind (FILE *file
)
7315 struct arm_unw_aux_info aux
;
7316 Elf_Internal_Shdr
*unwsec
= NULL
;
7317 Elf_Internal_Shdr
*strsec
;
7318 Elf_Internal_Shdr
*sec
;
7320 unsigned int sec_type
;
7322 switch (elf_header
.e_machine
)
7325 sec_type
= SHT_ARM_EXIDX
;
7329 sec_type
= SHT_C6000_UNWIND
;
7333 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7334 elf_header
.e_machine
);
7338 if (string_table
== NULL
)
7341 memset (& aux
, 0, sizeof (aux
));
7344 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7346 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7348 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7350 strsec
= section_headers
+ sec
->sh_link
;
7351 assert (aux
.strtab
== NULL
);
7352 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7353 1, strsec
->sh_size
, _("string table"));
7354 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7356 else if (sec
->sh_type
== sec_type
)
7361 printf (_("\nThere are no unwind sections in this file.\n"));
7363 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7365 if (sec
->sh_type
== sec_type
)
7367 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7369 (unsigned long) sec
->sh_offset
,
7370 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7372 dump_arm_unwind (&aux
, sec
);
7379 free ((char *) aux
.strtab
);
7383 process_unwind (FILE * file
)
7385 struct unwind_handler
7388 void (* handler
)(FILE *);
7391 { EM_ARM
, arm_process_unwind
},
7392 { EM_IA_64
, ia64_process_unwind
},
7393 { EM_PARISC
, hppa_process_unwind
},
7394 { EM_TI_C6000
, arm_process_unwind
},
7402 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7403 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7404 return handlers
[i
].handler (file
);
7406 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7407 get_machine_name (elf_header
.e_machine
));
7411 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7413 switch (entry
->d_tag
)
7416 if (entry
->d_un
.d_val
== 0)
7420 static const char * opts
[] =
7422 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7423 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7424 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7425 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7431 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7432 if (entry
->d_un
.d_val
& (1 << cnt
))
7434 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7440 case DT_MIPS_IVERSION
:
7441 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7442 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7444 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7447 case DT_MIPS_TIME_STAMP
:
7452 time_t atime
= entry
->d_un
.d_val
;
7453 tmp
= gmtime (&atime
);
7454 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7455 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7456 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7457 printf (_("Time Stamp: %s"), timebuf
);
7461 case DT_MIPS_RLD_VERSION
:
7462 case DT_MIPS_LOCAL_GOTNO
:
7463 case DT_MIPS_CONFLICTNO
:
7464 case DT_MIPS_LIBLISTNO
:
7465 case DT_MIPS_SYMTABNO
:
7466 case DT_MIPS_UNREFEXTNO
:
7467 case DT_MIPS_HIPAGENO
:
7468 case DT_MIPS_DELTA_CLASS_NO
:
7469 case DT_MIPS_DELTA_INSTANCE_NO
:
7470 case DT_MIPS_DELTA_RELOC_NO
:
7471 case DT_MIPS_DELTA_SYM_NO
:
7472 case DT_MIPS_DELTA_CLASSSYM_NO
:
7473 case DT_MIPS_COMPACT_SIZE
:
7474 print_vma (entry
->d_un
.d_ptr
, DEC
);
7478 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7484 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7486 switch (entry
->d_tag
)
7488 case DT_HP_DLD_FLAGS
:
7497 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7498 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7499 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7500 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7501 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7502 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7503 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7504 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7505 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7506 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7507 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7508 { DT_HP_GST
, "HP_GST" },
7509 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7510 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7511 { DT_HP_NODELETE
, "HP_NODELETE" },
7512 { DT_HP_GROUP
, "HP_GROUP" },
7513 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7517 bfd_vma val
= entry
->d_un
.d_val
;
7519 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7520 if (val
& flags
[cnt
].bit
)
7524 fputs (flags
[cnt
].str
, stdout
);
7526 val
^= flags
[cnt
].bit
;
7529 if (val
!= 0 || first
)
7533 print_vma (val
, HEX
);
7539 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7547 /* VMS vs Unix time offset and factor. */
7549 #define VMS_EPOCH_OFFSET 35067168000000000LL
7550 #define VMS_GRANULARITY_FACTOR 10000000
7552 /* Display a VMS time in a human readable format. */
7555 print_vms_time (bfd_int64_t vmstime
)
7560 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7561 tm
= gmtime (&unxtime
);
7562 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7563 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7564 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7569 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7571 switch (entry
->d_tag
)
7573 case DT_IA_64_PLT_RESERVE
:
7574 /* First 3 slots reserved. */
7575 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7577 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7580 case DT_IA_64_VMS_LINKTIME
:
7582 print_vms_time (entry
->d_un
.d_val
);
7586 case DT_IA_64_VMS_LNKFLAGS
:
7587 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7588 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7589 printf (" CALL_DEBUG");
7590 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7591 printf (" NOP0BUFS");
7592 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7593 printf (" P0IMAGE");
7594 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7595 printf (" MKTHREADS");
7596 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7597 printf (" UPCALLS");
7598 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7600 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7601 printf (" INITIALIZE");
7602 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7604 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7605 printf (" EXE_INIT");
7606 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7607 printf (" TBK_IN_IMG");
7608 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7609 printf (" DBG_IN_IMG");
7610 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7611 printf (" TBK_IN_DSF");
7612 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7613 printf (" DBG_IN_DSF");
7614 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7615 printf (" SIGNATURES");
7616 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7617 printf (" REL_SEG_OFF");
7621 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7628 get_32bit_dynamic_section (FILE * file
)
7630 Elf32_External_Dyn
* edyn
;
7631 Elf32_External_Dyn
* ext
;
7632 Elf_Internal_Dyn
* entry
;
7634 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7635 dynamic_size
, _("dynamic section"));
7639 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7640 might not have the luxury of section headers. Look for the DT_NULL
7641 terminator to determine the number of entries. */
7642 for (ext
= edyn
, dynamic_nent
= 0;
7643 (char *) ext
< (char *) edyn
+ dynamic_size
;
7647 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7651 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7653 if (dynamic_section
== NULL
)
7655 error (_("Out of memory\n"));
7660 for (ext
= edyn
, entry
= dynamic_section
;
7661 entry
< dynamic_section
+ dynamic_nent
;
7664 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7665 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7674 get_64bit_dynamic_section (FILE * file
)
7676 Elf64_External_Dyn
* edyn
;
7677 Elf64_External_Dyn
* ext
;
7678 Elf_Internal_Dyn
* entry
;
7680 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7681 dynamic_size
, _("dynamic section"));
7685 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7686 might not have the luxury of section headers. Look for the DT_NULL
7687 terminator to determine the number of entries. */
7688 for (ext
= edyn
, dynamic_nent
= 0;
7689 (char *) ext
< (char *) edyn
+ dynamic_size
;
7693 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7697 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7699 if (dynamic_section
== NULL
)
7701 error (_("Out of memory\n"));
7706 for (ext
= edyn
, entry
= dynamic_section
;
7707 entry
< dynamic_section
+ dynamic_nent
;
7710 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7711 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7720 print_dynamic_flags (bfd_vma flags
)
7728 flag
= flags
& - flags
;
7738 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7739 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7740 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7741 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7742 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7743 default: fputs (_("unknown"), stdout
); break;
7749 /* Parse and display the contents of the dynamic section. */
7752 process_dynamic_section (FILE * file
)
7754 Elf_Internal_Dyn
* entry
;
7756 if (dynamic_size
== 0)
7759 printf (_("\nThere is no dynamic section in this file.\n"));
7766 if (! get_32bit_dynamic_section (file
))
7769 else if (! get_64bit_dynamic_section (file
))
7772 /* Find the appropriate symbol table. */
7773 if (dynamic_symbols
== NULL
)
7775 for (entry
= dynamic_section
;
7776 entry
< dynamic_section
+ dynamic_nent
;
7779 Elf_Internal_Shdr section
;
7781 if (entry
->d_tag
!= DT_SYMTAB
)
7784 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7786 /* Since we do not know how big the symbol table is,
7787 we default to reading in the entire file (!) and
7788 processing that. This is overkill, I know, but it
7790 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7792 if (archive_file_offset
!= 0)
7793 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7796 if (fseek (file
, 0, SEEK_END
))
7797 error (_("Unable to seek to end of file!\n"));
7799 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7803 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7805 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7807 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7808 if (num_dynamic_syms
< 1)
7810 error (_("Unable to determine the number of symbols to load\n"));
7816 /* Similarly find a string table. */
7817 if (dynamic_strings
== NULL
)
7819 for (entry
= dynamic_section
;
7820 entry
< dynamic_section
+ dynamic_nent
;
7823 unsigned long offset
;
7826 if (entry
->d_tag
!= DT_STRTAB
)
7829 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7831 /* Since we do not know how big the string table is,
7832 we default to reading in the entire file (!) and
7833 processing that. This is overkill, I know, but it
7836 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7838 if (archive_file_offset
!= 0)
7839 str_tab_len
= archive_file_size
- offset
;
7842 if (fseek (file
, 0, SEEK_END
))
7843 error (_("Unable to seek to end of file\n"));
7844 str_tab_len
= ftell (file
) - offset
;
7847 if (str_tab_len
< 1)
7850 (_("Unable to determine the length of the dynamic string table\n"));
7854 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7856 _("dynamic string table"));
7857 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7862 /* And find the syminfo section if available. */
7863 if (dynamic_syminfo
== NULL
)
7865 unsigned long syminsz
= 0;
7867 for (entry
= dynamic_section
;
7868 entry
< dynamic_section
+ dynamic_nent
;
7871 if (entry
->d_tag
== DT_SYMINENT
)
7873 /* Note: these braces are necessary to avoid a syntax
7874 error from the SunOS4 C compiler. */
7875 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7877 else if (entry
->d_tag
== DT_SYMINSZ
)
7878 syminsz
= entry
->d_un
.d_val
;
7879 else if (entry
->d_tag
== DT_SYMINFO
)
7880 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7884 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7886 Elf_External_Syminfo
* extsyminfo
;
7887 Elf_External_Syminfo
* extsym
;
7888 Elf_Internal_Syminfo
* syminfo
;
7890 /* There is a syminfo section. Read the data. */
7891 extsyminfo
= (Elf_External_Syminfo
*)
7892 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7893 _("symbol information"));
7897 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7898 if (dynamic_syminfo
== NULL
)
7900 error (_("Out of memory\n"));
7904 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7905 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7906 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7907 ++syminfo
, ++extsym
)
7909 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7910 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7917 if (do_dynamic
&& dynamic_addr
)
7918 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7919 dynamic_addr
, dynamic_nent
);
7921 printf (_(" Tag Type Name/Value\n"));
7923 for (entry
= dynamic_section
;
7924 entry
< dynamic_section
+ dynamic_nent
;
7932 print_vma (entry
->d_tag
, FULL_HEX
);
7933 dtype
= get_dynamic_type (entry
->d_tag
);
7934 printf (" (%s)%*s", dtype
,
7935 ((is_32bit_elf
? 27 : 19)
7936 - (int) strlen (dtype
)),
7940 switch (entry
->d_tag
)
7944 print_dynamic_flags (entry
->d_un
.d_val
);
7954 switch (entry
->d_tag
)
7957 printf (_("Auxiliary library"));
7961 printf (_("Filter library"));
7965 printf (_("Configuration file"));
7969 printf (_("Dependency audit library"));
7973 printf (_("Audit library"));
7977 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7978 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7982 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7991 printf (_("Flags:"));
7993 if (entry
->d_un
.d_val
== 0)
7994 printf (_(" None\n"));
7997 unsigned long int val
= entry
->d_un
.d_val
;
7999 if (val
& DTF_1_PARINIT
)
8001 printf (" PARINIT");
8002 val
^= DTF_1_PARINIT
;
8004 if (val
& DTF_1_CONFEXP
)
8006 printf (" CONFEXP");
8007 val
^= DTF_1_CONFEXP
;
8010 printf (" %lx", val
);
8019 printf (_("Flags:"));
8021 if (entry
->d_un
.d_val
== 0)
8022 printf (_(" None\n"));
8025 unsigned long int val
= entry
->d_un
.d_val
;
8027 if (val
& DF_P1_LAZYLOAD
)
8029 printf (" LAZYLOAD");
8030 val
^= DF_P1_LAZYLOAD
;
8032 if (val
& DF_P1_GROUPPERM
)
8034 printf (" GROUPPERM");
8035 val
^= DF_P1_GROUPPERM
;
8038 printf (" %lx", val
);
8047 printf (_("Flags:"));
8048 if (entry
->d_un
.d_val
== 0)
8049 printf (_(" None\n"));
8052 unsigned long int val
= entry
->d_un
.d_val
;
8059 if (val
& DF_1_GLOBAL
)
8064 if (val
& DF_1_GROUP
)
8069 if (val
& DF_1_NODELETE
)
8071 printf (" NODELETE");
8072 val
^= DF_1_NODELETE
;
8074 if (val
& DF_1_LOADFLTR
)
8076 printf (" LOADFLTR");
8077 val
^= DF_1_LOADFLTR
;
8079 if (val
& DF_1_INITFIRST
)
8081 printf (" INITFIRST");
8082 val
^= DF_1_INITFIRST
;
8084 if (val
& DF_1_NOOPEN
)
8089 if (val
& DF_1_ORIGIN
)
8094 if (val
& DF_1_DIRECT
)
8099 if (val
& DF_1_TRANS
)
8104 if (val
& DF_1_INTERPOSE
)
8106 printf (" INTERPOSE");
8107 val
^= DF_1_INTERPOSE
;
8109 if (val
& DF_1_NODEFLIB
)
8111 printf (" NODEFLIB");
8112 val
^= DF_1_NODEFLIB
;
8114 if (val
& DF_1_NODUMP
)
8119 if (val
& DF_1_CONFALT
)
8121 printf (" CONFALT");
8122 val
^= DF_1_CONFALT
;
8124 if (val
& DF_1_ENDFILTEE
)
8126 printf (" ENDFILTEE");
8127 val
^= DF_1_ENDFILTEE
;
8129 if (val
& DF_1_DISPRELDNE
)
8131 printf (" DISPRELDNE");
8132 val
^= DF_1_DISPRELDNE
;
8134 if (val
& DF_1_DISPRELPND
)
8136 printf (" DISPRELPND");
8137 val
^= DF_1_DISPRELPND
;
8139 if (val
& DF_1_NODIRECT
)
8141 printf (" NODIRECT");
8142 val
^= DF_1_NODIRECT
;
8144 if (val
& DF_1_IGNMULDEF
)
8146 printf (" IGNMULDEF");
8147 val
^= DF_1_IGNMULDEF
;
8149 if (val
& DF_1_NOKSYMS
)
8151 printf (" NOKSYMS");
8152 val
^= DF_1_NOKSYMS
;
8154 if (val
& DF_1_NOHDR
)
8159 if (val
& DF_1_EDITED
)
8164 if (val
& DF_1_NORELOC
)
8166 printf (" NORELOC");
8167 val
^= DF_1_NORELOC
;
8169 if (val
& DF_1_SYMINTPOSE
)
8171 printf (" SYMINTPOSE");
8172 val
^= DF_1_SYMINTPOSE
;
8174 if (val
& DF_1_GLOBAUDIT
)
8176 printf (" GLOBAUDIT");
8177 val
^= DF_1_GLOBAUDIT
;
8179 if (val
& DF_1_SINGLETON
)
8181 printf (" SINGLETON");
8182 val
^= DF_1_SINGLETON
;
8185 printf (" %lx", val
);
8192 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8194 puts (get_dynamic_type (entry
->d_un
.d_val
));
8214 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8220 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8221 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8227 switch (entry
->d_tag
)
8230 printf (_("Shared library: [%s]"), name
);
8232 if (streq (name
, program_interpreter
))
8233 printf (_(" program interpreter"));
8237 printf (_("Library soname: [%s]"), name
);
8241 printf (_("Library rpath: [%s]"), name
);
8245 printf (_("Library runpath: [%s]"), name
);
8249 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8254 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8267 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8271 case DT_INIT_ARRAYSZ
:
8272 case DT_FINI_ARRAYSZ
:
8273 case DT_GNU_CONFLICTSZ
:
8274 case DT_GNU_LIBLISTSZ
:
8277 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8278 printf (_(" (bytes)\n"));
8288 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8301 if (entry
->d_tag
== DT_USED
8302 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8304 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8308 printf (_("Not needed object: [%s]\n"), name
);
8313 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8319 /* The value of this entry is ignored. */
8324 case DT_GNU_PRELINKED
:
8328 time_t atime
= entry
->d_un
.d_val
;
8330 tmp
= gmtime (&atime
);
8331 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8332 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8333 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8339 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8342 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8348 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8349 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8354 switch (elf_header
.e_machine
)
8357 case EM_MIPS_RS3_LE
:
8358 dynamic_section_mips_val (entry
);
8361 dynamic_section_parisc_val (entry
);
8364 dynamic_section_ia64_val (entry
);
8367 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8379 get_ver_flags (unsigned int flags
)
8381 static char buff
[32];
8388 if (flags
& VER_FLG_BASE
)
8389 strcat (buff
, "BASE ");
8391 if (flags
& VER_FLG_WEAK
)
8393 if (flags
& VER_FLG_BASE
)
8394 strcat (buff
, "| ");
8396 strcat (buff
, "WEAK ");
8399 if (flags
& VER_FLG_INFO
)
8401 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8402 strcat (buff
, "| ");
8404 strcat (buff
, "INFO ");
8407 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8408 strcat (buff
, _("| <unknown>"));
8413 /* Display the contents of the version sections. */
8416 process_version_sections (FILE * file
)
8418 Elf_Internal_Shdr
* section
;
8425 for (i
= 0, section
= section_headers
;
8426 i
< elf_header
.e_shnum
;
8429 switch (section
->sh_type
)
8431 case SHT_GNU_verdef
:
8433 Elf_External_Verdef
* edefs
;
8441 (_("\nVersion definition section '%s' contains %u entries:\n"),
8442 SECTION_NAME (section
), section
->sh_info
);
8444 printf (_(" Addr: 0x"));
8445 printf_vma (section
->sh_addr
);
8446 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8447 (unsigned long) section
->sh_offset
, section
->sh_link
,
8448 section
->sh_link
< elf_header
.e_shnum
8449 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8452 edefs
= (Elf_External_Verdef
*)
8453 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8454 _("version definition section"));
8457 endbuf
= (char *) edefs
+ section
->sh_size
;
8459 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8462 Elf_External_Verdef
* edef
;
8463 Elf_Internal_Verdef ent
;
8464 Elf_External_Verdaux
* eaux
;
8465 Elf_Internal_Verdaux aux
;
8469 /* Check for negative or very large indicies. */
8470 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
8473 vstart
= ((char *) edefs
) + idx
;
8474 if (vstart
+ sizeof (*edef
) > endbuf
)
8477 edef
= (Elf_External_Verdef
*) vstart
;
8479 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8480 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8481 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8482 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8483 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8484 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8485 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8487 printf (_(" %#06x: Rev: %d Flags: %s"),
8488 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8490 printf (_(" Index: %d Cnt: %d "),
8491 ent
.vd_ndx
, ent
.vd_cnt
);
8493 /* Check for overflow. */
8494 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
8495 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
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 ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
8516 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
8519 isum
+= aux
.vda_next
;
8520 vstart
+= aux
.vda_next
;
8522 eaux
= (Elf_External_Verdaux
*) vstart
;
8523 if (vstart
+ sizeof (*eaux
) > endbuf
)
8526 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8527 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8529 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8530 printf (_(" %#06x: Parent %d: %s\n"),
8531 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8533 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8534 isum
, j
, aux
.vda_name
);
8538 printf (_(" Version def aux past end of section\n"));
8543 if (cnt
< section
->sh_info
)
8544 printf (_(" Version definition past end of section\n"));
8550 case SHT_GNU_verneed
:
8552 Elf_External_Verneed
* eneed
;
8559 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8560 SECTION_NAME (section
), section
->sh_info
);
8562 printf (_(" Addr: 0x"));
8563 printf_vma (section
->sh_addr
);
8564 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8565 (unsigned long) section
->sh_offset
, section
->sh_link
,
8566 section
->sh_link
< elf_header
.e_shnum
8567 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8570 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8571 section
->sh_offset
, 1,
8573 _("Version Needs section"));
8576 endbuf
= (char *) eneed
+ section
->sh_size
;
8578 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8580 Elf_External_Verneed
* entry
;
8581 Elf_Internal_Verneed ent
;
8586 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
8589 vstart
= ((char *) eneed
) + idx
;
8590 if (vstart
+ sizeof (*entry
) > endbuf
)
8593 entry
= (Elf_External_Verneed
*) vstart
;
8595 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8596 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8597 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8598 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8599 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8601 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8603 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8604 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8606 printf (_(" File: %lx"), ent
.vn_file
);
8608 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8610 /* Check for overflow. */
8611 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
8612 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
8615 vstart
+= ent
.vn_aux
;
8617 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8619 Elf_External_Vernaux
* eaux
;
8620 Elf_Internal_Vernaux aux
;
8622 if (vstart
+ sizeof (*eaux
) > endbuf
)
8624 eaux
= (Elf_External_Vernaux
*) vstart
;
8626 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8627 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8628 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8629 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8630 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8632 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8633 printf (_(" %#06x: Name: %s"),
8634 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8636 printf (_(" %#06x: Name index: %lx"),
8637 isum
, aux
.vna_name
);
8639 printf (_(" Flags: %s Version: %d\n"),
8640 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8642 /* Check for overflow. */
8643 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
8644 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
8647 isum
+= aux
.vna_next
;
8648 vstart
+= aux
.vna_next
;
8652 warn (_("Missing Version Needs auxillary information\n"));
8657 if (cnt
< section
->sh_info
)
8658 warn (_("Missing Version Needs information\n"));
8664 case SHT_GNU_versym
:
8666 Elf_Internal_Shdr
* link_section
;
8669 unsigned char * edata
;
8670 unsigned short * data
;
8672 Elf_Internal_Sym
* symbols
;
8673 Elf_Internal_Shdr
* string_sec
;
8674 unsigned long num_syms
;
8677 if (section
->sh_link
>= elf_header
.e_shnum
)
8680 link_section
= section_headers
+ section
->sh_link
;
8681 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8683 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8688 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8689 if (symbols
== NULL
)
8692 string_sec
= section_headers
+ link_section
->sh_link
;
8694 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8695 string_sec
->sh_size
,
8696 _("version string table"));
8703 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8704 SECTION_NAME (section
), total
);
8706 printf (_(" Addr: "));
8707 printf_vma (section
->sh_addr
);
8708 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8709 (unsigned long) section
->sh_offset
, section
->sh_link
,
8710 SECTION_NAME (link_section
));
8712 off
= offset_from_vma (file
,
8713 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8714 total
* sizeof (short));
8715 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8717 _("version symbol data"));
8725 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8727 for (cnt
= total
; cnt
--;)
8728 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8733 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8736 int check_def
, check_need
;
8739 printf (" %03x:", cnt
);
8741 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8742 switch (data
[cnt
+ j
])
8745 fputs (_(" 0 (*local*) "), stdout
);
8749 fputs (_(" 1 (*global*) "), stdout
);
8753 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8754 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8756 /* If this index value is greater than the size of the symbols
8757 array, break to avoid an out-of-bounds read. */
8758 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8760 warn (_("invalid index into symbol array\n"));
8766 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8767 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8770 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8777 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8779 Elf_Internal_Verneed ivn
;
8780 unsigned long offset
;
8782 offset
= offset_from_vma
8783 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8784 sizeof (Elf_External_Verneed
));
8788 Elf_Internal_Vernaux ivna
;
8789 Elf_External_Verneed evn
;
8790 Elf_External_Vernaux evna
;
8791 unsigned long a_off
;
8793 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8794 _("version need")) == NULL
)
8797 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8798 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8800 a_off
= offset
+ ivn
.vn_aux
;
8804 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8805 1, _("version need aux (2)")) == NULL
)
8812 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8813 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8816 a_off
+= ivna
.vna_next
;
8818 while (ivna
.vna_other
!= data
[cnt
+ j
]
8819 && ivna
.vna_next
!= 0);
8821 if (ivna
.vna_other
== data
[cnt
+ j
])
8823 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8825 if (ivna
.vna_name
>= string_sec
->sh_size
)
8826 name
= _("*invalid*");
8828 name
= strtab
+ ivna
.vna_name
;
8829 nn
+= printf ("(%s%-*s",
8831 12 - (int) strlen (name
),
8837 offset
+= ivn
.vn_next
;
8839 while (ivn
.vn_next
);
8842 if (check_def
&& data
[cnt
+ j
] != 0x8001
8843 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8845 Elf_Internal_Verdef ivd
;
8846 Elf_External_Verdef evd
;
8847 unsigned long offset
;
8849 offset
= offset_from_vma
8850 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8855 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8856 _("version def")) == NULL
)
8863 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8864 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8867 offset
+= ivd
.vd_next
;
8869 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8870 && ivd
.vd_next
!= 0);
8872 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8874 Elf_External_Verdaux evda
;
8875 Elf_Internal_Verdaux ivda
;
8877 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8879 if (get_data (&evda
, file
,
8880 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8882 _("version def aux")) == NULL
)
8885 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8887 if (ivda
.vda_name
>= string_sec
->sh_size
)
8888 name
= _("*invalid*");
8890 name
= strtab
+ ivda
.vda_name
;
8891 nn
+= printf ("(%s%-*s",
8893 12 - (int) strlen (name
),
8899 printf ("%*c", 18 - nn
, ' ');
8917 printf (_("\nNo version information found in this file.\n"));
8923 get_symbol_binding (unsigned int binding
)
8925 static char buff
[32];
8929 case STB_LOCAL
: return "LOCAL";
8930 case STB_GLOBAL
: return "GLOBAL";
8931 case STB_WEAK
: return "WEAK";
8933 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8934 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8936 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8938 if (binding
== STB_GNU_UNIQUE
8939 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8940 /* GNU is still using the default value 0. */
8941 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8943 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8946 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8952 get_symbol_type (unsigned int type
)
8954 static char buff
[32];
8958 case STT_NOTYPE
: return "NOTYPE";
8959 case STT_OBJECT
: return "OBJECT";
8960 case STT_FUNC
: return "FUNC";
8961 case STT_SECTION
: return "SECTION";
8962 case STT_FILE
: return "FILE";
8963 case STT_COMMON
: return "COMMON";
8964 case STT_TLS
: return "TLS";
8965 case STT_RELC
: return "RELC";
8966 case STT_SRELC
: return "SRELC";
8968 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8970 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8971 return "THUMB_FUNC";
8973 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8976 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8977 return "PARISC_MILLI";
8979 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8981 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8983 if (elf_header
.e_machine
== EM_PARISC
)
8985 if (type
== STT_HP_OPAQUE
)
8987 if (type
== STT_HP_STUB
)
8991 if (type
== STT_GNU_IFUNC
8992 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8993 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
8994 /* GNU is still using the default value 0. */
8995 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8998 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9001 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9007 get_symbol_visibility (unsigned int visibility
)
9011 case STV_DEFAULT
: return "DEFAULT";
9012 case STV_INTERNAL
: return "INTERNAL";
9013 case STV_HIDDEN
: return "HIDDEN";
9014 case STV_PROTECTED
: return "PROTECTED";
9020 get_mips_symbol_other (unsigned int other
)
9032 case STO_MICROMIPS
| STO_MIPS_PIC
:
9033 return "MICROMIPS, MIPS PIC";
9042 get_ia64_symbol_other (unsigned int other
)
9046 static char res
[32];
9050 /* Function types is for images and .STB files only. */
9051 switch (elf_header
.e_type
)
9055 switch (VMS_ST_FUNC_TYPE (other
))
9057 case VMS_SFT_CODE_ADDR
:
9058 strcat (res
, " CA");
9060 case VMS_SFT_SYMV_IDX
:
9061 strcat (res
, " VEC");
9064 strcat (res
, " FD");
9066 case VMS_SFT_RESERVE
:
9067 strcat (res
, " RSV");
9076 switch (VMS_ST_LINKAGE (other
))
9078 case VMS_STL_IGNORE
:
9079 strcat (res
, " IGN");
9081 case VMS_STL_RESERVE
:
9082 strcat (res
, " RSV");
9085 strcat (res
, " STD");
9088 strcat (res
, " LNK");
9103 get_symbol_other (unsigned int other
)
9105 const char * result
= NULL
;
9106 static char buff
[32];
9111 switch (elf_header
.e_machine
)
9114 result
= get_mips_symbol_other (other
);
9117 result
= get_ia64_symbol_other (other
);
9126 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9131 get_symbol_index_type (unsigned int type
)
9133 static char buff
[32];
9137 case SHN_UNDEF
: return "UND";
9138 case SHN_ABS
: return "ABS";
9139 case SHN_COMMON
: return "COM";
9141 if (type
== SHN_IA_64_ANSI_COMMON
9142 && elf_header
.e_machine
== EM_IA_64
9143 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9145 else if ((elf_header
.e_machine
== EM_X86_64
9146 || elf_header
.e_machine
== EM_L1OM
9147 || elf_header
.e_machine
== EM_K1OM
)
9148 && type
== SHN_X86_64_LCOMMON
)
9150 else if ((type
== SHN_MIPS_SCOMMON
9151 && elf_header
.e_machine
== EM_MIPS
)
9152 || (type
== SHN_TIC6X_SCOMMON
9153 && elf_header
.e_machine
== EM_TI_C6000
))
9155 else if (type
== SHN_MIPS_SUNDEFINED
9156 && elf_header
.e_machine
== EM_MIPS
)
9158 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9159 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9160 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9161 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9162 else if (type
>= SHN_LORESERVE
)
9163 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9164 else if (type
>= elf_header
.e_shnum
)
9165 sprintf (buff
, "bad section index[%3d]", type
);
9167 sprintf (buff
, "%3d", type
);
9175 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9177 unsigned char * e_data
;
9180 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9184 error (_("Out of memory\n"));
9188 if (fread (e_data
, ent_size
, number
, file
) != number
)
9190 error (_("Unable to read in dynamic data\n"));
9194 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9198 error (_("Out of memory\n"));
9204 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9212 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9214 Elf_Internal_Sym
* psym
;
9217 psym
= dynamic_symbols
+ si
;
9219 n
= print_vma (si
, DEC_5
);
9221 fputs (" " + n
, stdout
);
9222 printf (" %3lu: ", hn
);
9223 print_vma (psym
->st_value
, LONG_HEX
);
9225 print_vma (psym
->st_size
, DEC_5
);
9227 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9228 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9229 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9230 /* Check to see if any other bits in the st_other field are set.
9231 Note - displaying this information disrupts the layout of the
9232 table being generated, but for the moment this case is very
9234 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9235 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9236 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9237 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9238 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9240 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9244 /* Dump the symbol table. */
9246 process_symbol_table (FILE * file
)
9248 Elf_Internal_Shdr
* section
;
9249 bfd_vma nbuckets
= 0;
9250 bfd_vma nchains
= 0;
9251 bfd_vma
* buckets
= NULL
;
9252 bfd_vma
* chains
= NULL
;
9253 bfd_vma ngnubuckets
= 0;
9254 bfd_vma
* gnubuckets
= NULL
;
9255 bfd_vma
* gnuchains
= NULL
;
9256 bfd_vma gnusymidx
= 0;
9258 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9261 if (dynamic_info
[DT_HASH
]
9263 || (do_using_dynamic
9265 && dynamic_strings
!= NULL
)))
9267 unsigned char nb
[8];
9268 unsigned char nc
[8];
9269 int hash_ent_size
= 4;
9271 if ((elf_header
.e_machine
== EM_ALPHA
9272 || elf_header
.e_machine
== EM_S390
9273 || elf_header
.e_machine
== EM_S390_OLD
)
9274 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9278 (archive_file_offset
9279 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9280 sizeof nb
+ sizeof nc
)),
9283 error (_("Unable to seek to start of dynamic information\n"));
9287 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9289 error (_("Failed to read in number of buckets\n"));
9293 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9295 error (_("Failed to read in number of chains\n"));
9299 nbuckets
= byte_get (nb
, hash_ent_size
);
9300 nchains
= byte_get (nc
, hash_ent_size
);
9302 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9303 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9306 if (buckets
== NULL
|| chains
== NULL
)
9308 if (do_using_dynamic
)
9319 if (dynamic_info_DT_GNU_HASH
9321 || (do_using_dynamic
9323 && dynamic_strings
!= NULL
)))
9325 unsigned char nb
[16];
9326 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9327 bfd_vma buckets_vma
;
9330 (archive_file_offset
9331 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9335 error (_("Unable to seek to start of dynamic information\n"));
9339 if (fread (nb
, 16, 1, file
) != 1)
9341 error (_("Failed to read in number of buckets\n"));
9345 ngnubuckets
= byte_get (nb
, 4);
9346 gnusymidx
= byte_get (nb
+ 4, 4);
9347 bitmaskwords
= byte_get (nb
+ 8, 4);
9348 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9350 buckets_vma
+= bitmaskwords
* 4;
9352 buckets_vma
+= bitmaskwords
* 8;
9355 (archive_file_offset
9356 + offset_from_vma (file
, buckets_vma
, 4)),
9359 error (_("Unable to seek to start of dynamic information\n"));
9363 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9365 if (gnubuckets
== NULL
)
9368 for (i
= 0; i
< ngnubuckets
; i
++)
9369 if (gnubuckets
[i
] != 0)
9371 if (gnubuckets
[i
] < gnusymidx
)
9374 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9375 maxchain
= gnubuckets
[i
];
9378 if (maxchain
== 0xffffffff)
9381 maxchain
-= gnusymidx
;
9384 (archive_file_offset
9385 + offset_from_vma (file
, buckets_vma
9386 + 4 * (ngnubuckets
+ maxchain
), 4)),
9389 error (_("Unable to seek to start of dynamic information\n"));
9395 if (fread (nb
, 4, 1, file
) != 1)
9397 error (_("Failed to determine last chain length\n"));
9401 if (maxchain
+ 1 == 0)
9406 while ((byte_get (nb
, 4) & 1) == 0);
9409 (archive_file_offset
9410 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9413 error (_("Unable to seek to start of dynamic information\n"));
9417 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9420 if (gnuchains
== NULL
)
9425 if (do_using_dynamic
)
9430 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9433 && dynamic_strings
!= NULL
)
9437 if (dynamic_info
[DT_HASH
])
9441 printf (_("\nSymbol table for image:\n"));
9443 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9445 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9447 for (hn
= 0; hn
< nbuckets
; hn
++)
9452 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9453 print_dynamic_symbol (si
, hn
);
9457 if (dynamic_info_DT_GNU_HASH
)
9459 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9461 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9463 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9465 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9466 if (gnubuckets
[hn
] != 0)
9468 bfd_vma si
= gnubuckets
[hn
];
9469 bfd_vma off
= si
- gnusymidx
;
9473 print_dynamic_symbol (si
, hn
);
9476 while ((gnuchains
[off
++] & 1) == 0);
9480 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9484 for (i
= 0, section
= section_headers
;
9485 i
< elf_header
.e_shnum
;
9489 char * strtab
= NULL
;
9490 unsigned long int strtab_size
= 0;
9491 Elf_Internal_Sym
* symtab
;
9492 Elf_Internal_Sym
* psym
;
9493 unsigned long num_syms
;
9495 if ((section
->sh_type
!= SHT_SYMTAB
9496 && section
->sh_type
!= SHT_DYNSYM
)
9498 && section
->sh_type
== SHT_SYMTAB
))
9501 if (section
->sh_entsize
== 0)
9503 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9504 SECTION_NAME (section
));
9508 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9509 SECTION_NAME (section
),
9510 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9513 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9515 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9517 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9521 if (section
->sh_link
== elf_header
.e_shstrndx
)
9523 strtab
= string_table
;
9524 strtab_size
= string_table_length
;
9526 else if (section
->sh_link
< elf_header
.e_shnum
)
9528 Elf_Internal_Shdr
* string_sec
;
9530 string_sec
= section_headers
+ section
->sh_link
;
9532 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9533 1, string_sec
->sh_size
,
9535 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9538 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9540 printf ("%6d: ", si
);
9541 print_vma (psym
->st_value
, LONG_HEX
);
9543 print_vma (psym
->st_size
, DEC_5
);
9544 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9545 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9546 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9547 /* Check to see if any other bits in the st_other field are set.
9548 Note - displaying this information disrupts the layout of the
9549 table being generated, but for the moment this case is very rare. */
9550 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9551 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9552 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9553 print_symbol (25, psym
->st_name
< strtab_size
9554 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9556 if (section
->sh_type
== SHT_DYNSYM
9557 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9559 unsigned char data
[2];
9560 unsigned short vers_data
;
9561 unsigned long offset
;
9565 offset
= offset_from_vma
9566 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9567 sizeof data
+ si
* sizeof (vers_data
));
9569 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9570 sizeof (data
), 1, _("version data")) == NULL
)
9573 vers_data
= byte_get (data
, 2);
9575 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9576 && section_headers
[psym
->st_shndx
].sh_type
9579 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9581 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9583 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9584 && (is_nobits
|| ! check_def
))
9586 Elf_External_Verneed evn
;
9587 Elf_Internal_Verneed ivn
;
9588 Elf_Internal_Vernaux ivna
;
9590 /* We must test both. */
9591 offset
= offset_from_vma
9592 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9597 unsigned long vna_off
;
9599 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9600 _("version need")) == NULL
)
9608 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9609 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9611 vna_off
= offset
+ ivn
.vn_aux
;
9615 Elf_External_Vernaux evna
;
9617 if (get_data (&evna
, file
, vna_off
,
9619 _("version need aux (3)")) == NULL
)
9627 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9628 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9629 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9632 vna_off
+= ivna
.vna_next
;
9634 while (ivna
.vna_other
!= vers_data
9635 && ivna
.vna_next
!= 0);
9637 if (ivna
.vna_other
== vers_data
)
9640 offset
+= ivn
.vn_next
;
9642 while (ivn
.vn_next
!= 0);
9644 if (ivna
.vna_other
== vers_data
)
9647 ivna
.vna_name
< strtab_size
9648 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9652 else if (! is_nobits
)
9653 error (_("bad dynamic symbol\n"));
9660 if (vers_data
!= 0x8001
9661 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9663 Elf_Internal_Verdef ivd
;
9664 Elf_Internal_Verdaux ivda
;
9665 Elf_External_Verdaux evda
;
9668 off
= offset_from_vma
9670 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9671 sizeof (Elf_External_Verdef
));
9675 Elf_External_Verdef evd
;
9677 if (get_data (&evd
, file
, off
, sizeof (evd
),
9678 1, _("version def")) == NULL
)
9686 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9687 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9688 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9693 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9694 && ivd
.vd_next
!= 0);
9699 if (get_data (&evda
, file
, off
, sizeof (evda
),
9700 1, _("version def aux")) == NULL
)
9703 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9705 if (psym
->st_name
!= ivda
.vda_name
)
9706 printf ((vers_data
& VERSYM_HIDDEN
)
9708 ivda
.vda_name
< strtab_size
9709 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9719 if (strtab
!= string_table
)
9725 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9727 if (do_histogram
&& buckets
!= NULL
)
9729 unsigned long * lengths
;
9730 unsigned long * counts
;
9733 unsigned long maxlength
= 0;
9734 unsigned long nzero_counts
= 0;
9735 unsigned long nsyms
= 0;
9737 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9738 (unsigned long) nbuckets
);
9739 printf (_(" Length Number %% of total Coverage\n"));
9741 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9742 if (lengths
== NULL
)
9744 error (_("Out of memory\n"));
9747 for (hn
= 0; hn
< nbuckets
; ++hn
)
9749 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9752 if (maxlength
< ++lengths
[hn
])
9757 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9760 error (_("Out of memory\n"));
9764 for (hn
= 0; hn
< nbuckets
; ++hn
)
9765 ++counts
[lengths
[hn
]];
9770 printf (" 0 %-10lu (%5.1f%%)\n",
9771 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9772 for (i
= 1; i
<= maxlength
; ++i
)
9774 nzero_counts
+= counts
[i
] * i
;
9775 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9776 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9777 (nzero_counts
* 100.0) / nsyms
);
9785 if (buckets
!= NULL
)
9791 if (do_histogram
&& gnubuckets
!= NULL
)
9793 unsigned long * lengths
;
9794 unsigned long * counts
;
9796 unsigned long maxlength
= 0;
9797 unsigned long nzero_counts
= 0;
9798 unsigned long nsyms
= 0;
9800 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9801 if (lengths
== NULL
)
9803 error (_("Out of memory\n"));
9807 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9808 (unsigned long) ngnubuckets
);
9809 printf (_(" Length Number %% of total Coverage\n"));
9811 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9812 if (gnubuckets
[hn
] != 0)
9814 bfd_vma off
, length
= 1;
9816 for (off
= gnubuckets
[hn
] - gnusymidx
;
9817 (gnuchains
[off
] & 1) == 0; ++off
)
9819 lengths
[hn
] = length
;
9820 if (length
> maxlength
)
9825 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9828 error (_("Out of memory\n"));
9832 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9833 ++counts
[lengths
[hn
]];
9835 if (ngnubuckets
> 0)
9838 printf (" 0 %-10lu (%5.1f%%)\n",
9839 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9840 for (j
= 1; j
<= maxlength
; ++j
)
9842 nzero_counts
+= counts
[j
] * j
;
9843 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9844 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9845 (nzero_counts
* 100.0) / nsyms
);
9859 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9863 if (dynamic_syminfo
== NULL
9865 /* No syminfo, this is ok. */
9868 /* There better should be a dynamic symbol section. */
9869 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9873 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9874 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9876 printf (_(" Num: Name BoundTo Flags\n"));
9877 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9879 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9881 printf ("%4d: ", i
);
9882 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9883 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9885 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9888 switch (dynamic_syminfo
[i
].si_boundto
)
9890 case SYMINFO_BT_SELF
:
9891 fputs ("SELF ", stdout
);
9893 case SYMINFO_BT_PARENT
:
9894 fputs ("PARENT ", stdout
);
9897 if (dynamic_syminfo
[i
].si_boundto
> 0
9898 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9899 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9901 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9905 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9909 if (flags
& SYMINFO_FLG_DIRECT
)
9911 if (flags
& SYMINFO_FLG_PASSTHRU
)
9912 printf (" PASSTHRU");
9913 if (flags
& SYMINFO_FLG_COPY
)
9915 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9916 printf (" LAZYLOAD");
9924 /* Check to see if the given reloc needs to be handled in a target specific
9925 manner. If so then process the reloc and return TRUE otherwise return
9929 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9930 unsigned char * start
,
9931 Elf_Internal_Sym
* symtab
)
9933 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9935 switch (elf_header
.e_machine
)
9938 case EM_CYGNUS_MN10300
:
9940 static Elf_Internal_Sym
* saved_sym
= NULL
;
9944 case 34: /* R_MN10300_ALIGN */
9946 case 33: /* R_MN10300_SYM_DIFF */
9947 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9949 case 1: /* R_MN10300_32 */
9950 case 2: /* R_MN10300_16 */
9951 if (saved_sym
!= NULL
)
9955 value
= reloc
->r_addend
9956 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9957 - saved_sym
->st_value
);
9959 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9966 if (saved_sym
!= NULL
)
9967 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9977 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9978 DWARF debug sections. This is a target specific test. Note - we do not
9979 go through the whole including-target-headers-multiple-times route, (as
9980 we have already done with <elf/h8.h>) because this would become very
9981 messy and even then this function would have to contain target specific
9982 information (the names of the relocs instead of their numeric values).
9983 FIXME: This is not the correct way to solve this problem. The proper way
9984 is to have target specific reloc sizing and typing functions created by
9985 the reloc-macros.h header, in the same way that it already creates the
9986 reloc naming functions. */
9989 is_32bit_abs_reloc (unsigned int reloc_type
)
9991 switch (elf_header
.e_machine
)
9995 return reloc_type
== 1; /* R_386_32. */
9997 return reloc_type
== 1; /* R_68K_32. */
9999 return reloc_type
== 1; /* R_860_32. */
10001 return reloc_type
== 2; /* R_960_32. */
10003 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10005 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10007 return reloc_type
== 1; /* R_ARC_32. */
10009 return reloc_type
== 2; /* R_ARM_ABS32 */
10012 return reloc_type
== 1;
10013 case EM_ADAPTEVA_EPIPHANY
:
10014 return reloc_type
== 3;
10016 return reloc_type
== 0x12; /* R_byte4_data. */
10018 return reloc_type
== 3; /* R_CRIS_32. */
10020 return reloc_type
== 3; /* R_CR16_NUM32. */
10022 return reloc_type
== 15; /* R_CRX_NUM32. */
10023 case EM_CYGNUS_FRV
:
10024 return reloc_type
== 1;
10025 case EM_CYGNUS_D10V
:
10027 return reloc_type
== 6; /* R_D10V_32. */
10028 case EM_CYGNUS_D30V
:
10030 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10032 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10033 case EM_CYGNUS_FR30
:
10035 return reloc_type
== 3; /* R_FR30_32. */
10039 return reloc_type
== 1; /* R_H8_DIR32. */
10041 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10044 return reloc_type
== 2; /* R_IP2K_32. */
10046 return reloc_type
== 2; /* R_IQ2000_32. */
10047 case EM_LATTICEMICO32
:
10048 return reloc_type
== 3; /* R_LM32_32. */
10051 return reloc_type
== 3; /* R_M32C_32. */
10053 return reloc_type
== 34; /* R_M32R_32_RELA. */
10055 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10056 case EM_CYGNUS_MEP
:
10057 return reloc_type
== 4; /* R_MEP_32. */
10059 return reloc_type
== 2; /* R_METAG_ADDR32. */
10060 case EM_MICROBLAZE
:
10061 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10063 return reloc_type
== 2; /* R_MIPS_32. */
10065 return reloc_type
== 4; /* R_MMIX_32. */
10066 case EM_CYGNUS_MN10200
:
10068 return reloc_type
== 1; /* R_MN10200_32. */
10069 case EM_CYGNUS_MN10300
:
10071 return reloc_type
== 1; /* R_MN10300_32. */
10073 return reloc_type
== 1; /* R_MOXIE_32. */
10074 case EM_MSP430_OLD
:
10076 return reloc_type
== 1; /* R_MSP43_32. */
10078 return reloc_type
== 2; /* R_MT_32. */
10079 case EM_ALTERA_NIOS2
:
10081 return reloc_type
== 1; /* R_NIOS_32. */
10084 return reloc_type
== 1; /* R_OR32_32. */
10086 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10087 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10090 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10092 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10094 return reloc_type
== 1; /* R_PPC_ADDR32. */
10096 return reloc_type
== 1; /* R_RL78_DIR32. */
10098 return reloc_type
== 1; /* R_RX_DIR32. */
10100 return reloc_type
== 1; /* R_I370_ADDR31. */
10103 return reloc_type
== 4; /* R_S390_32. */
10105 return reloc_type
== 8; /* R_SCORE_ABS32. */
10107 return reloc_type
== 1; /* R_SH_DIR32. */
10108 case EM_SPARC32PLUS
:
10111 return reloc_type
== 3 /* R_SPARC_32. */
10112 || reloc_type
== 23; /* R_SPARC_UA32. */
10114 return reloc_type
== 6; /* R_SPU_ADDR32 */
10116 return reloc_type
== 1; /* R_C6000_ABS32. */
10118 return reloc_type
== 2; /* R_TILEGX_32. */
10120 return reloc_type
== 1; /* R_TILEPRO_32. */
10121 case EM_CYGNUS_V850
:
10123 return reloc_type
== 6; /* R_V850_ABS32. */
10125 return reloc_type
== 0x33; /* R_V810_WORD. */
10127 return reloc_type
== 1; /* R_VAX_32. */
10131 return reloc_type
== 10; /* R_X86_64_32. */
10134 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10136 return reloc_type
== 4; /* R_XGATE_32. */
10138 return reloc_type
== 1; /* R_XSTROMY16_32. */
10139 case EM_XTENSA_OLD
:
10141 return reloc_type
== 1; /* R_XTENSA_32. */
10143 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10144 elf_header
.e_machine
);
10149 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10150 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10153 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10155 switch (elf_header
.e_machine
)
10159 return reloc_type
== 2; /* R_386_PC32. */
10161 return reloc_type
== 4; /* R_68K_PC32. */
10163 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10164 case EM_ADAPTEVA_EPIPHANY
:
10165 return reloc_type
== 6;
10167 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10169 return reloc_type
== 3; /* R_ARM_REL32 */
10170 case EM_MICROBLAZE
:
10171 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10173 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10175 return reloc_type
== 26; /* R_PPC_REL32. */
10177 return reloc_type
== 26; /* R_PPC64_REL32. */
10180 return reloc_type
== 5; /* R_390_PC32. */
10182 return reloc_type
== 2; /* R_SH_REL32. */
10183 case EM_SPARC32PLUS
:
10186 return reloc_type
== 6; /* R_SPARC_DISP32. */
10188 return reloc_type
== 13; /* R_SPU_REL32. */
10190 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10192 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10196 return reloc_type
== 2; /* R_X86_64_PC32. */
10197 case EM_XTENSA_OLD
:
10199 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10201 /* Do not abort or issue an error message here. Not all targets use
10202 pc-relative 32-bit relocs in their DWARF debug information and we
10203 have already tested for target coverage in is_32bit_abs_reloc. A
10204 more helpful warning message will be generated by apply_relocations
10205 anyway, so just return. */
10210 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10211 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10214 is_64bit_abs_reloc (unsigned int reloc_type
)
10216 switch (elf_header
.e_machine
)
10219 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10221 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10223 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10225 return reloc_type
== 80; /* R_PARISC_DIR64. */
10227 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10228 case EM_SPARC32PLUS
:
10231 return reloc_type
== 54; /* R_SPARC_UA64. */
10235 return reloc_type
== 1; /* R_X86_64_64. */
10238 return reloc_type
== 22; /* R_S390_64. */
10240 return reloc_type
== 1; /* R_TILEGX_64. */
10242 return reloc_type
== 18; /* R_MIPS_64. */
10248 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10249 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10252 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10254 switch (elf_header
.e_machine
)
10257 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10259 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10261 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10263 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10265 return reloc_type
== 44; /* R_PPC64_REL64. */
10266 case EM_SPARC32PLUS
:
10269 return reloc_type
== 46; /* R_SPARC_DISP64. */
10273 return reloc_type
== 24; /* R_X86_64_PC64. */
10276 return reloc_type
== 23; /* R_S390_PC64. */
10278 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10284 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10285 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10288 is_24bit_abs_reloc (unsigned int reloc_type
)
10290 switch (elf_header
.e_machine
)
10292 case EM_CYGNUS_MN10200
:
10294 return reloc_type
== 4; /* R_MN10200_24. */
10300 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10301 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10304 is_16bit_abs_reloc (unsigned int reloc_type
)
10306 switch (elf_header
.e_machine
)
10310 return reloc_type
== 4; /* R_AVR_16. */
10311 case EM_ADAPTEVA_EPIPHANY
:
10312 return reloc_type
== 5;
10313 case EM_CYGNUS_D10V
:
10315 return reloc_type
== 3; /* R_D10V_16. */
10319 return reloc_type
== R_H8_DIR16
;
10322 return reloc_type
== 1; /* R_IP2K_16. */
10325 return reloc_type
== 1; /* R_M32C_16 */
10326 case EM_MSP430_OLD
:
10328 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10329 case EM_ALTERA_NIOS2
:
10331 return reloc_type
== 9; /* R_NIOS_16. */
10333 return reloc_type
== 2; /* R_C6000_ABS16. */
10336 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10337 case EM_CYGNUS_MN10200
:
10339 return reloc_type
== 2; /* R_MN10200_16. */
10340 case EM_CYGNUS_MN10300
:
10342 return reloc_type
== 2; /* R_MN10300_16. */
10344 return reloc_type
== 3; /* R_XGATE_16. */
10350 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10351 relocation entries (possibly formerly used for SHT_GROUP sections). */
10354 is_none_reloc (unsigned int reloc_type
)
10356 switch (elf_header
.e_machine
)
10358 case EM_68K
: /* R_68K_NONE. */
10359 case EM_386
: /* R_386_NONE. */
10360 case EM_SPARC32PLUS
:
10362 case EM_SPARC
: /* R_SPARC_NONE. */
10363 case EM_MIPS
: /* R_MIPS_NONE. */
10364 case EM_PARISC
: /* R_PARISC_NONE. */
10365 case EM_ALPHA
: /* R_ALPHA_NONE. */
10366 case EM_ADAPTEVA_EPIPHANY
:
10367 case EM_PPC
: /* R_PPC_NONE. */
10368 case EM_PPC64
: /* R_PPC64_NONE. */
10369 case EM_ARM
: /* R_ARM_NONE. */
10370 case EM_IA_64
: /* R_IA64_NONE. */
10371 case EM_SH
: /* R_SH_NONE. */
10373 case EM_S390
: /* R_390_NONE. */
10374 case EM_CRIS
: /* R_CRIS_NONE. */
10375 case EM_X86_64
: /* R_X86_64_NONE. */
10376 case EM_L1OM
: /* R_X86_64_NONE. */
10377 case EM_K1OM
: /* R_X86_64_NONE. */
10378 case EM_MN10300
: /* R_MN10300_NONE. */
10379 case EM_MOXIE
: /* R_MOXIE_NONE. */
10380 case EM_M32R
: /* R_M32R_NONE. */
10381 case EM_TI_C6000
:/* R_C6000_NONE. */
10382 case EM_TILEGX
: /* R_TILEGX_NONE. */
10383 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10385 case EM_C166
: /* R_XC16X_NONE. */
10386 return reloc_type
== 0;
10388 return reloc_type
== 0 || reloc_type
== 256;
10389 case EM_XTENSA_OLD
:
10391 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10392 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10393 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10394 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10396 return reloc_type
== 3; /* R_METAG_NONE. */
10401 /* Apply relocations to a section.
10402 Note: So far support has been added only for those relocations
10403 which can be found in debug sections.
10404 FIXME: Add support for more relocations ? */
10407 apply_relocations (void * file
,
10408 Elf_Internal_Shdr
* section
,
10409 unsigned char * start
)
10411 Elf_Internal_Shdr
* relsec
;
10412 unsigned char * end
= start
+ section
->sh_size
;
10414 if (elf_header
.e_type
!= ET_REL
)
10417 /* Find the reloc section associated with the section. */
10418 for (relsec
= section_headers
;
10419 relsec
< section_headers
+ elf_header
.e_shnum
;
10422 bfd_boolean is_rela
;
10423 unsigned long num_relocs
;
10424 Elf_Internal_Rela
* relocs
;
10425 Elf_Internal_Rela
* rp
;
10426 Elf_Internal_Shdr
* symsec
;
10427 Elf_Internal_Sym
* symtab
;
10428 unsigned long num_syms
;
10429 Elf_Internal_Sym
* sym
;
10431 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10432 || relsec
->sh_info
>= elf_header
.e_shnum
10433 || section_headers
+ relsec
->sh_info
!= section
10434 || relsec
->sh_size
== 0
10435 || relsec
->sh_link
>= elf_header
.e_shnum
)
10438 is_rela
= relsec
->sh_type
== SHT_RELA
;
10442 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10443 relsec
->sh_size
, & relocs
, & num_relocs
))
10448 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10449 relsec
->sh_size
, & relocs
, & num_relocs
))
10453 /* SH uses RELA but uses in place value instead of the addend field. */
10454 if (elf_header
.e_machine
== EM_SH
)
10457 symsec
= section_headers
+ relsec
->sh_link
;
10458 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10460 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10463 unsigned int reloc_type
;
10464 unsigned int reloc_size
;
10465 unsigned char * rloc
;
10466 unsigned long sym_index
;
10468 reloc_type
= get_reloc_type (rp
->r_info
);
10470 if (target_specific_reloc_handling (rp
, start
, symtab
))
10472 else if (is_none_reloc (reloc_type
))
10474 else if (is_32bit_abs_reloc (reloc_type
)
10475 || is_32bit_pcrel_reloc (reloc_type
))
10477 else if (is_64bit_abs_reloc (reloc_type
)
10478 || is_64bit_pcrel_reloc (reloc_type
))
10480 else if (is_24bit_abs_reloc (reloc_type
))
10482 else if (is_16bit_abs_reloc (reloc_type
))
10486 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10487 reloc_type
, SECTION_NAME (section
));
10491 rloc
= start
+ rp
->r_offset
;
10492 if ((rloc
+ reloc_size
) > end
)
10494 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10495 (unsigned long) rp
->r_offset
,
10496 SECTION_NAME (section
));
10500 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10501 if (sym_index
>= num_syms
)
10503 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10504 sym_index
, SECTION_NAME (section
));
10507 sym
= symtab
+ sym_index
;
10509 /* If the reloc has a symbol associated with it,
10510 make sure that it is of an appropriate type.
10512 Relocations against symbols without type can happen.
10513 Gcc -feliminate-dwarf2-dups may generate symbols
10514 without type for debug info.
10516 Icc generates relocations against function symbols
10517 instead of local labels.
10519 Relocations against object symbols can happen, eg when
10520 referencing a global array. For an example of this see
10521 the _clz.o binary in libgcc.a. */
10523 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10525 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10526 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10527 (long int)(rp
- relocs
),
10528 SECTION_NAME (relsec
));
10534 addend
+= rp
->r_addend
;
10535 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10536 partial_inplace. */
10538 || (elf_header
.e_machine
== EM_XTENSA
10539 && reloc_type
== 1)
10540 || ((elf_header
.e_machine
== EM_PJ
10541 || elf_header
.e_machine
== EM_PJ_OLD
)
10542 && reloc_type
== 1)
10543 || ((elf_header
.e_machine
== EM_D30V
10544 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10545 && reloc_type
== 12))
10546 addend
+= byte_get (rloc
, reloc_size
);
10548 if (is_32bit_pcrel_reloc (reloc_type
)
10549 || is_64bit_pcrel_reloc (reloc_type
))
10551 /* On HPPA, all pc-relative relocations are biased by 8. */
10552 if (elf_header
.e_machine
== EM_PARISC
)
10554 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10558 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10567 #ifdef SUPPORT_DISASSEMBLY
10569 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10571 printf (_("\nAssembly dump of section %s\n"),
10572 SECTION_NAME (section
));
10574 /* XXX -- to be done --- XXX */
10580 /* Reads in the contents of SECTION from FILE, returning a pointer
10581 to a malloc'ed buffer or NULL if something went wrong. */
10584 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10586 bfd_size_type num_bytes
;
10588 num_bytes
= section
->sh_size
;
10590 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10592 printf (_("\nSection '%s' has no data to dump.\n"),
10593 SECTION_NAME (section
));
10597 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10598 _("section contents"));
10603 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10605 Elf_Internal_Shdr
* relsec
;
10606 bfd_size_type num_bytes
;
10610 char * name
= SECTION_NAME (section
);
10611 bfd_boolean some_strings_shown
;
10613 start
= get_section_contents (section
, file
);
10617 printf (_("\nString dump of section '%s':\n"), name
);
10619 /* If the section being dumped has relocations against it the user might
10620 be expecting these relocations to have been applied. Check for this
10621 case and issue a warning message in order to avoid confusion.
10622 FIXME: Maybe we ought to have an option that dumps a section with
10623 relocs applied ? */
10624 for (relsec
= section_headers
;
10625 relsec
< section_headers
+ elf_header
.e_shnum
;
10628 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10629 || relsec
->sh_info
>= elf_header
.e_shnum
10630 || section_headers
+ relsec
->sh_info
!= section
10631 || relsec
->sh_size
== 0
10632 || relsec
->sh_link
>= elf_header
.e_shnum
)
10635 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10639 num_bytes
= section
->sh_size
;
10641 end
= start
+ num_bytes
;
10642 some_strings_shown
= FALSE
;
10646 while (!ISPRINT (* data
))
10647 if (++ data
>= end
)
10653 /* PR 11128: Use two separate invocations in order to work
10654 around bugs in the Solaris 8 implementation of printf. */
10655 printf (" [%6tx] ", data
- start
);
10656 printf ("%s\n", data
);
10658 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10660 data
+= strlen (data
);
10661 some_strings_shown
= TRUE
;
10665 if (! some_strings_shown
)
10666 printf (_(" No strings found in this section."));
10674 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10676 bfd_boolean relocate
)
10678 Elf_Internal_Shdr
* relsec
;
10679 bfd_size_type bytes
;
10681 unsigned char * data
;
10682 unsigned char * start
;
10684 start
= (unsigned char *) get_section_contents (section
, file
);
10688 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10692 apply_relocations (file
, section
, start
);
10696 /* If the section being dumped has relocations against it the user might
10697 be expecting these relocations to have been applied. Check for this
10698 case and issue a warning message in order to avoid confusion.
10699 FIXME: Maybe we ought to have an option that dumps a section with
10700 relocs applied ? */
10701 for (relsec
= section_headers
;
10702 relsec
< section_headers
+ elf_header
.e_shnum
;
10705 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10706 || relsec
->sh_info
>= elf_header
.e_shnum
10707 || section_headers
+ relsec
->sh_info
!= section
10708 || relsec
->sh_size
== 0
10709 || relsec
->sh_link
>= elf_header
.e_shnum
)
10712 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10717 addr
= section
->sh_addr
;
10718 bytes
= section
->sh_size
;
10727 lbytes
= (bytes
> 16 ? 16 : bytes
);
10729 printf (" 0x%8.8lx ", (unsigned long) addr
);
10731 for (j
= 0; j
< 16; j
++)
10734 printf ("%2.2x", data
[j
]);
10742 for (j
= 0; j
< lbytes
; j
++)
10745 if (k
>= ' ' && k
< 0x7f)
10763 /* Uncompresses a section that was compressed using zlib, in place. */
10766 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10767 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10769 #ifndef HAVE_ZLIB_H
10772 dwarf_size_type compressed_size
= *size
;
10773 unsigned char * compressed_buffer
= *buffer
;
10774 dwarf_size_type uncompressed_size
;
10775 unsigned char * uncompressed_buffer
;
10778 dwarf_size_type header_size
= 12;
10780 /* Read the zlib header. In this case, it should be "ZLIB" followed
10781 by the uncompressed section size, 8 bytes in big-endian order. */
10782 if (compressed_size
< header_size
10783 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10786 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10787 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10788 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10789 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10790 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10791 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10792 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10793 uncompressed_size
+= compressed_buffer
[11];
10795 /* It is possible the section consists of several compressed
10796 buffers concatenated together, so we uncompress in a loop. */
10797 strm
.zalloc
= NULL
;
10799 strm
.opaque
= NULL
;
10800 strm
.avail_in
= compressed_size
- header_size
;
10801 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10802 strm
.avail_out
= uncompressed_size
;
10803 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10805 rc
= inflateInit (& strm
);
10806 while (strm
.avail_in
> 0)
10810 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10811 + (uncompressed_size
- strm
.avail_out
));
10812 rc
= inflate (&strm
, Z_FINISH
);
10813 if (rc
!= Z_STREAM_END
)
10815 rc
= inflateReset (& strm
);
10817 rc
= inflateEnd (& strm
);
10819 || strm
.avail_out
!= 0)
10822 free (compressed_buffer
);
10823 *buffer
= uncompressed_buffer
;
10824 *size
= uncompressed_size
;
10828 free (uncompressed_buffer
);
10829 /* Indicate decompression failure. */
10832 #endif /* HAVE_ZLIB_H */
10836 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10837 Elf_Internal_Shdr
* sec
, void * file
)
10839 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10842 /* If it is already loaded, do nothing. */
10843 if (section
->start
!= NULL
)
10846 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10847 section
->address
= sec
->sh_addr
;
10848 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10850 sec
->sh_size
, buf
);
10851 if (section
->start
== NULL
)
10855 section
->size
= sec
->sh_size
;
10856 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10857 sec
->sh_size
= section
->size
;
10860 if (section
->start
== NULL
)
10863 if (debug_displays
[debug
].relocate
)
10864 apply_relocations ((FILE *) file
, sec
, section
->start
);
10869 /* If this is not NULL, load_debug_section will only look for sections
10870 within the list of sections given here. */
10871 unsigned int *section_subset
= NULL
;
10874 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10876 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10877 Elf_Internal_Shdr
* sec
;
10879 /* Locate the debug section. */
10880 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10882 section
->name
= section
->uncompressed_name
;
10885 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10887 section
->name
= section
->compressed_name
;
10892 /* If we're loading from a subset of sections, and we've loaded
10893 a section matching this name before, it's likely that it's a
10895 if (section_subset
!= NULL
)
10896 free_debug_section (debug
);
10898 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10902 free_debug_section (enum dwarf_section_display_enum debug
)
10904 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10906 if (section
->start
== NULL
)
10909 free ((char *) section
->start
);
10910 section
->start
= NULL
;
10911 section
->address
= 0;
10916 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10918 char * name
= SECTION_NAME (section
);
10919 bfd_size_type length
;
10923 length
= section
->sh_size
;
10926 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10929 if (section
->sh_type
== SHT_NOBITS
)
10931 /* There is no point in dumping the contents of a debugging section
10932 which has the NOBITS type - the bits in the file will be random.
10933 This can happen when a file containing a .eh_frame section is
10934 stripped with the --only-keep-debug command line option. */
10935 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10939 if (const_strneq (name
, ".gnu.linkonce.wi."))
10940 name
= ".debug_info";
10942 /* See if we know how to display the contents of this section. */
10943 for (i
= 0; i
< max
; i
++)
10944 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10945 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10947 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10948 int secondary
= (section
!= find_section (name
));
10951 free_debug_section ((enum dwarf_section_display_enum
) i
);
10953 if (streq (sec
->uncompressed_name
, name
))
10954 sec
->name
= sec
->uncompressed_name
;
10956 sec
->name
= sec
->compressed_name
;
10957 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10960 /* If this debug section is part of a CU/TU set in a .dwp file,
10961 restrict load_debug_section to the sections in that set. */
10962 section_subset
= find_cu_tu_set (file
, shndx
);
10964 result
&= debug_displays
[i
].display (sec
, file
);
10966 section_subset
= NULL
;
10968 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10969 free_debug_section ((enum dwarf_section_display_enum
) i
);
10977 printf (_("Unrecognized debug section: %s\n"), name
);
10984 /* Set DUMP_SECTS for all sections where dumps were requested
10985 based on section name. */
10988 initialise_dumps_byname (void)
10990 struct dump_list_entry
* cur
;
10992 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10997 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10998 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11000 request_dump_bynumber (i
, cur
->type
);
11005 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11011 process_section_contents (FILE * file
)
11013 Elf_Internal_Shdr
* section
;
11019 initialise_dumps_byname ();
11021 for (i
= 0, section
= section_headers
;
11022 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11025 #ifdef SUPPORT_DISASSEMBLY
11026 if (dump_sects
[i
] & DISASS_DUMP
)
11027 disassemble_section (section
, file
);
11029 if (dump_sects
[i
] & HEX_DUMP
)
11030 dump_section_as_bytes (section
, file
, FALSE
);
11032 if (dump_sects
[i
] & RELOC_DUMP
)
11033 dump_section_as_bytes (section
, file
, TRUE
);
11035 if (dump_sects
[i
] & STRING_DUMP
)
11036 dump_section_as_strings (section
, file
);
11038 if (dump_sects
[i
] & DEBUG_DUMP
)
11039 display_debug_section (i
, section
, file
);
11042 /* Check to see if the user requested a
11043 dump of a section that does not exist. */
11044 while (i
++ < num_dump_sects
)
11046 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11050 process_mips_fpe_exception (int mask
)
11055 if (mask
& OEX_FPU_INEX
)
11056 fputs ("INEX", stdout
), first
= 0;
11057 if (mask
& OEX_FPU_UFLO
)
11058 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11059 if (mask
& OEX_FPU_OFLO
)
11060 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11061 if (mask
& OEX_FPU_DIV0
)
11062 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11063 if (mask
& OEX_FPU_INVAL
)
11064 printf ("%sINVAL", first
? "" : "|");
11067 fputs ("0", stdout
);
11070 /* ARM EABI attributes section. */
11075 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11077 const char ** table
;
11078 } arm_attr_public_tag
;
11080 static const char * arm_attr_tag_CPU_arch
[] =
11081 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11082 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11083 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11084 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11085 {"No", "Thumb-1", "Thumb-2"};
11086 static const char * arm_attr_tag_FP_arch
[] =
11087 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11089 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11090 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11091 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11092 static const char * arm_attr_tag_PCS_config
[] =
11093 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11094 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11095 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11096 {"V6", "SB", "TLS", "Unused"};
11097 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11098 {"Absolute", "PC-relative", "SB-relative", "None"};
11099 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11100 {"Absolute", "PC-relative", "None"};
11101 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11102 {"None", "direct", "GOT-indirect"};
11103 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11104 {"None", "??? 1", "2", "??? 3", "4"};
11105 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11106 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11107 {"Unused", "Needed", "Sign only"};
11108 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11109 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11110 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11111 {"Unused", "Finite", "RTABI", "IEEE 754"};
11112 static const char * arm_attr_tag_ABI_enum_size
[] =
11113 {"Unused", "small", "int", "forced to int"};
11114 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11115 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11116 static const char * arm_attr_tag_ABI_VFP_args
[] =
11117 {"AAPCS", "VFP registers", "custom"};
11118 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11119 {"AAPCS", "WMMX registers", "custom"};
11120 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11121 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11122 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11123 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11124 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11125 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11126 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11127 static const char * arm_attr_tag_FP_HP_extension
[] =
11128 {"Not Allowed", "Allowed"};
11129 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11130 {"None", "IEEE 754", "Alternative Format"};
11131 static const char * arm_attr_tag_MPextension_use
[] =
11132 {"Not Allowed", "Allowed"};
11133 static const char * arm_attr_tag_DIV_use
[] =
11134 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11135 "Allowed in v7-A with integer division extension"};
11136 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11137 static const char * arm_attr_tag_Virtualization_use
[] =
11138 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11139 "TrustZone and Virtualization Extensions"};
11140 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11141 {"Not Allowed", "Allowed"};
11143 #define LOOKUP(id, name) \
11144 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11145 static arm_attr_public_tag arm_attr_public_tags
[] =
11147 {4, "CPU_raw_name", 1, NULL
},
11148 {5, "CPU_name", 1, NULL
},
11149 LOOKUP(6, CPU_arch
),
11150 {7, "CPU_arch_profile", 0, NULL
},
11151 LOOKUP(8, ARM_ISA_use
),
11152 LOOKUP(9, THUMB_ISA_use
),
11153 LOOKUP(10, FP_arch
),
11154 LOOKUP(11, WMMX_arch
),
11155 LOOKUP(12, Advanced_SIMD_arch
),
11156 LOOKUP(13, PCS_config
),
11157 LOOKUP(14, ABI_PCS_R9_use
),
11158 LOOKUP(15, ABI_PCS_RW_data
),
11159 LOOKUP(16, ABI_PCS_RO_data
),
11160 LOOKUP(17, ABI_PCS_GOT_use
),
11161 LOOKUP(18, ABI_PCS_wchar_t
),
11162 LOOKUP(19, ABI_FP_rounding
),
11163 LOOKUP(20, ABI_FP_denormal
),
11164 LOOKUP(21, ABI_FP_exceptions
),
11165 LOOKUP(22, ABI_FP_user_exceptions
),
11166 LOOKUP(23, ABI_FP_number_model
),
11167 {24, "ABI_align_needed", 0, NULL
},
11168 {25, "ABI_align_preserved", 0, NULL
},
11169 LOOKUP(26, ABI_enum_size
),
11170 LOOKUP(27, ABI_HardFP_use
),
11171 LOOKUP(28, ABI_VFP_args
),
11172 LOOKUP(29, ABI_WMMX_args
),
11173 LOOKUP(30, ABI_optimization_goals
),
11174 LOOKUP(31, ABI_FP_optimization_goals
),
11175 {32, "compatibility", 0, NULL
},
11176 LOOKUP(34, CPU_unaligned_access
),
11177 LOOKUP(36, FP_HP_extension
),
11178 LOOKUP(38, ABI_FP_16bit_format
),
11179 LOOKUP(42, MPextension_use
),
11180 LOOKUP(44, DIV_use
),
11181 {64, "nodefaults", 0, NULL
},
11182 {65, "also_compatible_with", 0, NULL
},
11183 LOOKUP(66, T2EE_use
),
11184 {67, "conformance", 1, NULL
},
11185 LOOKUP(68, Virtualization_use
),
11186 LOOKUP(70, MPextension_use_legacy
)
11190 static unsigned char *
11191 display_arm_attribute (unsigned char * p
)
11196 arm_attr_public_tag
* attr
;
11200 tag
= read_uleb128 (p
, &len
);
11203 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11205 if (arm_attr_public_tags
[i
].tag
== tag
)
11207 attr
= &arm_attr_public_tags
[i
];
11214 printf (" Tag_%s: ", attr
->name
);
11215 switch (attr
->type
)
11220 case 7: /* Tag_CPU_arch_profile. */
11221 val
= read_uleb128 (p
, &len
);
11225 case 0: printf (_("None\n")); break;
11226 case 'A': printf (_("Application\n")); break;
11227 case 'R': printf (_("Realtime\n")); break;
11228 case 'M': printf (_("Microcontroller\n")); break;
11229 case 'S': printf (_("Application or Realtime\n")); break;
11230 default: printf ("??? (%d)\n", val
); break;
11234 case 24: /* Tag_align_needed. */
11235 val
= read_uleb128 (p
, &len
);
11239 case 0: printf (_("None\n")); break;
11240 case 1: printf (_("8-byte\n")); break;
11241 case 2: printf (_("4-byte\n")); break;
11242 case 3: printf ("??? 3\n"); break;
11245 printf (_("8-byte and up to %d-byte extended\n"),
11248 printf ("??? (%d)\n", val
);
11253 case 25: /* Tag_align_preserved. */
11254 val
= read_uleb128 (p
, &len
);
11258 case 0: printf (_("None\n")); break;
11259 case 1: printf (_("8-byte, except leaf SP\n")); break;
11260 case 2: printf (_("8-byte\n")); break;
11261 case 3: printf ("??? 3\n"); break;
11264 printf (_("8-byte and up to %d-byte extended\n"),
11267 printf ("??? (%d)\n", val
);
11272 case 32: /* Tag_compatibility. */
11273 val
= read_uleb128 (p
, &len
);
11275 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11276 p
+= strlen ((char *) p
) + 1;
11279 case 64: /* Tag_nodefaults. */
11281 printf (_("True\n"));
11284 case 65: /* Tag_also_compatible_with. */
11285 val
= read_uleb128 (p
, &len
);
11287 if (val
== 6 /* Tag_CPU_arch. */)
11289 val
= read_uleb128 (p
, &len
);
11291 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11292 printf ("??? (%d)\n", val
);
11294 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11298 while (*(p
++) != '\0' /* NUL terminator. */);
11312 assert (attr
->type
& 0x80);
11313 val
= read_uleb128 (p
, &len
);
11315 type
= attr
->type
& 0x7f;
11317 printf ("??? (%d)\n", val
);
11319 printf ("%s\n", attr
->table
[val
]);
11326 type
= 1; /* String. */
11328 type
= 2; /* uleb128. */
11329 printf (" Tag_unknown_%d: ", tag
);
11334 printf ("\"%s\"\n", p
);
11335 p
+= strlen ((char *) p
) + 1;
11339 val
= read_uleb128 (p
, &len
);
11341 printf ("%d (0x%x)\n", val
, val
);
11347 static unsigned char *
11348 display_gnu_attribute (unsigned char * p
,
11349 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11356 tag
= read_uleb128 (p
, &len
);
11359 /* Tag_compatibility is the only generic GNU attribute defined at
11363 val
= read_uleb128 (p
, &len
);
11365 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11366 p
+= strlen ((char *) p
) + 1;
11370 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11371 return display_proc_gnu_attribute (p
, tag
);
11374 type
= 1; /* String. */
11376 type
= 2; /* uleb128. */
11377 printf (" Tag_unknown_%d: ", tag
);
11381 printf ("\"%s\"\n", p
);
11382 p
+= strlen ((char *) p
) + 1;
11386 val
= read_uleb128 (p
, &len
);
11388 printf ("%d (0x%x)\n", val
, val
);
11394 static unsigned char *
11395 display_power_gnu_attribute (unsigned char * p
, int tag
)
11401 if (tag
== Tag_GNU_Power_ABI_FP
)
11403 val
= read_uleb128 (p
, &len
);
11405 printf (" Tag_GNU_Power_ABI_FP: ");
11410 printf (_("Hard or soft float\n"));
11413 printf (_("Hard float\n"));
11416 printf (_("Soft float\n"));
11419 printf (_("Single-precision hard float\n"));
11422 printf ("??? (%d)\n", val
);
11428 if (tag
== Tag_GNU_Power_ABI_Vector
)
11430 val
= read_uleb128 (p
, &len
);
11432 printf (" Tag_GNU_Power_ABI_Vector: ");
11436 printf (_("Any\n"));
11439 printf (_("Generic\n"));
11442 printf ("AltiVec\n");
11448 printf ("??? (%d)\n", val
);
11454 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11456 val
= read_uleb128 (p
, &len
);
11458 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11462 printf (_("Any\n"));
11465 printf ("r3/r4\n");
11468 printf (_("Memory\n"));
11471 printf ("??? (%d)\n", val
);
11478 type
= 1; /* String. */
11480 type
= 2; /* uleb128. */
11481 printf (" Tag_unknown_%d: ", tag
);
11485 printf ("\"%s\"\n", p
);
11486 p
+= strlen ((char *) p
) + 1;
11490 val
= read_uleb128 (p
, &len
);
11492 printf ("%d (0x%x)\n", val
, val
);
11499 display_sparc_hwcaps (int mask
)
11504 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11505 fputs ("mul32", stdout
), first
= 0;
11506 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11507 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11508 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11509 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11510 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11511 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11512 if (mask
& ELF_SPARC_HWCAP_POPC
)
11513 printf ("%spopc", first
? "" : "|"), first
= 0;
11514 if (mask
& ELF_SPARC_HWCAP_VIS
)
11515 printf ("%svis", first
? "" : "|"), first
= 0;
11516 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11517 printf ("%svis2", first
? "" : "|"), first
= 0;
11518 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11519 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11520 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11521 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11522 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11523 printf ("%svis3", first
? "" : "|"), first
= 0;
11524 if (mask
& ELF_SPARC_HWCAP_HPC
)
11525 printf ("%shpc", first
? "" : "|"), first
= 0;
11526 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11527 printf ("%srandom", first
? "" : "|"), first
= 0;
11528 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11529 printf ("%strans", first
? "" : "|"), first
= 0;
11530 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11531 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11532 if (mask
& ELF_SPARC_HWCAP_IMA
)
11533 printf ("%sima", first
? "" : "|"), first
= 0;
11534 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11535 printf ("%scspare", first
? "" : "|"), first
= 0;
11538 fputc('0', stdout
);
11539 fputc('\n', stdout
);
11542 static unsigned char *
11543 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11549 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11551 val
= read_uleb128 (p
, &len
);
11553 printf (" Tag_GNU_Sparc_HWCAPS: ");
11555 display_sparc_hwcaps (val
);
11560 type
= 1; /* String. */
11562 type
= 2; /* uleb128. */
11563 printf (" Tag_unknown_%d: ", tag
);
11567 printf ("\"%s\"\n", p
);
11568 p
+= strlen ((char *) p
) + 1;
11572 val
= read_uleb128 (p
, &len
);
11574 printf ("%d (0x%x)\n", val
, val
);
11580 static unsigned char *
11581 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11587 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11589 val
= read_uleb128 (p
, &len
);
11591 printf (" Tag_GNU_MIPS_ABI_FP: ");
11596 printf (_("Hard or soft float\n"));
11599 printf (_("Hard float (double precision)\n"));
11602 printf (_("Hard float (single precision)\n"));
11605 printf (_("Soft float\n"));
11608 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11611 printf ("??? (%d)\n", val
);
11618 type
= 1; /* String. */
11620 type
= 2; /* uleb128. */
11621 printf (" Tag_unknown_%d: ", tag
);
11625 printf ("\"%s\"\n", p
);
11626 p
+= strlen ((char *) p
) + 1;
11630 val
= read_uleb128 (p
, &len
);
11632 printf ("%d (0x%x)\n", val
, val
);
11638 static unsigned char *
11639 display_tic6x_attribute (unsigned char * p
)
11645 tag
= read_uleb128 (p
, &len
);
11651 val
= read_uleb128 (p
, &len
);
11653 printf (" Tag_ISA: ");
11657 case C6XABI_Tag_ISA_none
:
11658 printf (_("None\n"));
11660 case C6XABI_Tag_ISA_C62X
:
11663 case C6XABI_Tag_ISA_C67X
:
11666 case C6XABI_Tag_ISA_C67XP
:
11667 printf ("C67x+\n");
11669 case C6XABI_Tag_ISA_C64X
:
11672 case C6XABI_Tag_ISA_C64XP
:
11673 printf ("C64x+\n");
11675 case C6XABI_Tag_ISA_C674X
:
11676 printf ("C674x\n");
11679 printf ("??? (%d)\n", val
);
11684 case Tag_ABI_wchar_t
:
11685 val
= read_uleb128 (p
, &len
);
11687 printf (" Tag_ABI_wchar_t: ");
11691 printf (_("Not used\n"));
11694 printf (_("2 bytes\n"));
11697 printf (_("4 bytes\n"));
11700 printf ("??? (%d)\n", val
);
11705 case Tag_ABI_stack_align_needed
:
11706 val
= read_uleb128 (p
, &len
);
11708 printf (" Tag_ABI_stack_align_needed: ");
11712 printf (_("8-byte\n"));
11715 printf (_("16-byte\n"));
11718 printf ("??? (%d)\n", val
);
11723 case Tag_ABI_stack_align_preserved
:
11724 val
= read_uleb128 (p
, &len
);
11726 printf (" Tag_ABI_stack_align_preserved: ");
11730 printf (_("8-byte\n"));
11733 printf (_("16-byte\n"));
11736 printf ("??? (%d)\n", val
);
11742 val
= read_uleb128 (p
, &len
);
11744 printf (" Tag_ABI_DSBT: ");
11748 printf (_("DSBT addressing not used\n"));
11751 printf (_("DSBT addressing used\n"));
11754 printf ("??? (%d)\n", val
);
11760 val
= read_uleb128 (p
, &len
);
11762 printf (" Tag_ABI_PID: ");
11766 printf (_("Data addressing position-dependent\n"));
11769 printf (_("Data addressing position-independent, GOT near DP\n"));
11772 printf (_("Data addressing position-independent, GOT far from DP\n"));
11775 printf ("??? (%d)\n", val
);
11781 val
= read_uleb128 (p
, &len
);
11783 printf (" Tag_ABI_PIC: ");
11787 printf (_("Code addressing position-dependent\n"));
11790 printf (_("Code addressing position-independent\n"));
11793 printf ("??? (%d)\n", val
);
11798 case Tag_ABI_array_object_alignment
:
11799 val
= read_uleb128 (p
, &len
);
11801 printf (" Tag_ABI_array_object_alignment: ");
11805 printf (_("8-byte\n"));
11808 printf (_("4-byte\n"));
11811 printf (_("16-byte\n"));
11814 printf ("??? (%d)\n", val
);
11819 case Tag_ABI_array_object_align_expected
:
11820 val
= read_uleb128 (p
, &len
);
11822 printf (" Tag_ABI_array_object_align_expected: ");
11826 printf (_("8-byte\n"));
11829 printf (_("4-byte\n"));
11832 printf (_("16-byte\n"));
11835 printf ("??? (%d)\n", val
);
11840 case Tag_ABI_compatibility
:
11841 val
= read_uleb128 (p
, &len
);
11843 printf (" Tag_ABI_compatibility: ");
11844 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11845 p
+= strlen ((char *) p
) + 1;
11848 case Tag_ABI_conformance
:
11849 printf (" Tag_ABI_conformance: ");
11850 printf ("\"%s\"\n", p
);
11851 p
+= strlen ((char *) p
) + 1;
11855 printf (" Tag_unknown_%d: ", tag
);
11859 printf ("\"%s\"\n", p
);
11860 p
+= strlen ((char *) p
) + 1;
11864 val
= read_uleb128 (p
, &len
);
11866 printf ("%d (0x%x)\n", val
, val
);
11873 process_attributes (FILE * file
,
11874 const char * public_name
,
11875 unsigned int proc_type
,
11876 unsigned char * (* display_pub_attribute
) (unsigned char *),
11877 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11879 Elf_Internal_Shdr
* sect
;
11880 unsigned char * contents
;
11882 unsigned char * end
;
11883 bfd_vma section_len
;
11887 /* Find the section header so that we get the size. */
11888 for (i
= 0, sect
= section_headers
;
11889 i
< elf_header
.e_shnum
;
11892 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11895 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11896 sect
->sh_size
, _("attributes"));
11897 if (contents
== NULL
)
11903 len
= sect
->sh_size
- 1;
11909 bfd_boolean public_section
;
11910 bfd_boolean gnu_section
;
11912 section_len
= byte_get (p
, 4);
11915 if (section_len
> len
)
11917 printf (_("ERROR: Bad section length (%d > %d)\n"),
11918 (int) section_len
, (int) len
);
11922 len
-= section_len
;
11923 printf (_("Attribute Section: %s\n"), p
);
11925 if (public_name
&& streq ((char *) p
, public_name
))
11926 public_section
= TRUE
;
11928 public_section
= FALSE
;
11930 if (streq ((char *) p
, "gnu"))
11931 gnu_section
= TRUE
;
11933 gnu_section
= FALSE
;
11935 namelen
= strlen ((char *) p
) + 1;
11937 section_len
-= namelen
+ 4;
11939 while (section_len
> 0)
11945 size
= byte_get (p
, 4);
11946 if (size
> section_len
)
11948 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11949 (int) size
, (int) section_len
);
11950 size
= section_len
;
11953 section_len
-= size
;
11954 end
= p
+ size
- 1;
11960 printf (_("File Attributes\n"));
11963 printf (_("Section Attributes:"));
11966 printf (_("Symbol Attributes:"));
11972 val
= read_uleb128 (p
, &j
);
11976 printf (" %d", val
);
11981 printf (_("Unknown tag: %d\n"), tag
);
11982 public_section
= FALSE
;
11986 if (public_section
)
11989 p
= display_pub_attribute (p
);
11991 else if (gnu_section
)
11994 p
= display_gnu_attribute (p
,
11995 display_proc_gnu_attribute
);
11999 /* ??? Do something sensible, like dump hex. */
12000 printf (_(" Unknown section contexts\n"));
12007 printf (_("Unknown format '%c'\n"), *p
);
12015 process_arm_specific (FILE * file
)
12017 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12018 display_arm_attribute
, NULL
);
12022 process_power_specific (FILE * file
)
12024 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12025 display_power_gnu_attribute
);
12029 process_sparc_specific (FILE * file
)
12031 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12032 display_sparc_gnu_attribute
);
12036 process_tic6x_specific (FILE * file
)
12038 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12039 display_tic6x_attribute
, NULL
);
12042 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12043 Print the Address, Access and Initial fields of an entry at VMA ADDR
12044 and return the VMA of the next entry. */
12047 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12050 print_vma (addr
, LONG_HEX
);
12052 if (addr
< pltgot
+ 0xfff0)
12053 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12055 printf ("%10s", "");
12058 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12063 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12064 print_vma (entry
, LONG_HEX
);
12066 return addr
+ (is_32bit_elf
? 4 : 8);
12069 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12070 PLTGOT. Print the Address and Initial fields of an entry at VMA
12071 ADDR and return the VMA of the next entry. */
12074 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12077 print_vma (addr
, LONG_HEX
);
12080 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12085 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12086 print_vma (entry
, LONG_HEX
);
12088 return addr
+ (is_32bit_elf
? 4 : 8);
12092 process_mips_specific (FILE * file
)
12094 Elf_Internal_Dyn
* entry
;
12095 size_t liblist_offset
= 0;
12096 size_t liblistno
= 0;
12097 size_t conflictsno
= 0;
12098 size_t options_offset
= 0;
12099 size_t conflicts_offset
= 0;
12100 size_t pltrelsz
= 0;
12102 bfd_vma pltgot
= 0;
12103 bfd_vma mips_pltgot
= 0;
12104 bfd_vma jmprel
= 0;
12105 bfd_vma local_gotno
= 0;
12106 bfd_vma gotsym
= 0;
12107 bfd_vma symtabno
= 0;
12109 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12110 display_mips_gnu_attribute
);
12112 /* We have a lot of special sections. Thanks SGI! */
12113 if (dynamic_section
== NULL
)
12114 /* No information available. */
12117 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12118 switch (entry
->d_tag
)
12120 case DT_MIPS_LIBLIST
:
12122 = offset_from_vma (file
, entry
->d_un
.d_val
,
12123 liblistno
* sizeof (Elf32_External_Lib
));
12125 case DT_MIPS_LIBLISTNO
:
12126 liblistno
= entry
->d_un
.d_val
;
12128 case DT_MIPS_OPTIONS
:
12129 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12131 case DT_MIPS_CONFLICT
:
12133 = offset_from_vma (file
, entry
->d_un
.d_val
,
12134 conflictsno
* sizeof (Elf32_External_Conflict
));
12136 case DT_MIPS_CONFLICTNO
:
12137 conflictsno
= entry
->d_un
.d_val
;
12140 pltgot
= entry
->d_un
.d_ptr
;
12142 case DT_MIPS_LOCAL_GOTNO
:
12143 local_gotno
= entry
->d_un
.d_val
;
12145 case DT_MIPS_GOTSYM
:
12146 gotsym
= entry
->d_un
.d_val
;
12148 case DT_MIPS_SYMTABNO
:
12149 symtabno
= entry
->d_un
.d_val
;
12151 case DT_MIPS_PLTGOT
:
12152 mips_pltgot
= entry
->d_un
.d_ptr
;
12155 pltrel
= entry
->d_un
.d_val
;
12158 pltrelsz
= entry
->d_un
.d_val
;
12161 jmprel
= entry
->d_un
.d_ptr
;
12167 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12169 Elf32_External_Lib
* elib
;
12172 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12174 sizeof (Elf32_External_Lib
),
12175 _("liblist section data"));
12178 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12179 (unsigned long) liblistno
);
12180 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12183 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12190 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12191 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12192 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12193 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12194 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12196 tmp
= gmtime (&atime
);
12197 snprintf (timebuf
, sizeof (timebuf
),
12198 "%04u-%02u-%02uT%02u:%02u:%02u",
12199 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12200 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12202 printf ("%3lu: ", (unsigned long) cnt
);
12203 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12204 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12206 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12207 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12208 liblist
.l_version
);
12210 if (liblist
.l_flags
== 0)
12214 static const struct
12221 { " EXACT_MATCH", LL_EXACT_MATCH
},
12222 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12223 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12224 { " EXPORTS", LL_EXPORTS
},
12225 { " DELAY_LOAD", LL_DELAY_LOAD
},
12226 { " DELTA", LL_DELTA
}
12228 int flags
= liblist
.l_flags
;
12231 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12232 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12234 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12235 flags
^= l_flags_vals
[fcnt
].bit
;
12238 printf (" %#x", (unsigned int) flags
);
12248 if (options_offset
!= 0)
12250 Elf_External_Options
* eopt
;
12251 Elf_Internal_Shdr
* sect
= section_headers
;
12252 Elf_Internal_Options
* iopt
;
12253 Elf_Internal_Options
* option
;
12257 /* Find the section header so that we get the size. */
12258 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12261 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12262 sect
->sh_size
, _("options"));
12265 iopt
= (Elf_Internal_Options
*)
12266 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12269 error (_("Out of memory\n"));
12276 while (offset
< sect
->sh_size
)
12278 Elf_External_Options
* eoption
;
12280 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12282 option
->kind
= BYTE_GET (eoption
->kind
);
12283 option
->size
= BYTE_GET (eoption
->size
);
12284 option
->section
= BYTE_GET (eoption
->section
);
12285 option
->info
= BYTE_GET (eoption
->info
);
12287 offset
+= option
->size
;
12293 printf (_("\nSection '%s' contains %d entries:\n"),
12294 SECTION_NAME (sect
), cnt
);
12302 switch (option
->kind
)
12305 /* This shouldn't happen. */
12306 printf (" NULL %d %lx", option
->section
, option
->info
);
12309 printf (" REGINFO ");
12310 if (elf_header
.e_machine
== EM_MIPS
)
12313 Elf32_External_RegInfo
* ereg
;
12314 Elf32_RegInfo reginfo
;
12316 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12317 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12318 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12319 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12320 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12321 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12322 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12324 printf ("GPR %08lx GP 0x%lx\n",
12325 reginfo
.ri_gprmask
,
12326 (unsigned long) reginfo
.ri_gp_value
);
12327 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12328 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12329 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12334 Elf64_External_RegInfo
* ereg
;
12335 Elf64_Internal_RegInfo reginfo
;
12337 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12338 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12339 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12340 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12341 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12342 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12343 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12345 printf ("GPR %08lx GP 0x",
12346 reginfo
.ri_gprmask
);
12347 printf_vma (reginfo
.ri_gp_value
);
12350 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12351 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12352 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12356 case ODK_EXCEPTIONS
:
12357 fputs (" EXCEPTIONS fpe_min(", stdout
);
12358 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12359 fputs (") fpe_max(", stdout
);
12360 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12361 fputs (")", stdout
);
12363 if (option
->info
& OEX_PAGE0
)
12364 fputs (" PAGE0", stdout
);
12365 if (option
->info
& OEX_SMM
)
12366 fputs (" SMM", stdout
);
12367 if (option
->info
& OEX_FPDBUG
)
12368 fputs (" FPDBUG", stdout
);
12369 if (option
->info
& OEX_DISMISS
)
12370 fputs (" DISMISS", stdout
);
12373 fputs (" PAD ", stdout
);
12374 if (option
->info
& OPAD_PREFIX
)
12375 fputs (" PREFIX", stdout
);
12376 if (option
->info
& OPAD_POSTFIX
)
12377 fputs (" POSTFIX", stdout
);
12378 if (option
->info
& OPAD_SYMBOL
)
12379 fputs (" SYMBOL", stdout
);
12382 fputs (" HWPATCH ", stdout
);
12383 if (option
->info
& OHW_R4KEOP
)
12384 fputs (" R4KEOP", stdout
);
12385 if (option
->info
& OHW_R8KPFETCH
)
12386 fputs (" R8KPFETCH", stdout
);
12387 if (option
->info
& OHW_R5KEOP
)
12388 fputs (" R5KEOP", stdout
);
12389 if (option
->info
& OHW_R5KCVTL
)
12390 fputs (" R5KCVTL", stdout
);
12393 fputs (" FILL ", stdout
);
12394 /* XXX Print content of info word? */
12397 fputs (" TAGS ", stdout
);
12398 /* XXX Print content of info word? */
12401 fputs (" HWAND ", stdout
);
12402 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12403 fputs (" R4KEOP_CHECKED", stdout
);
12404 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12405 fputs (" R4KEOP_CLEAN", stdout
);
12408 fputs (" HWOR ", stdout
);
12409 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12410 fputs (" R4KEOP_CHECKED", stdout
);
12411 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12412 fputs (" R4KEOP_CLEAN", stdout
);
12415 printf (" GP_GROUP %#06lx self-contained %#06lx",
12416 option
->info
& OGP_GROUP
,
12417 (option
->info
& OGP_SELF
) >> 16);
12420 printf (" IDENT %#06lx self-contained %#06lx",
12421 option
->info
& OGP_GROUP
,
12422 (option
->info
& OGP_SELF
) >> 16);
12425 /* This shouldn't happen. */
12426 printf (" %3d ??? %d %lx",
12427 option
->kind
, option
->section
, option
->info
);
12431 len
= sizeof (* eopt
);
12432 while (len
< option
->size
)
12433 if (((char *) option
)[len
] >= ' '
12434 && ((char *) option
)[len
] < 0x7f)
12435 printf ("%c", ((char *) option
)[len
++]);
12437 printf ("\\%03o", ((char *) option
)[len
++]);
12439 fputs ("\n", stdout
);
12447 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12449 Elf32_Conflict
* iconf
;
12452 if (dynamic_symbols
== NULL
)
12454 error (_("conflict list found without a dynamic symbol table\n"));
12458 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12461 error (_("Out of memory\n"));
12467 Elf32_External_Conflict
* econf32
;
12469 econf32
= (Elf32_External_Conflict
*)
12470 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12471 sizeof (* econf32
), _("conflict"));
12475 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12476 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12482 Elf64_External_Conflict
* econf64
;
12484 econf64
= (Elf64_External_Conflict
*)
12485 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12486 sizeof (* econf64
), _("conflict"));
12490 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12491 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12496 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12497 (unsigned long) conflictsno
);
12498 puts (_(" Num: Index Value Name"));
12500 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12502 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12504 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12505 print_vma (psym
->st_value
, FULL_HEX
);
12507 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12508 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12510 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12517 if (pltgot
!= 0 && local_gotno
!= 0)
12519 bfd_vma ent
, local_end
, global_end
;
12521 unsigned char * data
;
12525 addr_size
= (is_32bit_elf
? 4 : 8);
12526 local_end
= pltgot
+ local_gotno
* addr_size
;
12527 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12529 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12530 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12531 global_end
- pltgot
, 1,
12532 _("Global Offset Table data"));
12536 printf (_("\nPrimary GOT:\n"));
12537 printf (_(" Canonical gp value: "));
12538 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12541 printf (_(" Reserved entries:\n"));
12542 printf (_(" %*s %10s %*s Purpose\n"),
12543 addr_size
* 2, _("Address"), _("Access"),
12544 addr_size
* 2, _("Initial"));
12545 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12546 printf (_(" Lazy resolver\n"));
12548 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12549 >> (addr_size
* 8 - 1)) != 0)
12551 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12552 printf (_(" Module pointer (GNU extension)\n"));
12556 if (ent
< local_end
)
12558 printf (_(" Local entries:\n"));
12559 printf (" %*s %10s %*s\n",
12560 addr_size
* 2, _("Address"), _("Access"),
12561 addr_size
* 2, _("Initial"));
12562 while (ent
< local_end
)
12564 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12570 if (gotsym
< symtabno
)
12574 printf (_(" Global entries:\n"));
12575 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12576 addr_size
* 2, _("Address"),
12578 addr_size
* 2, _("Initial"),
12579 addr_size
* 2, _("Sym.Val."),
12581 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12582 _("Ndx"), _("Name"));
12584 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12585 for (i
= gotsym
; i
< symtabno
; i
++)
12587 Elf_Internal_Sym
* psym
;
12589 psym
= dynamic_symbols
+ i
;
12590 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12592 print_vma (psym
->st_value
, LONG_HEX
);
12593 printf (" %-7s %3s ",
12594 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12595 get_symbol_index_type (psym
->st_shndx
));
12596 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12597 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12599 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12609 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12612 size_t offset
, rel_offset
;
12613 unsigned long count
, i
;
12614 unsigned char * data
;
12615 int addr_size
, sym_width
;
12616 Elf_Internal_Rela
* rels
;
12618 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12619 if (pltrel
== DT_RELA
)
12621 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12626 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12631 addr_size
= (is_32bit_elf
? 4 : 8);
12632 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12634 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12635 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12636 1, _("Procedure Linkage Table data"));
12640 printf ("\nPLT GOT:\n\n");
12641 printf (_(" Reserved entries:\n"));
12642 printf (_(" %*s %*s Purpose\n"),
12643 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12644 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12645 printf (_(" PLT lazy resolver\n"));
12646 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12647 printf (_(" Module pointer\n"));
12650 printf (_(" Entries:\n"));
12651 printf (" %*s %*s %*s %-7s %3s %s\n",
12652 addr_size
* 2, _("Address"),
12653 addr_size
* 2, _("Initial"),
12654 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12655 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12656 for (i
= 0; i
< count
; i
++)
12658 Elf_Internal_Sym
* psym
;
12660 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12661 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12663 print_vma (psym
->st_value
, LONG_HEX
);
12664 printf (" %-7s %3s ",
12665 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12666 get_symbol_index_type (psym
->st_shndx
));
12667 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12668 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12670 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12684 process_gnu_liblist (FILE * file
)
12686 Elf_Internal_Shdr
* section
;
12687 Elf_Internal_Shdr
* string_sec
;
12688 Elf32_External_Lib
* elib
;
12690 size_t strtab_size
;
12697 for (i
= 0, section
= section_headers
;
12698 i
< elf_header
.e_shnum
;
12701 switch (section
->sh_type
)
12703 case SHT_GNU_LIBLIST
:
12704 if (section
->sh_link
>= elf_header
.e_shnum
)
12707 elib
= (Elf32_External_Lib
*)
12708 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12709 _("liblist section data"));
12713 string_sec
= section_headers
+ section
->sh_link
;
12715 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12716 string_sec
->sh_size
,
12717 _("liblist string table"));
12719 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12725 strtab_size
= string_sec
->sh_size
;
12727 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12728 SECTION_NAME (section
),
12729 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12731 puts (_(" Library Time Stamp Checksum Version Flags"));
12733 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12741 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12742 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12743 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12744 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12745 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12747 tmp
= gmtime (&atime
);
12748 snprintf (timebuf
, sizeof (timebuf
),
12749 "%04u-%02u-%02uT%02u:%02u:%02u",
12750 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12751 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12753 printf ("%3lu: ", (unsigned long) cnt
);
12755 printf ("%-20s", liblist
.l_name
< strtab_size
12756 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12758 printf ("%-20.20s", liblist
.l_name
< strtab_size
12759 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12760 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12761 liblist
.l_version
, liblist
.l_flags
);
12772 static const char *
12773 get_note_type (unsigned e_type
)
12775 static char buff
[64];
12777 if (elf_header
.e_type
== ET_CORE
)
12781 return _("NT_AUXV (auxiliary vector)");
12783 return _("NT_PRSTATUS (prstatus structure)");
12785 return _("NT_FPREGSET (floating point registers)");
12787 return _("NT_PRPSINFO (prpsinfo structure)");
12788 case NT_TASKSTRUCT
:
12789 return _("NT_TASKSTRUCT (task structure)");
12791 return _("NT_PRXFPREG (user_xfpregs structure)");
12793 return _("NT_PPC_VMX (ppc Altivec registers)");
12795 return _("NT_PPC_VSX (ppc VSX registers)");
12797 return _("NT_386_TLS (x86 TLS information)");
12798 case NT_386_IOPERM
:
12799 return _("NT_386_IOPERM (x86 I/O permissions)");
12800 case NT_X86_XSTATE
:
12801 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12802 case NT_S390_HIGH_GPRS
:
12803 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12804 case NT_S390_TIMER
:
12805 return _("NT_S390_TIMER (s390 timer register)");
12806 case NT_S390_TODCMP
:
12807 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12808 case NT_S390_TODPREG
:
12809 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12811 return _("NT_S390_CTRS (s390 control registers)");
12812 case NT_S390_PREFIX
:
12813 return _("NT_S390_PREFIX (s390 prefix register)");
12815 return _("NT_ARM_VFP (arm VFP registers)");
12817 return _("NT_ARM_TLS (AArch TLS registers)");
12818 case NT_ARM_HW_BREAK
:
12819 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12820 case NT_ARM_HW_WATCH
:
12821 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12823 return _("NT_PSTATUS (pstatus structure)");
12825 return _("NT_FPREGS (floating point registers)");
12827 return _("NT_PSINFO (psinfo structure)");
12829 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12831 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12832 case NT_WIN32PSTATUS
:
12833 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12835 return _("NT_SIGINFO (siginfo_t data)");
12837 return _("NT_FILE (mapped files)");
12845 return _("NT_VERSION (version)");
12847 return _("NT_ARCH (architecture)");
12852 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12857 print_core_note (Elf_Internal_Note
*pnote
)
12859 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12860 bfd_vma count
, page_size
;
12861 unsigned char *descdata
, *filenames
, *descend
;
12863 if (pnote
->type
!= NT_FILE
)
12869 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12870 /* Still "successful". */
12875 if (pnote
->descsz
< 2 * addr_size
)
12877 printf (_(" Malformed note - too short for header\n"));
12881 descdata
= (unsigned char *) pnote
->descdata
;
12882 descend
= descdata
+ pnote
->descsz
;
12884 if (descdata
[pnote
->descsz
- 1] != '\0')
12886 printf (_(" Malformed note - does not end with \\0\n"));
12890 count
= byte_get (descdata
, addr_size
);
12891 descdata
+= addr_size
;
12893 page_size
= byte_get (descdata
, addr_size
);
12894 descdata
+= addr_size
;
12896 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12898 printf (_(" Malformed note - too short for supplied file count\n"));
12902 printf (_(" Page size: "));
12903 print_vma (page_size
, DEC
);
12906 printf (_(" %*s%*s%*s\n"),
12907 (int) (2 + 2 * addr_size
), _("Start"),
12908 (int) (4 + 2 * addr_size
), _("End"),
12909 (int) (4 + 2 * addr_size
), _("Page Offset"));
12910 filenames
= descdata
+ count
* 3 * addr_size
;
12911 while (--count
> 0)
12913 bfd_vma start
, end
, file_ofs
;
12915 if (filenames
== descend
)
12917 printf (_(" Malformed note - filenames end too early\n"));
12921 start
= byte_get (descdata
, addr_size
);
12922 descdata
+= addr_size
;
12923 end
= byte_get (descdata
, addr_size
);
12924 descdata
+= addr_size
;
12925 file_ofs
= byte_get (descdata
, addr_size
);
12926 descdata
+= addr_size
;
12929 print_vma (start
, FULL_HEX
);
12931 print_vma (end
, FULL_HEX
);
12933 print_vma (file_ofs
, FULL_HEX
);
12934 printf ("\n %s\n", filenames
);
12936 filenames
+= 1 + strlen ((char *) filenames
);
12942 static const char *
12943 get_gnu_elf_note_type (unsigned e_type
)
12945 static char buff
[64];
12949 case NT_GNU_ABI_TAG
:
12950 return _("NT_GNU_ABI_TAG (ABI version tag)");
12952 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12953 case NT_GNU_BUILD_ID
:
12954 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12955 case NT_GNU_GOLD_VERSION
:
12956 return _("NT_GNU_GOLD_VERSION (gold version)");
12961 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12966 print_gnu_note (Elf_Internal_Note
*pnote
)
12968 switch (pnote
->type
)
12970 case NT_GNU_BUILD_ID
:
12974 printf (_(" Build ID: "));
12975 for (i
= 0; i
< pnote
->descsz
; ++i
)
12976 printf ("%02x", pnote
->descdata
[i
] & 0xff);
12981 case NT_GNU_ABI_TAG
:
12983 unsigned long os
, major
, minor
, subminor
;
12984 const char *osname
;
12986 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
12987 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
12988 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
12989 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
12993 case GNU_ABI_TAG_LINUX
:
12996 case GNU_ABI_TAG_HURD
:
12999 case GNU_ABI_TAG_SOLARIS
:
13000 osname
= "Solaris";
13002 case GNU_ABI_TAG_FREEBSD
:
13003 osname
= "FreeBSD";
13005 case GNU_ABI_TAG_NETBSD
:
13009 osname
= "Unknown";
13013 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13014 major
, minor
, subminor
);
13022 static const char *
13023 get_netbsd_elfcore_note_type (unsigned e_type
)
13025 static char buff
[64];
13027 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13029 /* NetBSD core "procinfo" structure. */
13030 return _("NetBSD procinfo structure");
13033 /* As of Jan 2002 there are no other machine-independent notes
13034 defined for NetBSD core files. If the note type is less
13035 than the start of the machine-dependent note types, we don't
13038 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13040 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13044 switch (elf_header
.e_machine
)
13046 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13047 and PT_GETFPREGS == mach+2. */
13052 case EM_SPARC32PLUS
:
13056 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13057 return _("PT_GETREGS (reg structure)");
13058 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13059 return _("PT_GETFPREGS (fpreg structure)");
13065 /* On all other arch's, PT_GETREGS == mach+1 and
13066 PT_GETFPREGS == mach+3. */
13070 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13071 return _("PT_GETREGS (reg structure)");
13072 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13073 return _("PT_GETFPREGS (fpreg structure)");
13079 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13080 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13084 static const char *
13085 get_stapsdt_note_type (unsigned e_type
)
13087 static char buff
[64];
13092 return _("NT_STAPSDT (SystemTap probe descriptors)");
13098 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13103 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13105 int addr_size
= is_32bit_elf
? 4 : 8;
13106 char *data
= pnote
->descdata
;
13107 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13108 bfd_vma pc
, base_addr
, semaphore
;
13109 char *provider
, *probe
, *arg_fmt
;
13111 pc
= byte_get ((unsigned char *) data
, addr_size
);
13113 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13115 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13119 data
+= strlen (data
) + 1;
13121 data
+= strlen (data
) + 1;
13123 data
+= strlen (data
) + 1;
13125 printf (_(" Provider: %s\n"), provider
);
13126 printf (_(" Name: %s\n"), probe
);
13127 printf (_(" Location: "));
13128 print_vma (pc
, FULL_HEX
);
13129 printf (_(", Base: "));
13130 print_vma (base_addr
, FULL_HEX
);
13131 printf (_(", Semaphore: "));
13132 print_vma (semaphore
, FULL_HEX
);
13134 printf (_(" Arguments: %s\n"), arg_fmt
);
13136 return data
== data_end
;
13139 static const char *
13140 get_ia64_vms_note_type (unsigned e_type
)
13142 static char buff
[64];
13147 return _("NT_VMS_MHD (module header)");
13149 return _("NT_VMS_LNM (language name)");
13151 return _("NT_VMS_SRC (source files)");
13153 return "NT_VMS_TITLE";
13155 return _("NT_VMS_EIDC (consistency check)");
13156 case NT_VMS_FPMODE
:
13157 return _("NT_VMS_FPMODE (FP mode)");
13158 case NT_VMS_LINKTIME
:
13159 return "NT_VMS_LINKTIME";
13160 case NT_VMS_IMGNAM
:
13161 return _("NT_VMS_IMGNAM (image name)");
13163 return _("NT_VMS_IMGID (image id)");
13164 case NT_VMS_LINKID
:
13165 return _("NT_VMS_LINKID (link id)");
13166 case NT_VMS_IMGBID
:
13167 return _("NT_VMS_IMGBID (build id)");
13168 case NT_VMS_GSTNAM
:
13169 return _("NT_VMS_GSTNAM (sym table name)");
13170 case NT_VMS_ORIG_DYN
:
13171 return "NT_VMS_ORIG_DYN";
13172 case NT_VMS_PATCHTIME
:
13173 return "NT_VMS_PATCHTIME";
13175 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13181 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13183 switch (pnote
->type
)
13186 if (pnote
->descsz
> 36)
13188 size_t l
= strlen (pnote
->descdata
+ 34);
13189 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13190 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13191 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13192 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13195 printf (_(" Invalid size\n"));
13198 printf (_(" Language: %s\n"), pnote
->descdata
);
13201 case NT_VMS_FPMODE
:
13202 printf (_(" Floating Point mode: "));
13203 printf ("0x%016" BFD_VMA_FMT
"x\n",
13204 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13206 case NT_VMS_LINKTIME
:
13207 printf (_(" Link time: "));
13209 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13212 case NT_VMS_PATCHTIME
:
13213 printf (_(" Patch time: "));
13215 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13218 case NT_VMS_ORIG_DYN
:
13219 printf (_(" Major id: %u, minor id: %u\n"),
13220 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13221 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13222 printf (_(" Last modified : "));
13224 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13225 printf (_("\n Link flags : "));
13226 printf ("0x%016" BFD_VMA_FMT
"x\n",
13227 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13228 printf (_(" Header flags: 0x%08x\n"),
13229 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13230 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13233 case NT_VMS_IMGNAM
:
13234 printf (_(" Image name: %s\n"), pnote
->descdata
);
13236 case NT_VMS_GSTNAM
:
13237 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13240 printf (_(" Image id: %s\n"), pnote
->descdata
);
13242 case NT_VMS_LINKID
:
13243 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13251 /* Note that by the ELF standard, the name field is already null byte
13252 terminated, and namesz includes the terminating null byte.
13253 I.E. the value of namesz for the name "FSF" is 4.
13255 If the value of namesz is zero, there is no name present. */
13257 process_note (Elf_Internal_Note
* pnote
)
13259 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13262 if (pnote
->namesz
== 0)
13263 /* If there is no note name, then use the default set of
13264 note type strings. */
13265 nt
= get_note_type (pnote
->type
);
13267 else if (const_strneq (pnote
->namedata
, "GNU"))
13268 /* GNU-specific object file notes. */
13269 nt
= get_gnu_elf_note_type (pnote
->type
);
13271 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13272 /* NetBSD-specific core file notes. */
13273 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13275 else if (strneq (pnote
->namedata
, "SPU/", 4))
13277 /* SPU-specific core file notes. */
13278 nt
= pnote
->namedata
+ 4;
13282 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13283 /* VMS/ia64-specific file notes. */
13284 nt
= get_ia64_vms_note_type (pnote
->type
);
13286 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13287 nt
= get_stapsdt_note_type (pnote
->type
);
13290 /* Don't recognize this note name; just use the default set of
13291 note type strings. */
13292 nt
= get_note_type (pnote
->type
);
13294 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13296 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13297 return print_ia64_vms_note (pnote
);
13298 else if (const_strneq (pnote
->namedata
, "GNU"))
13299 return print_gnu_note (pnote
);
13300 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13301 return print_stapsdt_note (pnote
);
13302 else if (const_strneq (pnote
->namedata
, "CORE"))
13303 return print_core_note (pnote
);
13310 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13312 Elf_External_Note
* pnotes
;
13313 Elf_External_Note
* external
;
13319 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13321 if (pnotes
== NULL
)
13326 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13327 (unsigned long) offset
, (unsigned long) length
);
13328 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13330 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13332 Elf_External_Note
* next
;
13333 Elf_Internal_Note inote
;
13334 char * temp
= NULL
;
13336 if (!is_ia64_vms ())
13338 inote
.type
= BYTE_GET (external
->type
);
13339 inote
.namesz
= BYTE_GET (external
->namesz
);
13340 inote
.namedata
= external
->name
;
13341 inote
.descsz
= BYTE_GET (external
->descsz
);
13342 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13343 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13345 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13349 Elf64_External_VMS_Note
*vms_external
;
13351 vms_external
= (Elf64_External_VMS_Note
*)external
;
13352 inote
.type
= BYTE_GET (vms_external
->type
);
13353 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13354 inote
.namedata
= vms_external
->name
;
13355 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13356 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13357 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13359 next
= (Elf_External_Note
*)
13360 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13363 if ( ((char *) next
> ((char *) pnotes
) + length
)
13364 || ((char *) next
< (char *) pnotes
))
13366 warn (_("corrupt note found at offset %lx into core notes\n"),
13367 (unsigned long) ((char *) external
- (char *) pnotes
));
13368 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13369 inote
.type
, inote
.namesz
, inote
.descsz
);
13375 /* Prevent out-of-bounds indexing. */
13376 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13377 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13379 warn (_("corrupt note found at offset %lx into core notes\n"),
13380 (unsigned long) ((char *) external
- (char *) pnotes
));
13381 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13382 inote
.type
, inote
.namesz
, inote
.descsz
);
13386 /* Verify that name is null terminated. It appears that at least
13387 one version of Linux (RedHat 6.0) generates corefiles that don't
13388 comply with the ELF spec by failing to include the null byte in
13390 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13392 temp
= (char *) malloc (inote
.namesz
+ 1);
13396 error (_("Out of memory\n"));
13401 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13402 temp
[inote
.namesz
] = 0;
13404 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13405 inote
.namedata
= temp
;
13408 res
&= process_note (& inote
);
13423 process_corefile_note_segments (FILE * file
)
13425 Elf_Internal_Phdr
* segment
;
13429 if (! get_program_headers (file
))
13432 for (i
= 0, segment
= program_headers
;
13433 i
< elf_header
.e_phnum
;
13436 if (segment
->p_type
== PT_NOTE
)
13437 res
&= process_corefile_note_segment (file
,
13438 (bfd_vma
) segment
->p_offset
,
13439 (bfd_vma
) segment
->p_filesz
);
13446 process_note_sections (FILE * file
)
13448 Elf_Internal_Shdr
* section
;
13452 for (i
= 0, section
= section_headers
;
13453 i
< elf_header
.e_shnum
&& section
!= NULL
;
13455 if (section
->sh_type
== SHT_NOTE
)
13456 res
&= process_corefile_note_segment (file
,
13457 (bfd_vma
) section
->sh_offset
,
13458 (bfd_vma
) section
->sh_size
);
13464 process_notes (FILE * file
)
13466 /* If we have not been asked to display the notes then do nothing. */
13470 if (elf_header
.e_type
!= ET_CORE
)
13471 return process_note_sections (file
);
13473 /* No program headers means no NOTE segment. */
13474 if (elf_header
.e_phnum
> 0)
13475 return process_corefile_note_segments (file
);
13477 printf (_("No note segments present in the core file.\n"));
13482 process_arch_specific (FILE * file
)
13487 switch (elf_header
.e_machine
)
13490 return process_arm_specific (file
);
13492 case EM_MIPS_RS3_LE
:
13493 return process_mips_specific (file
);
13496 return process_power_specific (file
);
13499 case EM_SPARC32PLUS
:
13501 return process_sparc_specific (file
);
13504 return process_tic6x_specific (file
);
13513 get_file_header (FILE * file
)
13515 /* Read in the identity array. */
13516 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13519 /* Determine how to read the rest of the header. */
13520 switch (elf_header
.e_ident
[EI_DATA
])
13522 default: /* fall through */
13523 case ELFDATANONE
: /* fall through */
13525 byte_get
= byte_get_little_endian
;
13526 byte_put
= byte_put_little_endian
;
13529 byte_get
= byte_get_big_endian
;
13530 byte_put
= byte_put_big_endian
;
13534 /* For now we only support 32 bit and 64 bit ELF files. */
13535 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13537 /* Read in the rest of the header. */
13540 Elf32_External_Ehdr ehdr32
;
13542 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13545 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13546 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13547 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13548 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13549 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13550 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13551 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13552 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13553 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13554 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13555 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13556 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13557 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13561 Elf64_External_Ehdr ehdr64
;
13563 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13564 we will not be able to cope with the 64bit data found in
13565 64 ELF files. Detect this now and abort before we start
13566 overwriting things. */
13567 if (sizeof (bfd_vma
) < 8)
13569 error (_("This instance of readelf has been built without support for a\n\
13570 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13574 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13577 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13578 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13579 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13580 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13581 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13582 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13583 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13584 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13585 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13586 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13587 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13588 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13589 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13592 if (elf_header
.e_shoff
)
13594 /* There may be some extensions in the first section header. Don't
13595 bomb if we can't read it. */
13597 get_32bit_section_headers (file
, 1);
13599 get_64bit_section_headers (file
, 1);
13605 /* Process one ELF object file according to the command line options.
13606 This file may actually be stored in an archive. The file is
13607 positioned at the start of the ELF object. */
13610 process_object (char * file_name
, FILE * file
)
13614 if (! get_file_header (file
))
13616 error (_("%s: Failed to read file header\n"), file_name
);
13620 /* Initialise per file variables. */
13621 for (i
= ARRAY_SIZE (version_info
); i
--;)
13622 version_info
[i
] = 0;
13624 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13625 dynamic_info
[i
] = 0;
13626 dynamic_info_DT_GNU_HASH
= 0;
13628 /* Process the file. */
13630 printf (_("\nFile: %s\n"), file_name
);
13632 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13633 Note we do this even if cmdline_dump_sects is empty because we
13634 must make sure that the dump_sets array is zeroed out before each
13635 object file is processed. */
13636 if (num_dump_sects
> num_cmdline_dump_sects
)
13637 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13639 if (num_cmdline_dump_sects
> 0)
13641 if (num_dump_sects
== 0)
13642 /* A sneaky way of allocating the dump_sects array. */
13643 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13645 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13646 memcpy (dump_sects
, cmdline_dump_sects
,
13647 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13650 if (! process_file_header ())
13653 if (! process_section_headers (file
))
13655 /* Without loaded section headers we cannot process lots of
13657 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13659 if (! do_using_dynamic
)
13660 do_syms
= do_dyn_syms
= do_reloc
= 0;
13663 if (! process_section_groups (file
))
13665 /* Without loaded section groups we cannot process unwind. */
13669 if (process_program_headers (file
))
13670 process_dynamic_section (file
);
13672 process_relocs (file
);
13674 process_unwind (file
);
13676 process_symbol_table (file
);
13678 process_syminfo (file
);
13680 process_version_sections (file
);
13682 process_section_contents (file
);
13684 process_notes (file
);
13686 process_gnu_liblist (file
);
13688 process_arch_specific (file
);
13690 if (program_headers
)
13692 free (program_headers
);
13693 program_headers
= NULL
;
13696 if (section_headers
)
13698 free (section_headers
);
13699 section_headers
= NULL
;
13704 free (string_table
);
13705 string_table
= NULL
;
13706 string_table_length
= 0;
13709 if (dynamic_strings
)
13711 free (dynamic_strings
);
13712 dynamic_strings
= NULL
;
13713 dynamic_strings_length
= 0;
13716 if (dynamic_symbols
)
13718 free (dynamic_symbols
);
13719 dynamic_symbols
= NULL
;
13720 num_dynamic_syms
= 0;
13723 if (dynamic_syminfo
)
13725 free (dynamic_syminfo
);
13726 dynamic_syminfo
= NULL
;
13729 if (dynamic_section
)
13731 free (dynamic_section
);
13732 dynamic_section
= NULL
;
13735 if (section_headers_groups
)
13737 free (section_headers_groups
);
13738 section_headers_groups
= NULL
;
13741 if (section_groups
)
13743 struct group_list
* g
;
13744 struct group_list
* next
;
13746 for (i
= 0; i
< group_count
; i
++)
13748 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13755 free (section_groups
);
13756 section_groups
= NULL
;
13759 free_debug_memory ();
13764 /* Process an ELF archive.
13765 On entry the file is positioned just after the ARMAG string. */
13768 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13770 struct archive_info arch
;
13771 struct archive_info nested_arch
;
13777 /* The ARCH structure is used to hold information about this archive. */
13778 arch
.file_name
= NULL
;
13780 arch
.index_array
= NULL
;
13781 arch
.sym_table
= NULL
;
13782 arch
.longnames
= NULL
;
13784 /* The NESTED_ARCH structure is used as a single-item cache of information
13785 about a nested archive (when members of a thin archive reside within
13786 another regular archive file). */
13787 nested_arch
.file_name
= NULL
;
13788 nested_arch
.file
= NULL
;
13789 nested_arch
.index_array
= NULL
;
13790 nested_arch
.sym_table
= NULL
;
13791 nested_arch
.longnames
= NULL
;
13793 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13799 if (do_archive_index
)
13801 if (arch
.sym_table
== NULL
)
13802 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13806 unsigned long current_pos
;
13808 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13809 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13810 current_pos
= ftell (file
);
13812 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13814 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13816 char * member_name
;
13818 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13820 if (member_name
!= NULL
)
13822 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13824 if (qualified_name
!= NULL
)
13826 printf (_("Contents of binary %s at offset "), qualified_name
);
13827 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13829 free (qualified_name
);
13834 if (l
>= arch
.sym_size
)
13836 error (_("%s: end of the symbol table reached before the end of the index\n"),
13840 printf ("\t%s\n", arch
.sym_table
+ l
);
13841 l
+= strlen (arch
.sym_table
+ l
) + 1;
13844 if (arch
.uses_64bit_indicies
)
13849 if (l
< arch
.sym_size
)
13850 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13851 file_name
, arch
.sym_size
- l
);
13853 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13855 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13861 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13862 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13863 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13864 && !do_section_groups
&& !do_dyn_syms
)
13866 ret
= 0; /* Archive index only. */
13877 char * qualified_name
;
13879 /* Read the next archive header. */
13880 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13882 error (_("%s: failed to seek to next archive header\n"), file_name
);
13885 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13886 if (got
!= sizeof arch
.arhdr
)
13890 error (_("%s: failed to read archive header\n"), file_name
);
13894 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13896 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13901 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13903 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13904 if (archive_file_size
& 01)
13905 ++archive_file_size
;
13907 name
= get_archive_member_name (&arch
, &nested_arch
);
13910 error (_("%s: bad archive file name\n"), file_name
);
13914 namelen
= strlen (name
);
13916 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13917 if (qualified_name
== NULL
)
13919 error (_("%s: bad archive file name\n"), file_name
);
13924 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13926 /* This is a proxy for an external member of a thin archive. */
13927 FILE * member_file
;
13928 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13929 if (member_file_name
== NULL
)
13935 member_file
= fopen (member_file_name
, "rb");
13936 if (member_file
== NULL
)
13938 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13939 free (member_file_name
);
13944 archive_file_offset
= arch
.nested_member_origin
;
13946 ret
|= process_object (qualified_name
, member_file
);
13948 fclose (member_file
);
13949 free (member_file_name
);
13951 else if (is_thin_archive
)
13953 /* This is a proxy for a member of a nested archive. */
13954 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13956 /* The nested archive file will have been opened and setup by
13957 get_archive_member_name. */
13958 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13960 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13965 ret
|= process_object (qualified_name
, nested_arch
.file
);
13969 archive_file_offset
= arch
.next_arhdr_offset
;
13970 arch
.next_arhdr_offset
+= archive_file_size
;
13972 ret
|= process_object (qualified_name
, file
);
13975 if (dump_sects
!= NULL
)
13979 num_dump_sects
= 0;
13982 free (qualified_name
);
13986 if (nested_arch
.file
!= NULL
)
13987 fclose (nested_arch
.file
);
13988 release_archive (&nested_arch
);
13989 release_archive (&arch
);
13995 process_file (char * file_name
)
13998 struct stat statbuf
;
13999 char armag
[SARMAG
];
14002 if (stat (file_name
, &statbuf
) < 0)
14004 if (errno
== ENOENT
)
14005 error (_("'%s': No such file\n"), file_name
);
14007 error (_("Could not locate '%s'. System error message: %s\n"),
14008 file_name
, strerror (errno
));
14012 if (! S_ISREG (statbuf
.st_mode
))
14014 error (_("'%s' is not an ordinary file\n"), file_name
);
14018 file
= fopen (file_name
, "rb");
14021 error (_("Input file '%s' is not readable.\n"), file_name
);
14025 if (fread (armag
, SARMAG
, 1, file
) != 1)
14027 error (_("%s: Failed to read file's magic number\n"), file_name
);
14032 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14033 ret
= process_archive (file_name
, file
, FALSE
);
14034 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14035 ret
= process_archive (file_name
, file
, TRUE
);
14038 if (do_archive_index
)
14039 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14043 archive_file_size
= archive_file_offset
= 0;
14044 ret
= process_object (file_name
, file
);
14052 #ifdef SUPPORT_DISASSEMBLY
14053 /* Needed by the i386 disassembler. For extra credit, someone could
14054 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14058 print_address (unsigned int addr
, FILE * outfile
)
14060 fprintf (outfile
,"0x%8.8x", addr
);
14063 /* Needed by the i386 disassembler. */
14065 db_task_printsym (unsigned int addr
)
14067 print_address (addr
, stderr
);
14072 main (int argc
, char ** argv
)
14076 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14077 setlocale (LC_MESSAGES
, "");
14079 #if defined (HAVE_SETLOCALE)
14080 setlocale (LC_CTYPE
, "");
14082 bindtextdomain (PACKAGE
, LOCALEDIR
);
14083 textdomain (PACKAGE
);
14085 expandargv (&argc
, &argv
);
14087 parse_args (argc
, argv
);
14089 if (num_dump_sects
> 0)
14091 /* Make a copy of the dump_sects array. */
14092 cmdline_dump_sects
= (dump_type
*)
14093 malloc (num_dump_sects
* sizeof (* dump_sects
));
14094 if (cmdline_dump_sects
== NULL
)
14095 error (_("Out of memory allocating dump request table.\n"));
14098 memcpy (cmdline_dump_sects
, dump_sects
,
14099 num_dump_sects
* sizeof (* dump_sects
));
14100 num_cmdline_dump_sects
= num_dump_sects
;
14104 if (optind
< (argc
- 1))
14108 while (optind
< argc
)
14109 err
|= process_file (argv
[optind
++]);
14111 if (dump_sects
!= NULL
)
14113 if (cmdline_dump_sects
!= NULL
)
14114 free (cmdline_dump_sects
);