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_V850E3V5_ARCH
:
2480 strcat (buf
, ", v850e3v5");
2482 case E_V850E2V3_ARCH
:
2483 strcat (buf
, ", v850e2v3");
2486 strcat (buf
, ", v850e2");
2489 strcat (buf
, ", v850e1");
2492 strcat (buf
, ", v850e");
2495 strcat (buf
, ", v850");
2498 strcat (buf
, _(", unknown v850 architecture variant"));
2504 case EM_CYGNUS_M32R
:
2505 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2506 strcat (buf
, ", m32r");
2510 case EM_MIPS_RS3_LE
:
2511 if (e_flags
& EF_MIPS_NOREORDER
)
2512 strcat (buf
, ", noreorder");
2514 if (e_flags
& EF_MIPS_PIC
)
2515 strcat (buf
, ", pic");
2517 if (e_flags
& EF_MIPS_CPIC
)
2518 strcat (buf
, ", cpic");
2520 if (e_flags
& EF_MIPS_UCODE
)
2521 strcat (buf
, ", ugen_reserved");
2523 if (e_flags
& EF_MIPS_ABI2
)
2524 strcat (buf
, ", abi2");
2526 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2527 strcat (buf
, ", odk first");
2529 if (e_flags
& EF_MIPS_32BITMODE
)
2530 strcat (buf
, ", 32bitmode");
2532 switch ((e_flags
& EF_MIPS_MACH
))
2534 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2535 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2536 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2537 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2538 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2539 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2540 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2541 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2542 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2543 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2544 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2545 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2546 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2547 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2548 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2549 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2551 /* We simply ignore the field in this case to avoid confusion:
2552 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2555 default: strcat (buf
, _(", unknown CPU")); break;
2558 switch ((e_flags
& EF_MIPS_ABI
))
2560 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2561 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2562 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2563 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2565 /* We simply ignore the field in this case to avoid confusion:
2566 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2567 This means it is likely to be an o32 file, but not for
2570 default: strcat (buf
, _(", unknown ABI")); break;
2573 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2574 strcat (buf
, ", mdmx");
2576 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2577 strcat (buf
, ", mips16");
2579 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2580 strcat (buf
, ", micromips");
2582 switch ((e_flags
& EF_MIPS_ARCH
))
2584 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2585 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2586 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2587 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2588 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2589 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2590 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2591 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2592 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2593 default: strcat (buf
, _(", unknown ISA")); break;
2598 switch ((e_flags
& EF_SH_MACH_MASK
))
2600 case EF_SH1
: strcat (buf
, ", sh1"); break;
2601 case EF_SH2
: strcat (buf
, ", sh2"); break;
2602 case EF_SH3
: strcat (buf
, ", sh3"); break;
2603 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2604 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2605 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2606 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2607 case EF_SH4
: strcat (buf
, ", sh4"); break;
2608 case EF_SH5
: strcat (buf
, ", sh5"); break;
2609 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2610 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2611 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2612 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2613 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2614 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2615 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2616 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2617 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2618 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2619 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2620 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2621 default: strcat (buf
, _(", unknown ISA")); break;
2624 if (e_flags
& EF_SH_PIC
)
2625 strcat (buf
, ", pic");
2627 if (e_flags
& EF_SH_FDPIC
)
2628 strcat (buf
, ", fdpic");
2632 if (e_flags
& EF_SPARC_32PLUS
)
2633 strcat (buf
, ", v8+");
2635 if (e_flags
& EF_SPARC_SUN_US1
)
2636 strcat (buf
, ", ultrasparcI");
2638 if (e_flags
& EF_SPARC_SUN_US3
)
2639 strcat (buf
, ", ultrasparcIII");
2641 if (e_flags
& EF_SPARC_HAL_R1
)
2642 strcat (buf
, ", halr1");
2644 if (e_flags
& EF_SPARC_LEDATA
)
2645 strcat (buf
, ", ledata");
2647 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2648 strcat (buf
, ", tso");
2650 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2651 strcat (buf
, ", pso");
2653 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2654 strcat (buf
, ", rmo");
2658 switch (e_flags
& EF_PARISC_ARCH
)
2660 case EFA_PARISC_1_0
:
2661 strcpy (buf
, ", PA-RISC 1.0");
2663 case EFA_PARISC_1_1
:
2664 strcpy (buf
, ", PA-RISC 1.1");
2666 case EFA_PARISC_2_0
:
2667 strcpy (buf
, ", PA-RISC 2.0");
2672 if (e_flags
& EF_PARISC_TRAPNIL
)
2673 strcat (buf
, ", trapnil");
2674 if (e_flags
& EF_PARISC_EXT
)
2675 strcat (buf
, ", ext");
2676 if (e_flags
& EF_PARISC_LSB
)
2677 strcat (buf
, ", lsb");
2678 if (e_flags
& EF_PARISC_WIDE
)
2679 strcat (buf
, ", wide");
2680 if (e_flags
& EF_PARISC_NO_KABP
)
2681 strcat (buf
, ", no kabp");
2682 if (e_flags
& EF_PARISC_LAZYSWAP
)
2683 strcat (buf
, ", lazyswap");
2688 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2689 strcat (buf
, ", new calling convention");
2691 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2692 strcat (buf
, ", gnu calling convention");
2696 if ((e_flags
& EF_IA_64_ABI64
))
2697 strcat (buf
, ", 64-bit");
2699 strcat (buf
, ", 32-bit");
2700 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2701 strcat (buf
, ", reduced fp model");
2702 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2703 strcat (buf
, ", no function descriptors, constant gp");
2704 else if ((e_flags
& EF_IA_64_CONS_GP
))
2705 strcat (buf
, ", constant gp");
2706 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2707 strcat (buf
, ", absolute");
2708 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2710 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2711 strcat (buf
, ", vms_linkages");
2712 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2714 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2716 case EF_IA_64_VMS_COMCOD_WARNING
:
2717 strcat (buf
, ", warning");
2719 case EF_IA_64_VMS_COMCOD_ERROR
:
2720 strcat (buf
, ", error");
2722 case EF_IA_64_VMS_COMCOD_ABORT
:
2723 strcat (buf
, ", abort");
2732 if ((e_flags
& EF_VAX_NONPIC
))
2733 strcat (buf
, ", non-PIC");
2734 if ((e_flags
& EF_VAX_DFLOAT
))
2735 strcat (buf
, ", D-Float");
2736 if ((e_flags
& EF_VAX_GFLOAT
))
2737 strcat (buf
, ", G-Float");
2741 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2742 strcat (buf
, ", 64-bit doubles");
2743 if (e_flags
& E_FLAG_RX_DSP
)
2744 strcat (buf
, ", dsp");
2745 if (e_flags
& E_FLAG_RX_PID
)
2746 strcat (buf
, ", pid");
2747 if (e_flags
& E_FLAG_RX_ABI
)
2748 strcat (buf
, ", RX ABI");
2752 if (e_flags
& EF_S390_HIGH_GPRS
)
2753 strcat (buf
, ", highgprs");
2757 if ((e_flags
& EF_C6000_REL
))
2758 strcat (buf
, ", relocatable module");
2767 get_osabi_name (unsigned int osabi
)
2769 static char buff
[32];
2773 case ELFOSABI_NONE
: return "UNIX - System V";
2774 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2775 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2776 case ELFOSABI_GNU
: return "UNIX - GNU";
2777 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2778 case ELFOSABI_AIX
: return "UNIX - AIX";
2779 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2780 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2781 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2782 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2783 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2784 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2785 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2786 case ELFOSABI_AROS
: return "AROS";
2787 case ELFOSABI_FENIXOS
: return "FenixOS";
2790 switch (elf_header
.e_machine
)
2795 case ELFOSABI_ARM
: return "ARM";
2805 case ELFOSABI_STANDALONE
: return _("Standalone App");
2814 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2815 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2824 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2830 get_aarch64_segment_type (unsigned long type
)
2834 case PT_AARCH64_ARCHEXT
:
2835 return "AARCH64_ARCHEXT";
2844 get_arm_segment_type (unsigned long type
)
2858 get_mips_segment_type (unsigned long type
)
2862 case PT_MIPS_REGINFO
:
2864 case PT_MIPS_RTPROC
:
2866 case PT_MIPS_OPTIONS
:
2876 get_parisc_segment_type (unsigned long type
)
2880 case PT_HP_TLS
: return "HP_TLS";
2881 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2882 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2883 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2884 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2885 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2886 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2887 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2888 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2889 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2890 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2891 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2892 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2893 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2894 case PT_HP_STACK
: return "HP_STACK";
2895 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2896 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2897 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2898 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2907 get_ia64_segment_type (unsigned long type
)
2911 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2912 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2913 case PT_HP_TLS
: return "HP_TLS";
2914 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2915 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2916 case PT_IA_64_HP_STACK
: return "HP_STACK";
2925 get_tic6x_segment_type (unsigned long type
)
2929 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2938 get_segment_type (unsigned long p_type
)
2940 static char buff
[32];
2944 case PT_NULL
: return "NULL";
2945 case PT_LOAD
: return "LOAD";
2946 case PT_DYNAMIC
: return "DYNAMIC";
2947 case PT_INTERP
: return "INTERP";
2948 case PT_NOTE
: return "NOTE";
2949 case PT_SHLIB
: return "SHLIB";
2950 case PT_PHDR
: return "PHDR";
2951 case PT_TLS
: return "TLS";
2953 case PT_GNU_EH_FRAME
:
2954 return "GNU_EH_FRAME";
2955 case PT_GNU_STACK
: return "GNU_STACK";
2956 case PT_GNU_RELRO
: return "GNU_RELRO";
2959 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2961 const char * result
;
2963 switch (elf_header
.e_machine
)
2966 result
= get_aarch64_segment_type (p_type
);
2969 result
= get_arm_segment_type (p_type
);
2972 case EM_MIPS_RS3_LE
:
2973 result
= get_mips_segment_type (p_type
);
2976 result
= get_parisc_segment_type (p_type
);
2979 result
= get_ia64_segment_type (p_type
);
2982 result
= get_tic6x_segment_type (p_type
);
2992 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2994 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2996 const char * result
;
2998 switch (elf_header
.e_machine
)
3001 result
= get_parisc_segment_type (p_type
);
3004 result
= get_ia64_segment_type (p_type
);
3014 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3017 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3024 get_mips_section_type_name (unsigned int sh_type
)
3028 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3029 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3030 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3031 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3032 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3033 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3034 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3035 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3036 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3037 case SHT_MIPS_RELD
: return "MIPS_RELD";
3038 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3039 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3040 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3041 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3042 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3043 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3044 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3045 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3046 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3047 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3048 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3049 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3050 case SHT_MIPS_LINE
: return "MIPS_LINE";
3051 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3052 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3053 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3054 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3055 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3056 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3057 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3058 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3059 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3060 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3061 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3062 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3063 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3064 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3065 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3066 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3074 get_parisc_section_type_name (unsigned int sh_type
)
3078 case SHT_PARISC_EXT
: return "PARISC_EXT";
3079 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3080 case SHT_PARISC_DOC
: return "PARISC_DOC";
3081 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3082 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3083 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3084 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3092 get_ia64_section_type_name (unsigned int sh_type
)
3094 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3095 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3096 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3100 case SHT_IA_64_EXT
: return "IA_64_EXT";
3101 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3102 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3103 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3104 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3105 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3106 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3107 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3108 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3109 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3117 get_x86_64_section_type_name (unsigned int sh_type
)
3121 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3129 get_aarch64_section_type_name (unsigned int sh_type
)
3133 case SHT_AARCH64_ATTRIBUTES
:
3134 return "AARCH64_ATTRIBUTES";
3142 get_arm_section_type_name (unsigned int sh_type
)
3146 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3147 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3148 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3149 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3150 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3158 get_tic6x_section_type_name (unsigned int sh_type
)
3162 case SHT_C6000_UNWIND
:
3163 return "C6000_UNWIND";
3164 case SHT_C6000_PREEMPTMAP
:
3165 return "C6000_PREEMPTMAP";
3166 case SHT_C6000_ATTRIBUTES
:
3167 return "C6000_ATTRIBUTES";
3172 case SHT_TI_HANDLER
:
3173 return "TI_HANDLER";
3174 case SHT_TI_INITINFO
:
3175 return "TI_INITINFO";
3176 case SHT_TI_PHATTRS
:
3177 return "TI_PHATTRS";
3185 get_section_type_name (unsigned int sh_type
)
3187 static char buff
[32];
3191 case SHT_NULL
: return "NULL";
3192 case SHT_PROGBITS
: return "PROGBITS";
3193 case SHT_SYMTAB
: return "SYMTAB";
3194 case SHT_STRTAB
: return "STRTAB";
3195 case SHT_RELA
: return "RELA";
3196 case SHT_HASH
: return "HASH";
3197 case SHT_DYNAMIC
: return "DYNAMIC";
3198 case SHT_NOTE
: return "NOTE";
3199 case SHT_NOBITS
: return "NOBITS";
3200 case SHT_REL
: return "REL";
3201 case SHT_SHLIB
: return "SHLIB";
3202 case SHT_DYNSYM
: return "DYNSYM";
3203 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3204 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3205 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3206 case SHT_GNU_HASH
: return "GNU_HASH";
3207 case SHT_GROUP
: return "GROUP";
3208 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3209 case SHT_GNU_verdef
: return "VERDEF";
3210 case SHT_GNU_verneed
: return "VERNEED";
3211 case SHT_GNU_versym
: return "VERSYM";
3212 case 0x6ffffff0: return "VERSYM";
3213 case 0x6ffffffc: return "VERDEF";
3214 case 0x7ffffffd: return "AUXILIARY";
3215 case 0x7fffffff: return "FILTER";
3216 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3219 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3221 const char * result
;
3223 switch (elf_header
.e_machine
)
3226 case EM_MIPS_RS3_LE
:
3227 result
= get_mips_section_type_name (sh_type
);
3230 result
= get_parisc_section_type_name (sh_type
);
3233 result
= get_ia64_section_type_name (sh_type
);
3238 result
= get_x86_64_section_type_name (sh_type
);
3241 result
= get_aarch64_section_type_name (sh_type
);
3244 result
= get_arm_section_type_name (sh_type
);
3247 result
= get_tic6x_section_type_name (sh_type
);
3257 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3259 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3261 const char * result
;
3263 switch (elf_header
.e_machine
)
3266 result
= get_ia64_section_type_name (sh_type
);
3276 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3278 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3279 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3281 /* This message is probably going to be displayed in a 15
3282 character wide field, so put the hex value first. */
3283 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3289 #define OPTION_DEBUG_DUMP 512
3290 #define OPTION_DYN_SYMS 513
3291 #define OPTION_DWARF_DEPTH 514
3292 #define OPTION_DWARF_START 515
3293 #define OPTION_DWARF_CHECK 516
3295 static struct option options
[] =
3297 {"all", no_argument
, 0, 'a'},
3298 {"file-header", no_argument
, 0, 'h'},
3299 {"program-headers", no_argument
, 0, 'l'},
3300 {"headers", no_argument
, 0, 'e'},
3301 {"histogram", no_argument
, 0, 'I'},
3302 {"segments", no_argument
, 0, 'l'},
3303 {"sections", no_argument
, 0, 'S'},
3304 {"section-headers", no_argument
, 0, 'S'},
3305 {"section-groups", no_argument
, 0, 'g'},
3306 {"section-details", no_argument
, 0, 't'},
3307 {"full-section-name",no_argument
, 0, 'N'},
3308 {"symbols", no_argument
, 0, 's'},
3309 {"syms", no_argument
, 0, 's'},
3310 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3311 {"relocs", no_argument
, 0, 'r'},
3312 {"notes", no_argument
, 0, 'n'},
3313 {"dynamic", no_argument
, 0, 'd'},
3314 {"arch-specific", no_argument
, 0, 'A'},
3315 {"version-info", no_argument
, 0, 'V'},
3316 {"use-dynamic", no_argument
, 0, 'D'},
3317 {"unwind", no_argument
, 0, 'u'},
3318 {"archive-index", no_argument
, 0, 'c'},
3319 {"hex-dump", required_argument
, 0, 'x'},
3320 {"relocated-dump", required_argument
, 0, 'R'},
3321 {"string-dump", required_argument
, 0, 'p'},
3322 #ifdef SUPPORT_DISASSEMBLY
3323 {"instruction-dump", required_argument
, 0, 'i'},
3325 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3327 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3328 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3329 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3331 {"version", no_argument
, 0, 'v'},
3332 {"wide", no_argument
, 0, 'W'},
3333 {"help", no_argument
, 0, 'H'},
3334 {0, no_argument
, 0, 0}
3338 usage (FILE * stream
)
3340 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3341 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3342 fprintf (stream
, _(" Options are:\n\
3343 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3344 -h --file-header Display the ELF file header\n\
3345 -l --program-headers Display the program headers\n\
3346 --segments An alias for --program-headers\n\
3347 -S --section-headers Display the sections' header\n\
3348 --sections An alias for --section-headers\n\
3349 -g --section-groups Display the section groups\n\
3350 -t --section-details Display the section details\n\
3351 -e --headers Equivalent to: -h -l -S\n\
3352 -s --syms Display the symbol table\n\
3353 --symbols An alias for --syms\n\
3354 --dyn-syms Display the dynamic symbol table\n\
3355 -n --notes Display the core notes (if present)\n\
3356 -r --relocs Display the relocations (if present)\n\
3357 -u --unwind Display the unwind info (if present)\n\
3358 -d --dynamic Display the dynamic section (if present)\n\
3359 -V --version-info Display the version sections (if present)\n\
3360 -A --arch-specific Display architecture specific information (if any)\n\
3361 -c --archive-index Display the symbol/file index in an archive\n\
3362 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3363 -x --hex-dump=<number|name>\n\
3364 Dump the contents of section <number|name> as bytes\n\
3365 -p --string-dump=<number|name>\n\
3366 Dump the contents of section <number|name> as strings\n\
3367 -R --relocated-dump=<number|name>\n\
3368 Dump the contents of section <number|name> as relocated bytes\n\
3369 -w[lLiaprmfFsoRt] or\n\
3370 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3371 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3372 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3374 Display the contents of DWARF2 debug sections\n"));
3375 fprintf (stream
, _("\
3376 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3377 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3379 #ifdef SUPPORT_DISASSEMBLY
3380 fprintf (stream
, _("\
3381 -i --instruction-dump=<number|name>\n\
3382 Disassemble the contents of section <number|name>\n"));
3384 fprintf (stream
, _("\
3385 -I --histogram Display histogram of bucket list lengths\n\
3386 -W --wide Allow output width to exceed 80 characters\n\
3387 @<file> Read options from <file>\n\
3388 -H --help Display this information\n\
3389 -v --version Display the version number of readelf\n"));
3391 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3392 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3394 exit (stream
== stdout
? 0 : 1);
3397 /* Record the fact that the user wants the contents of section number
3398 SECTION to be displayed using the method(s) encoded as flags bits
3399 in TYPE. Note, TYPE can be zero if we are creating the array for
3403 request_dump_bynumber (unsigned int section
, dump_type type
)
3405 if (section
>= num_dump_sects
)
3407 dump_type
* new_dump_sects
;
3409 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3410 sizeof (* dump_sects
));
3412 if (new_dump_sects
== NULL
)
3413 error (_("Out of memory allocating dump request table.\n"));
3416 /* Copy current flag settings. */
3417 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3421 dump_sects
= new_dump_sects
;
3422 num_dump_sects
= section
+ 1;
3427 dump_sects
[section
] |= type
;
3432 /* Request a dump by section name. */
3435 request_dump_byname (const char * section
, dump_type type
)
3437 struct dump_list_entry
* new_request
;
3439 new_request
= (struct dump_list_entry
*)
3440 malloc (sizeof (struct dump_list_entry
));
3442 error (_("Out of memory allocating dump request table.\n"));
3444 new_request
->name
= strdup (section
);
3445 if (!new_request
->name
)
3446 error (_("Out of memory allocating dump request table.\n"));
3448 new_request
->type
= type
;
3450 new_request
->next
= dump_sects_byname
;
3451 dump_sects_byname
= new_request
;
3455 request_dump (dump_type type
)
3461 section
= strtoul (optarg
, & cp
, 0);
3463 if (! *cp
&& section
>= 0)
3464 request_dump_bynumber (section
, type
);
3466 request_dump_byname (optarg
, type
);
3471 parse_args (int argc
, char ** argv
)
3478 while ((c
= getopt_long
3479 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3497 do_section_groups
++;
3505 do_section_groups
++;
3510 do_section_details
++;
3554 request_dump (HEX_DUMP
);
3557 request_dump (STRING_DUMP
);
3560 request_dump (RELOC_DUMP
);
3567 dwarf_select_sections_all ();
3572 dwarf_select_sections_by_letters (optarg
);
3575 case OPTION_DEBUG_DUMP
:
3582 dwarf_select_sections_by_names (optarg
);
3585 case OPTION_DWARF_DEPTH
:
3589 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3592 case OPTION_DWARF_START
:
3596 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3599 case OPTION_DWARF_CHECK
:
3602 case OPTION_DYN_SYMS
:
3605 #ifdef SUPPORT_DISASSEMBLY
3607 request_dump (DISASS_DUMP
);
3611 print_version (program_name
);
3620 /* xgettext:c-format */
3621 error (_("Invalid option '-%c'\n"), c
);
3628 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3629 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3630 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3631 && !do_section_groups
&& !do_archive_index
3636 warn (_("Nothing to do.\n"));
3642 get_elf_class (unsigned int elf_class
)
3644 static char buff
[32];
3648 case ELFCLASSNONE
: return _("none");
3649 case ELFCLASS32
: return "ELF32";
3650 case ELFCLASS64
: return "ELF64";
3652 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3658 get_data_encoding (unsigned int encoding
)
3660 static char buff
[32];
3664 case ELFDATANONE
: return _("none");
3665 case ELFDATA2LSB
: return _("2's complement, little endian");
3666 case ELFDATA2MSB
: return _("2's complement, big endian");
3668 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3673 /* Decode the data held in 'elf_header'. */
3676 process_file_header (void)
3678 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3679 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3680 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3681 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3684 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3688 init_dwarf_regnames (elf_header
.e_machine
);
3694 printf (_("ELF Header:\n"));
3695 printf (_(" Magic: "));
3696 for (i
= 0; i
< EI_NIDENT
; i
++)
3697 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3699 printf (_(" Class: %s\n"),
3700 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3701 printf (_(" Data: %s\n"),
3702 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3703 printf (_(" Version: %d %s\n"),
3704 elf_header
.e_ident
[EI_VERSION
],
3705 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3707 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3708 ? _("<unknown: %lx>")
3710 printf (_(" OS/ABI: %s\n"),
3711 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3712 printf (_(" ABI Version: %d\n"),
3713 elf_header
.e_ident
[EI_ABIVERSION
]);
3714 printf (_(" Type: %s\n"),
3715 get_file_type (elf_header
.e_type
));
3716 printf (_(" Machine: %s\n"),
3717 get_machine_name (elf_header
.e_machine
));
3718 printf (_(" Version: 0x%lx\n"),
3719 (unsigned long) elf_header
.e_version
);
3721 printf (_(" Entry point address: "));
3722 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3723 printf (_("\n Start of program headers: "));
3724 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3725 printf (_(" (bytes into file)\n Start of section headers: "));
3726 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3727 printf (_(" (bytes into file)\n"));
3729 printf (_(" Flags: 0x%lx%s\n"),
3730 (unsigned long) elf_header
.e_flags
,
3731 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3732 printf (_(" Size of this header: %ld (bytes)\n"),
3733 (long) elf_header
.e_ehsize
);
3734 printf (_(" Size of program headers: %ld (bytes)\n"),
3735 (long) elf_header
.e_phentsize
);
3736 printf (_(" Number of program headers: %ld"),
3737 (long) elf_header
.e_phnum
);
3738 if (section_headers
!= NULL
3739 && elf_header
.e_phnum
== PN_XNUM
3740 && section_headers
[0].sh_info
!= 0)
3741 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3742 putc ('\n', stdout
);
3743 printf (_(" Size of section headers: %ld (bytes)\n"),
3744 (long) elf_header
.e_shentsize
);
3745 printf (_(" Number of section headers: %ld"),
3746 (long) elf_header
.e_shnum
);
3747 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3748 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3749 putc ('\n', stdout
);
3750 printf (_(" Section header string table index: %ld"),
3751 (long) elf_header
.e_shstrndx
);
3752 if (section_headers
!= NULL
3753 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3754 printf (" (%u)", section_headers
[0].sh_link
);
3755 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3756 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3757 printf (_(" <corrupt: out of range>"));
3758 putc ('\n', stdout
);
3761 if (section_headers
!= NULL
)
3763 if (elf_header
.e_phnum
== PN_XNUM
3764 && section_headers
[0].sh_info
!= 0)
3765 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3766 if (elf_header
.e_shnum
== SHN_UNDEF
)
3767 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3768 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3769 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3770 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3771 elf_header
.e_shstrndx
= SHN_UNDEF
;
3772 free (section_headers
);
3773 section_headers
= NULL
;
3781 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3783 Elf32_External_Phdr
* phdrs
;
3784 Elf32_External_Phdr
* external
;
3785 Elf_Internal_Phdr
* internal
;
3788 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3789 elf_header
.e_phentsize
,
3791 _("program headers"));
3795 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3796 i
< elf_header
.e_phnum
;
3797 i
++, internal
++, external
++)
3799 internal
->p_type
= BYTE_GET (external
->p_type
);
3800 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3801 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3802 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3803 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3804 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3805 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3806 internal
->p_align
= BYTE_GET (external
->p_align
);
3815 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3817 Elf64_External_Phdr
* phdrs
;
3818 Elf64_External_Phdr
* external
;
3819 Elf_Internal_Phdr
* internal
;
3822 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3823 elf_header
.e_phentsize
,
3825 _("program headers"));
3829 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3830 i
< elf_header
.e_phnum
;
3831 i
++, internal
++, external
++)
3833 internal
->p_type
= BYTE_GET (external
->p_type
);
3834 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3835 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3836 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3837 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3838 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3839 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3840 internal
->p_align
= BYTE_GET (external
->p_align
);
3848 /* Returns 1 if the program headers were read into `program_headers'. */
3851 get_program_headers (FILE * file
)
3853 Elf_Internal_Phdr
* phdrs
;
3855 /* Check cache of prior read. */
3856 if (program_headers
!= NULL
)
3859 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3860 sizeof (Elf_Internal_Phdr
));
3864 error (_("Out of memory\n"));
3869 ? get_32bit_program_headers (file
, phdrs
)
3870 : get_64bit_program_headers (file
, phdrs
))
3872 program_headers
= phdrs
;
3880 /* Returns 1 if the program headers were loaded. */
3883 process_program_headers (FILE * file
)
3885 Elf_Internal_Phdr
* segment
;
3888 if (elf_header
.e_phnum
== 0)
3890 /* PR binutils/12467. */
3891 if (elf_header
.e_phoff
!= 0)
3892 warn (_("possibly corrupt ELF header - it has a non-zero program"
3893 " header offset, but no program headers"));
3894 else if (do_segments
)
3895 printf (_("\nThere are no program headers in this file.\n"));
3899 if (do_segments
&& !do_header
)
3901 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3902 printf (_("Entry point "));
3903 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3904 printf (_("\nThere are %d program headers, starting at offset "),
3905 elf_header
.e_phnum
);
3906 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3910 if (! get_program_headers (file
))
3915 if (elf_header
.e_phnum
> 1)
3916 printf (_("\nProgram Headers:\n"));
3918 printf (_("\nProgram Headers:\n"));
3922 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3925 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3929 (_(" Type Offset VirtAddr PhysAddr\n"));
3931 (_(" FileSiz MemSiz Flags Align\n"));
3938 for (i
= 0, segment
= program_headers
;
3939 i
< elf_header
.e_phnum
;
3944 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3948 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3949 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3950 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3951 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3952 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3954 (segment
->p_flags
& PF_R
? 'R' : ' '),
3955 (segment
->p_flags
& PF_W
? 'W' : ' '),
3956 (segment
->p_flags
& PF_X
? 'E' : ' '));
3957 printf ("%#lx", (unsigned long) segment
->p_align
);
3961 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3962 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3965 print_vma (segment
->p_offset
, FULL_HEX
);
3969 print_vma (segment
->p_vaddr
, FULL_HEX
);
3971 print_vma (segment
->p_paddr
, FULL_HEX
);
3974 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3975 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3978 print_vma (segment
->p_filesz
, FULL_HEX
);
3982 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3983 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3986 print_vma (segment
->p_memsz
, FULL_HEX
);
3990 (segment
->p_flags
& PF_R
? 'R' : ' '),
3991 (segment
->p_flags
& PF_W
? 'W' : ' '),
3992 (segment
->p_flags
& PF_X
? 'E' : ' '));
3994 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3995 printf ("%#lx", (unsigned long) segment
->p_align
);
3998 print_vma (segment
->p_align
, PREFIX_HEX
);
4003 print_vma (segment
->p_offset
, FULL_HEX
);
4005 print_vma (segment
->p_vaddr
, FULL_HEX
);
4007 print_vma (segment
->p_paddr
, FULL_HEX
);
4009 print_vma (segment
->p_filesz
, FULL_HEX
);
4011 print_vma (segment
->p_memsz
, FULL_HEX
);
4013 (segment
->p_flags
& PF_R
? 'R' : ' '),
4014 (segment
->p_flags
& PF_W
? 'W' : ' '),
4015 (segment
->p_flags
& PF_X
? 'E' : ' '));
4016 print_vma (segment
->p_align
, HEX
);
4020 switch (segment
->p_type
)
4024 error (_("more than one dynamic segment\n"));
4026 /* By default, assume that the .dynamic section is the first
4027 section in the DYNAMIC segment. */
4028 dynamic_addr
= segment
->p_offset
;
4029 dynamic_size
= segment
->p_filesz
;
4031 /* Try to locate the .dynamic section. If there is
4032 a section header table, we can easily locate it. */
4033 if (section_headers
!= NULL
)
4035 Elf_Internal_Shdr
* sec
;
4037 sec
= find_section (".dynamic");
4038 if (sec
== NULL
|| sec
->sh_size
== 0)
4040 /* A corresponding .dynamic section is expected, but on
4041 IA-64/OpenVMS it is OK for it to be missing. */
4042 if (!is_ia64_vms ())
4043 error (_("no .dynamic section in the dynamic segment\n"));
4047 if (sec
->sh_type
== SHT_NOBITS
)
4053 dynamic_addr
= sec
->sh_offset
;
4054 dynamic_size
= sec
->sh_size
;
4056 if (dynamic_addr
< segment
->p_offset
4057 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4058 warn (_("the .dynamic section is not contained"
4059 " within the dynamic segment\n"));
4060 else if (dynamic_addr
> segment
->p_offset
)
4061 warn (_("the .dynamic section is not the first section"
4062 " in the dynamic segment.\n"));
4067 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4069 error (_("Unable to find program interpreter name\n"));
4073 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4075 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4076 error (_("Internal error: failed to create format string to display program interpreter\n"));
4078 program_interpreter
[0] = 0;
4079 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4080 error (_("Unable to read program interpreter name\n"));
4083 printf (_("\n [Requesting program interpreter: %s]"),
4084 program_interpreter
);
4090 putc ('\n', stdout
);
4093 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4095 printf (_("\n Section to Segment mapping:\n"));
4096 printf (_(" Segment Sections...\n"));
4098 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4101 Elf_Internal_Shdr
* section
;
4103 segment
= program_headers
+ i
;
4104 section
= section_headers
+ 1;
4106 printf (" %2.2d ", i
);
4108 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4110 if (!ELF_TBSS_SPECIAL (section
, segment
)
4111 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4112 printf ("%s ", SECTION_NAME (section
));
4123 /* Find the file offset corresponding to VMA by using the program headers. */
4126 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4128 Elf_Internal_Phdr
* seg
;
4130 if (! get_program_headers (file
))
4132 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4136 for (seg
= program_headers
;
4137 seg
< program_headers
+ elf_header
.e_phnum
;
4140 if (seg
->p_type
!= PT_LOAD
)
4143 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4144 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4145 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4148 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4149 (unsigned long) vma
);
4155 get_32bit_section_headers (FILE * file
, unsigned int num
)
4157 Elf32_External_Shdr
* shdrs
;
4158 Elf_Internal_Shdr
* internal
;
4161 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4162 elf_header
.e_shentsize
, num
,
4163 _("section headers"));
4167 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4168 sizeof (Elf_Internal_Shdr
));
4170 if (section_headers
== NULL
)
4172 error (_("Out of memory\n"));
4176 for (i
= 0, internal
= section_headers
;
4180 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4181 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4182 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4183 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4184 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4185 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4186 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4187 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4188 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4189 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4198 get_64bit_section_headers (FILE * file
, unsigned int num
)
4200 Elf64_External_Shdr
* shdrs
;
4201 Elf_Internal_Shdr
* internal
;
4204 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4205 elf_header
.e_shentsize
, num
,
4206 _("section headers"));
4210 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4211 sizeof (Elf_Internal_Shdr
));
4213 if (section_headers
== NULL
)
4215 error (_("Out of memory\n"));
4219 for (i
= 0, internal
= section_headers
;
4223 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4224 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4225 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4226 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4227 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4228 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4229 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4230 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4231 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4232 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4240 static Elf_Internal_Sym
*
4241 get_32bit_elf_symbols (FILE * file
,
4242 Elf_Internal_Shdr
* section
,
4243 unsigned long * num_syms_return
)
4245 unsigned long number
= 0;
4246 Elf32_External_Sym
* esyms
= NULL
;
4247 Elf_External_Sym_Shndx
* shndx
= NULL
;
4248 Elf_Internal_Sym
* isyms
= NULL
;
4249 Elf_Internal_Sym
* psym
;
4252 /* Run some sanity checks first. */
4253 if (section
->sh_entsize
== 0)
4255 error (_("sh_entsize is zero\n"));
4259 number
= section
->sh_size
/ section
->sh_entsize
;
4261 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4263 error (_("Invalid sh_entsize\n"));
4267 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4268 section
->sh_size
, _("symbols"));
4273 if (symtab_shndx_hdr
!= NULL
4274 && (symtab_shndx_hdr
->sh_link
4275 == (unsigned long) (section
- section_headers
)))
4277 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4278 symtab_shndx_hdr
->sh_offset
,
4279 1, symtab_shndx_hdr
->sh_size
,
4280 _("symbol table section indicies"));
4285 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4289 error (_("Out of memory\n"));
4293 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4295 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4296 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4297 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4298 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4299 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4301 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4302 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4303 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4304 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4305 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4314 if (num_syms_return
!= NULL
)
4315 * num_syms_return
= isyms
== NULL
? 0 : number
;
4320 static Elf_Internal_Sym
*
4321 get_64bit_elf_symbols (FILE * file
,
4322 Elf_Internal_Shdr
* section
,
4323 unsigned long * num_syms_return
)
4325 unsigned long number
= 0;
4326 Elf64_External_Sym
* esyms
= NULL
;
4327 Elf_External_Sym_Shndx
* shndx
= NULL
;
4328 Elf_Internal_Sym
* isyms
= NULL
;
4329 Elf_Internal_Sym
* psym
;
4332 /* Run some sanity checks first. */
4333 if (section
->sh_entsize
== 0)
4335 error (_("sh_entsize is zero\n"));
4339 number
= section
->sh_size
/ section
->sh_entsize
;
4341 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4343 error (_("Invalid sh_entsize\n"));
4347 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4348 section
->sh_size
, _("symbols"));
4352 if (symtab_shndx_hdr
!= NULL
4353 && (symtab_shndx_hdr
->sh_link
4354 == (unsigned long) (section
- section_headers
)))
4356 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4357 symtab_shndx_hdr
->sh_offset
,
4358 1, symtab_shndx_hdr
->sh_size
,
4359 _("symbol table section indicies"));
4364 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4368 error (_("Out of memory\n"));
4372 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4374 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4375 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4376 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4377 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4379 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4381 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4382 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4383 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4385 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4386 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4395 if (num_syms_return
!= NULL
)
4396 * num_syms_return
= isyms
== NULL
? 0 : number
;
4402 get_elf_section_flags (bfd_vma sh_flags
)
4404 static char buff
[1024];
4406 int field_size
= is_32bit_elf
? 8 : 16;
4408 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4409 bfd_vma os_flags
= 0;
4410 bfd_vma proc_flags
= 0;
4411 bfd_vma unknown_flags
= 0;
4419 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4420 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4421 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4422 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4423 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4424 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4425 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4426 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4427 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4428 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4429 /* IA-64 specific. */
4430 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4431 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4432 /* IA-64 OpenVMS specific. */
4433 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4434 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4435 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4436 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4437 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4438 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4440 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4441 /* SPARC specific. */
4442 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4445 if (do_section_details
)
4447 sprintf (buff
, "[%*.*lx]: ",
4448 field_size
, field_size
, (unsigned long) sh_flags
);
4449 p
+= field_size
+ 4;
4456 flag
= sh_flags
& - sh_flags
;
4459 if (do_section_details
)
4463 case SHF_WRITE
: sindex
= 0; break;
4464 case SHF_ALLOC
: sindex
= 1; break;
4465 case SHF_EXECINSTR
: sindex
= 2; break;
4466 case SHF_MERGE
: sindex
= 3; break;
4467 case SHF_STRINGS
: sindex
= 4; break;
4468 case SHF_INFO_LINK
: sindex
= 5; break;
4469 case SHF_LINK_ORDER
: sindex
= 6; break;
4470 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4471 case SHF_GROUP
: sindex
= 8; break;
4472 case SHF_TLS
: sindex
= 9; break;
4473 case SHF_EXCLUDE
: sindex
= 18; break;
4477 switch (elf_header
.e_machine
)
4480 if (flag
== SHF_IA_64_SHORT
)
4482 else if (flag
== SHF_IA_64_NORECOV
)
4485 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4488 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4489 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4490 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4491 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4492 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4493 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4504 case EM_OLD_SPARCV9
:
4505 case EM_SPARC32PLUS
:
4508 if (flag
== SHF_ORDERED
)
4518 if (p
!= buff
+ field_size
+ 4)
4520 if (size
< (10 + 2))
4527 size
-= flags
[sindex
].len
;
4528 p
= stpcpy (p
, flags
[sindex
].str
);
4530 else if (flag
& SHF_MASKOS
)
4532 else if (flag
& SHF_MASKPROC
)
4535 unknown_flags
|= flag
;
4541 case SHF_WRITE
: *p
= 'W'; break;
4542 case SHF_ALLOC
: *p
= 'A'; break;
4543 case SHF_EXECINSTR
: *p
= 'X'; break;
4544 case SHF_MERGE
: *p
= 'M'; break;
4545 case SHF_STRINGS
: *p
= 'S'; break;
4546 case SHF_INFO_LINK
: *p
= 'I'; break;
4547 case SHF_LINK_ORDER
: *p
= 'L'; break;
4548 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4549 case SHF_GROUP
: *p
= 'G'; break;
4550 case SHF_TLS
: *p
= 'T'; break;
4551 case SHF_EXCLUDE
: *p
= 'E'; break;
4554 if ((elf_header
.e_machine
== EM_X86_64
4555 || elf_header
.e_machine
== EM_L1OM
4556 || elf_header
.e_machine
== EM_K1OM
)
4557 && flag
== SHF_X86_64_LARGE
)
4559 else if (flag
& SHF_MASKOS
)
4562 sh_flags
&= ~ SHF_MASKOS
;
4564 else if (flag
& SHF_MASKPROC
)
4567 sh_flags
&= ~ SHF_MASKPROC
;
4577 if (do_section_details
)
4581 size
-= 5 + field_size
;
4582 if (p
!= buff
+ field_size
+ 4)
4590 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4591 (unsigned long) os_flags
);
4592 p
+= 5 + field_size
;
4596 size
-= 7 + field_size
;
4597 if (p
!= buff
+ field_size
+ 4)
4605 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4606 (unsigned long) proc_flags
);
4607 p
+= 7 + field_size
;
4611 size
-= 10 + field_size
;
4612 if (p
!= buff
+ field_size
+ 4)
4620 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4621 (unsigned long) unknown_flags
);
4622 p
+= 10 + field_size
;
4631 process_section_headers (FILE * file
)
4633 Elf_Internal_Shdr
* section
;
4636 section_headers
= NULL
;
4638 if (elf_header
.e_shnum
== 0)
4640 /* PR binutils/12467. */
4641 if (elf_header
.e_shoff
!= 0)
4642 warn (_("possibly corrupt ELF file header - it has a non-zero"
4643 " section header offset, but no section headers\n"));
4644 else if (do_sections
)
4645 printf (_("\nThere are no sections in this file.\n"));
4650 if (do_sections
&& !do_header
)
4651 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4652 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4656 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4659 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4662 /* Read in the string table, so that we have names to display. */
4663 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4664 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4666 section
= section_headers
+ elf_header
.e_shstrndx
;
4668 if (section
->sh_size
!= 0)
4670 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4671 1, section
->sh_size
,
4674 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4678 /* Scan the sections for the dynamic symbol table
4679 and dynamic string table and debug sections. */
4680 dynamic_symbols
= NULL
;
4681 dynamic_strings
= NULL
;
4682 dynamic_syminfo
= NULL
;
4683 symtab_shndx_hdr
= NULL
;
4685 eh_addr_size
= is_32bit_elf
? 4 : 8;
4686 switch (elf_header
.e_machine
)
4689 case EM_MIPS_RS3_LE
:
4690 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4691 FDE addresses. However, the ABI also has a semi-official ILP32
4692 variant for which the normal FDE address size rules apply.
4694 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4695 section, where XX is the size of longs in bits. Unfortunately,
4696 earlier compilers provided no way of distinguishing ILP32 objects
4697 from LP64 objects, so if there's any doubt, we should assume that
4698 the official LP64 form is being used. */
4699 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4700 && find_section (".gcc_compiled_long32") == NULL
)
4706 switch (elf_header
.e_flags
& EF_H8_MACH
)
4708 case E_H8_MACH_H8300
:
4709 case E_H8_MACH_H8300HN
:
4710 case E_H8_MACH_H8300SN
:
4711 case E_H8_MACH_H8300SXN
:
4714 case E_H8_MACH_H8300H
:
4715 case E_H8_MACH_H8300S
:
4716 case E_H8_MACH_H8300SX
:
4724 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4726 case EF_M32C_CPU_M16C
:
4733 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4736 size_t expected_entsize \
4737 = is_32bit_elf ? size32 : size64; \
4738 if (section->sh_entsize != expected_entsize) \
4739 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4740 i, (unsigned long int) section->sh_entsize, \
4741 (unsigned long int) expected_entsize); \
4742 section->sh_entsize = expected_entsize; \
4745 #define CHECK_ENTSIZE(section, i, type) \
4746 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4747 sizeof (Elf64_External_##type))
4749 for (i
= 0, section
= section_headers
;
4750 i
< elf_header
.e_shnum
;
4753 char * name
= SECTION_NAME (section
);
4755 if (section
->sh_type
== SHT_DYNSYM
)
4757 if (dynamic_symbols
!= NULL
)
4759 error (_("File contains multiple dynamic symbol tables\n"));
4763 CHECK_ENTSIZE (section
, i
, Sym
);
4764 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4766 else if (section
->sh_type
== SHT_STRTAB
4767 && streq (name
, ".dynstr"))
4769 if (dynamic_strings
!= NULL
)
4771 error (_("File contains multiple dynamic string tables\n"));
4775 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4776 1, section
->sh_size
,
4777 _("dynamic strings"));
4778 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4780 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4782 if (symtab_shndx_hdr
!= NULL
)
4784 error (_("File contains multiple symtab shndx tables\n"));
4787 symtab_shndx_hdr
= section
;
4789 else if (section
->sh_type
== SHT_SYMTAB
)
4790 CHECK_ENTSIZE (section
, i
, Sym
);
4791 else if (section
->sh_type
== SHT_GROUP
)
4792 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4793 else if (section
->sh_type
== SHT_REL
)
4794 CHECK_ENTSIZE (section
, i
, Rel
);
4795 else if (section
->sh_type
== SHT_RELA
)
4796 CHECK_ENTSIZE (section
, i
, Rela
);
4797 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4798 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4799 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4800 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4801 || do_debug_addr
|| do_debug_cu_index
)
4802 && (const_strneq (name
, ".debug_")
4803 || const_strneq (name
, ".zdebug_")))
4806 name
+= sizeof (".zdebug_") - 1;
4808 name
+= sizeof (".debug_") - 1;
4811 || (do_debug_info
&& const_strneq (name
, "info"))
4812 || (do_debug_info
&& const_strneq (name
, "types"))
4813 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4814 || (do_debug_lines
&& const_strneq (name
, "line"))
4815 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4816 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4817 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4818 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4819 || (do_debug_frames
&& const_strneq (name
, "frame"))
4820 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4821 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4822 || (do_debug_str
&& const_strneq (name
, "str"))
4823 || (do_debug_loc
&& const_strneq (name
, "loc"))
4824 || (do_debug_addr
&& const_strneq (name
, "addr"))
4825 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4826 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4828 request_dump_bynumber (i
, DEBUG_DUMP
);
4830 /* Linkonce section to be combined with .debug_info at link time. */
4831 else if ((do_debugging
|| do_debug_info
)
4832 && const_strneq (name
, ".gnu.linkonce.wi."))
4833 request_dump_bynumber (i
, DEBUG_DUMP
);
4834 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4835 request_dump_bynumber (i
, DEBUG_DUMP
);
4836 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4837 request_dump_bynumber (i
, DEBUG_DUMP
);
4838 /* Trace sections for Itanium VMS. */
4839 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4840 || do_trace_aranges
)
4841 && const_strneq (name
, ".trace_"))
4843 name
+= sizeof (".trace_") - 1;
4846 || (do_trace_info
&& streq (name
, "info"))
4847 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4848 || (do_trace_aranges
&& streq (name
, "aranges"))
4850 request_dump_bynumber (i
, DEBUG_DUMP
);
4858 if (elf_header
.e_shnum
> 1)
4859 printf (_("\nSection Headers:\n"));
4861 printf (_("\nSection Header:\n"));
4865 if (do_section_details
)
4867 printf (_(" [Nr] Name\n"));
4868 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4872 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4876 if (do_section_details
)
4878 printf (_(" [Nr] Name\n"));
4879 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4883 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4887 if (do_section_details
)
4889 printf (_(" [Nr] Name\n"));
4890 printf (_(" Type Address Offset Link\n"));
4891 printf (_(" Size EntSize Info Align\n"));
4895 printf (_(" [Nr] Name Type Address Offset\n"));
4896 printf (_(" Size EntSize Flags Link Info Align\n"));
4900 if (do_section_details
)
4901 printf (_(" Flags\n"));
4903 for (i
= 0, section
= section_headers
;
4904 i
< elf_header
.e_shnum
;
4907 printf (" [%2u] ", i
);
4908 if (do_section_details
)
4910 print_symbol (INT_MAX
, SECTION_NAME (section
));
4915 print_symbol (-17, SECTION_NAME (section
));
4918 printf (do_wide
? " %-15s " : " %-15.15s ",
4919 get_section_type_name (section
->sh_type
));
4923 const char * link_too_big
= NULL
;
4925 print_vma (section
->sh_addr
, LONG_HEX
);
4927 printf ( " %6.6lx %6.6lx %2.2lx",
4928 (unsigned long) section
->sh_offset
,
4929 (unsigned long) section
->sh_size
,
4930 (unsigned long) section
->sh_entsize
);
4932 if (do_section_details
)
4933 fputs (" ", stdout
);
4935 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4937 if (section
->sh_link
>= elf_header
.e_shnum
)
4940 /* The sh_link value is out of range. Normally this indicates
4941 an error but it can have special values in Solaris binaries. */
4942 switch (elf_header
.e_machine
)
4949 case EM_OLD_SPARCV9
:
4950 case EM_SPARC32PLUS
:
4953 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4954 link_too_big
= "BEFORE";
4955 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4956 link_too_big
= "AFTER";
4963 if (do_section_details
)
4965 if (link_too_big
!= NULL
&& * link_too_big
)
4966 printf ("<%s> ", link_too_big
);
4968 printf ("%2u ", section
->sh_link
);
4969 printf ("%3u %2lu\n", section
->sh_info
,
4970 (unsigned long) section
->sh_addralign
);
4973 printf ("%2u %3u %2lu\n",
4976 (unsigned long) section
->sh_addralign
);
4978 if (link_too_big
&& ! * link_too_big
)
4979 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4980 i
, section
->sh_link
);
4984 print_vma (section
->sh_addr
, LONG_HEX
);
4986 if ((long) section
->sh_offset
== section
->sh_offset
)
4987 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4991 print_vma (section
->sh_offset
, LONG_HEX
);
4994 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4995 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4999 print_vma (section
->sh_size
, LONG_HEX
);
5002 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5003 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5007 print_vma (section
->sh_entsize
, LONG_HEX
);
5010 if (do_section_details
)
5011 fputs (" ", stdout
);
5013 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5015 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5017 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5018 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5021 print_vma (section
->sh_addralign
, DEC
);
5025 else if (do_section_details
)
5027 printf (" %-15.15s ",
5028 get_section_type_name (section
->sh_type
));
5029 print_vma (section
->sh_addr
, LONG_HEX
);
5030 if ((long) section
->sh_offset
== section
->sh_offset
)
5031 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5035 print_vma (section
->sh_offset
, LONG_HEX
);
5037 printf (" %u\n ", section
->sh_link
);
5038 print_vma (section
->sh_size
, LONG_HEX
);
5040 print_vma (section
->sh_entsize
, LONG_HEX
);
5042 printf (" %-16u %lu\n",
5044 (unsigned long) section
->sh_addralign
);
5049 print_vma (section
->sh_addr
, LONG_HEX
);
5050 if ((long) section
->sh_offset
== section
->sh_offset
)
5051 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5055 print_vma (section
->sh_offset
, LONG_HEX
);
5058 print_vma (section
->sh_size
, LONG_HEX
);
5060 print_vma (section
->sh_entsize
, LONG_HEX
);
5062 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5064 printf (" %2u %3u %lu\n",
5067 (unsigned long) section
->sh_addralign
);
5070 if (do_section_details
)
5071 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5074 if (!do_section_details
)
5076 if (elf_header
.e_machine
== EM_X86_64
5077 || elf_header
.e_machine
== EM_L1OM
5078 || elf_header
.e_machine
== EM_K1OM
)
5079 printf (_("Key to Flags:\n\
5080 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5081 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5082 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5084 printf (_("Key to Flags:\n\
5085 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5086 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5087 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5094 get_group_flags (unsigned int flags
)
5096 static char buff
[32];
5106 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5113 process_section_groups (FILE * file
)
5115 Elf_Internal_Shdr
* section
;
5117 struct group
* group
;
5118 Elf_Internal_Shdr
* symtab_sec
;
5119 Elf_Internal_Shdr
* strtab_sec
;
5120 Elf_Internal_Sym
* symtab
;
5121 unsigned long num_syms
;
5125 /* Don't process section groups unless needed. */
5126 if (!do_unwind
&& !do_section_groups
)
5129 if (elf_header
.e_shnum
== 0)
5131 if (do_section_groups
)
5132 printf (_("\nThere are no sections to group in this file.\n"));
5137 if (section_headers
== NULL
)
5139 error (_("Section headers are not available!\n"));
5140 /* PR 13622: This can happen with a corrupt ELF header. */
5144 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5145 sizeof (struct group
*));
5147 if (section_headers_groups
== NULL
)
5149 error (_("Out of memory\n"));
5153 /* Scan the sections for the group section. */
5155 for (i
= 0, section
= section_headers
;
5156 i
< elf_header
.e_shnum
;
5158 if (section
->sh_type
== SHT_GROUP
)
5161 if (group_count
== 0)
5163 if (do_section_groups
)
5164 printf (_("\nThere are no section groups in this file.\n"));
5169 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5171 if (section_groups
== NULL
)
5173 error (_("Out of memory\n"));
5183 for (i
= 0, section
= section_headers
, group
= section_groups
;
5184 i
< elf_header
.e_shnum
;
5187 if (section
->sh_type
== SHT_GROUP
)
5189 char * name
= SECTION_NAME (section
);
5191 unsigned char * start
;
5192 unsigned char * indices
;
5193 unsigned int entry
, j
, size
;
5194 Elf_Internal_Shdr
* sec
;
5195 Elf_Internal_Sym
* sym
;
5197 /* Get the symbol table. */
5198 if (section
->sh_link
>= elf_header
.e_shnum
5199 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5202 error (_("Bad sh_link in group section `%s'\n"), name
);
5206 if (symtab_sec
!= sec
)
5211 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5216 error (_("Corrupt header in group section `%s'\n"), name
);
5220 if (section
->sh_info
>= num_syms
)
5222 error (_("Bad sh_info in group section `%s'\n"), name
);
5226 sym
= symtab
+ section
->sh_info
;
5228 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5230 if (sym
->st_shndx
== 0
5231 || sym
->st_shndx
>= elf_header
.e_shnum
)
5233 error (_("Bad sh_info in group section `%s'\n"), name
);
5237 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5246 /* Get the string table. */
5247 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5256 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5261 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5262 1, strtab_sec
->sh_size
,
5264 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5266 group_name
= sym
->st_name
< strtab_size
5267 ? strtab
+ sym
->st_name
: _("<corrupt>");
5270 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5271 1, section
->sh_size
,
5277 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5278 entry
= byte_get (indices
, 4);
5281 if (do_section_groups
)
5283 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5284 get_group_flags (entry
), i
, name
, group_name
, size
);
5286 printf (_(" [Index] Name\n"));
5289 group
->group_index
= i
;
5291 for (j
= 0; j
< size
; j
++)
5293 struct group_list
* g
;
5295 entry
= byte_get (indices
, 4);
5298 if (entry
>= elf_header
.e_shnum
)
5300 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5301 entry
, i
, elf_header
.e_shnum
- 1);
5305 if (section_headers_groups
[entry
] != NULL
)
5309 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5311 section_headers_groups
[entry
]->group_index
);
5316 /* Intel C/C++ compiler may put section 0 in a
5317 section group. We just warn it the first time
5318 and ignore it afterwards. */
5319 static int warned
= 0;
5322 error (_("section 0 in group section [%5u]\n"),
5323 section_headers_groups
[entry
]->group_index
);
5329 section_headers_groups
[entry
] = group
;
5331 if (do_section_groups
)
5333 sec
= section_headers
+ entry
;
5334 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5337 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5338 g
->section_index
= entry
;
5339 g
->next
= group
->root
;
5357 /* Data used to display dynamic fixups. */
5359 struct ia64_vms_dynfixup
5361 bfd_vma needed_ident
; /* Library ident number. */
5362 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5363 bfd_vma fixup_needed
; /* Index of the library. */
5364 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5365 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5368 /* Data used to display dynamic relocations. */
5370 struct ia64_vms_dynimgrela
5372 bfd_vma img_rela_cnt
; /* Number of relocations. */
5373 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5376 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5380 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5381 const char *strtab
, unsigned int strtab_sz
)
5383 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5385 const char *lib_name
;
5387 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5388 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5389 _("dynamic section image fixups"));
5393 if (fixup
->needed
< strtab_sz
)
5394 lib_name
= strtab
+ fixup
->needed
;
5397 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5398 (unsigned long) fixup
->needed
);
5401 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5402 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5404 (_("Seg Offset Type SymVec DataType\n"));
5406 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5411 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5412 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5413 type
= BYTE_GET (imfs
[i
].type
);
5414 rtype
= elf_ia64_reloc_type (type
);
5416 printf (" 0x%08x ", type
);
5418 printf (" %-32s ", rtype
);
5419 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5420 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5426 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5429 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5431 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5434 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5435 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5436 _("dynamic section image relocations"));
5440 printf (_("\nImage relocs\n"));
5442 (_("Seg Offset Type Addend Seg Sym Off\n"));
5444 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5449 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5450 printf ("%08" BFD_VMA_FMT
"x ",
5451 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5452 type
= BYTE_GET (imrs
[i
].type
);
5453 rtype
= elf_ia64_reloc_type (type
);
5455 printf ("0x%08x ", type
);
5457 printf ("%-31s ", rtype
);
5458 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5459 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5460 printf ("%08" BFD_VMA_FMT
"x\n",
5461 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5467 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5470 process_ia64_vms_dynamic_relocs (FILE *file
)
5472 struct ia64_vms_dynfixup fixup
;
5473 struct ia64_vms_dynimgrela imgrela
;
5474 Elf_Internal_Dyn
*entry
;
5476 bfd_vma strtab_off
= 0;
5477 bfd_vma strtab_sz
= 0;
5478 char *strtab
= NULL
;
5480 memset (&fixup
, 0, sizeof (fixup
));
5481 memset (&imgrela
, 0, sizeof (imgrela
));
5483 /* Note: the order of the entries is specified by the OpenVMS specs. */
5484 for (entry
= dynamic_section
;
5485 entry
< dynamic_section
+ dynamic_nent
;
5488 switch (entry
->d_tag
)
5490 case DT_IA_64_VMS_STRTAB_OFFSET
:
5491 strtab_off
= entry
->d_un
.d_val
;
5494 strtab_sz
= entry
->d_un
.d_val
;
5496 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5497 1, strtab_sz
, _("dynamic string section"));
5500 case DT_IA_64_VMS_NEEDED_IDENT
:
5501 fixup
.needed_ident
= entry
->d_un
.d_val
;
5504 fixup
.needed
= entry
->d_un
.d_val
;
5506 case DT_IA_64_VMS_FIXUP_NEEDED
:
5507 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5509 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5510 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5512 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5513 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5515 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5518 case DT_IA_64_VMS_IMG_RELA_CNT
:
5519 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5521 case DT_IA_64_VMS_IMG_RELA_OFF
:
5522 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5524 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5544 } dynamic_relocations
[] =
5546 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5547 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5548 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5551 /* Process the reloc section. */
5554 process_relocs (FILE * file
)
5556 unsigned long rel_size
;
5557 unsigned long rel_offset
;
5563 if (do_using_dynamic
)
5567 int has_dynamic_reloc
;
5570 has_dynamic_reloc
= 0;
5572 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5574 is_rela
= dynamic_relocations
[i
].rela
;
5575 name
= dynamic_relocations
[i
].name
;
5576 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5577 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5579 has_dynamic_reloc
|= rel_size
;
5581 if (is_rela
== UNKNOWN
)
5583 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5584 switch (dynamic_info
[DT_PLTREL
])
5598 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5599 name
, rel_offset
, rel_size
);
5601 dump_relocations (file
,
5602 offset_from_vma (file
, rel_offset
, rel_size
),
5604 dynamic_symbols
, num_dynamic_syms
,
5605 dynamic_strings
, dynamic_strings_length
, is_rela
);
5610 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5612 if (! has_dynamic_reloc
)
5613 printf (_("\nThere are no dynamic relocations in this file.\n"));
5617 Elf_Internal_Shdr
* section
;
5621 for (i
= 0, section
= section_headers
;
5622 i
< elf_header
.e_shnum
;
5625 if ( section
->sh_type
!= SHT_RELA
5626 && section
->sh_type
!= SHT_REL
)
5629 rel_offset
= section
->sh_offset
;
5630 rel_size
= section
->sh_size
;
5634 Elf_Internal_Shdr
* strsec
;
5637 printf (_("\nRelocation section "));
5639 if (string_table
== NULL
)
5640 printf ("%d", section
->sh_name
);
5642 printf ("'%s'", SECTION_NAME (section
));
5644 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5645 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5647 is_rela
= section
->sh_type
== SHT_RELA
;
5649 if (section
->sh_link
!= 0
5650 && section
->sh_link
< elf_header
.e_shnum
)
5652 Elf_Internal_Shdr
* symsec
;
5653 Elf_Internal_Sym
* symtab
;
5654 unsigned long nsyms
;
5655 unsigned long strtablen
= 0;
5656 char * strtab
= NULL
;
5658 symsec
= section_headers
+ section
->sh_link
;
5659 if (symsec
->sh_type
!= SHT_SYMTAB
5660 && symsec
->sh_type
!= SHT_DYNSYM
)
5663 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5668 if (symsec
->sh_link
!= 0
5669 && symsec
->sh_link
< elf_header
.e_shnum
)
5671 strsec
= section_headers
+ symsec
->sh_link
;
5673 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5676 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5679 dump_relocations (file
, rel_offset
, rel_size
,
5680 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5686 dump_relocations (file
, rel_offset
, rel_size
,
5687 NULL
, 0, NULL
, 0, is_rela
);
5694 printf (_("\nThere are no relocations in this file.\n"));
5700 /* Process the unwind section. */
5702 #include "unwind-ia64.h"
5704 /* An absolute address consists of a section and an offset. If the
5705 section is NULL, the offset itself is the address, otherwise, the
5706 address equals to LOAD_ADDRESS(section) + offset. */
5710 unsigned short section
;
5714 #define ABSADDR(a) \
5716 ? section_headers [(a).section].sh_addr + (a).offset \
5719 struct ia64_unw_table_entry
5721 struct absaddr start
;
5723 struct absaddr info
;
5726 struct ia64_unw_aux_info
5729 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5730 unsigned long table_len
; /* Length of unwind table. */
5731 unsigned char * info
; /* Unwind info. */
5732 unsigned long info_size
; /* Size of unwind info. */
5733 bfd_vma info_addr
; /* starting address of unwind info. */
5734 bfd_vma seg_base
; /* Starting address of segment. */
5735 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5736 unsigned long nsyms
; /* Number of symbols. */
5737 char * strtab
; /* The string table. */
5738 unsigned long strtab_size
; /* Size of string table. */
5742 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5743 unsigned long nsyms
,
5744 const char * strtab
,
5745 unsigned long strtab_size
,
5746 struct absaddr addr
,
5747 const char ** symname
,
5750 bfd_vma dist
= 0x100000;
5751 Elf_Internal_Sym
* sym
;
5752 Elf_Internal_Sym
* best
= NULL
;
5755 REMOVE_ARCH_BITS (addr
.offset
);
5757 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5759 bfd_vma value
= sym
->st_value
;
5761 REMOVE_ARCH_BITS (value
);
5763 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5764 && sym
->st_name
!= 0
5765 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5766 && addr
.offset
>= value
5767 && addr
.offset
- value
< dist
)
5770 dist
= addr
.offset
- value
;
5778 *symname
= (best
->st_name
>= strtab_size
5779 ? _("<corrupt>") : strtab
+ best
->st_name
);
5785 *offset
= addr
.offset
;
5789 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5791 struct ia64_unw_table_entry
* tp
;
5794 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5798 const unsigned char * dp
;
5799 const unsigned char * head
;
5800 const char * procname
;
5802 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5803 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5805 fputs ("\n<", stdout
);
5809 fputs (procname
, stdout
);
5812 printf ("+%lx", (unsigned long) offset
);
5815 fputs (">: [", stdout
);
5816 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5817 fputc ('-', stdout
);
5818 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5819 printf ("], info at +0x%lx\n",
5820 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5822 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5823 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5825 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5826 (unsigned) UNW_VER (stamp
),
5827 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5828 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5829 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5830 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5832 if (UNW_VER (stamp
) != 1)
5834 printf (_("\tUnknown version.\n"));
5839 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5840 dp
= unw_decode (dp
, in_body
, & in_body
);
5845 slurp_ia64_unwind_table (FILE * file
,
5846 struct ia64_unw_aux_info
* aux
,
5847 Elf_Internal_Shdr
* sec
)
5849 unsigned long size
, nrelas
, i
;
5850 Elf_Internal_Phdr
* seg
;
5851 struct ia64_unw_table_entry
* tep
;
5852 Elf_Internal_Shdr
* relsec
;
5853 Elf_Internal_Rela
* rela
;
5854 Elf_Internal_Rela
* rp
;
5855 unsigned char * table
;
5857 Elf_Internal_Sym
* sym
;
5858 const char * relname
;
5860 /* First, find the starting address of the segment that includes
5863 if (elf_header
.e_phnum
)
5865 if (! get_program_headers (file
))
5868 for (seg
= program_headers
;
5869 seg
< program_headers
+ elf_header
.e_phnum
;
5872 if (seg
->p_type
!= PT_LOAD
)
5875 if (sec
->sh_addr
>= seg
->p_vaddr
5876 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5878 aux
->seg_base
= seg
->p_vaddr
;
5884 /* Second, build the unwind table from the contents of the unwind section: */
5885 size
= sec
->sh_size
;
5886 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5891 aux
->table
= (struct ia64_unw_table_entry
*)
5892 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5894 for (tp
= table
; tp
< table
+ size
; ++tep
)
5896 tep
->start
.section
= SHN_UNDEF
;
5897 tep
->end
.section
= SHN_UNDEF
;
5898 tep
->info
.section
= SHN_UNDEF
;
5899 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5900 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5901 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5902 tep
->start
.offset
+= aux
->seg_base
;
5903 tep
->end
.offset
+= aux
->seg_base
;
5904 tep
->info
.offset
+= aux
->seg_base
;
5908 /* Third, apply any relocations to the unwind table: */
5909 for (relsec
= section_headers
;
5910 relsec
< section_headers
+ elf_header
.e_shnum
;
5913 if (relsec
->sh_type
!= SHT_RELA
5914 || relsec
->sh_info
>= elf_header
.e_shnum
5915 || section_headers
+ relsec
->sh_info
!= sec
)
5918 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5922 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5924 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5925 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5927 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5929 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5933 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5935 switch (rp
->r_offset
/eh_addr_size
% 3)
5938 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5939 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5942 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5943 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5946 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5947 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5957 aux
->table_len
= size
/ (3 * eh_addr_size
);
5962 ia64_process_unwind (FILE * file
)
5964 Elf_Internal_Shdr
* sec
;
5965 Elf_Internal_Shdr
* unwsec
= NULL
;
5966 Elf_Internal_Shdr
* strsec
;
5967 unsigned long i
, unwcount
= 0, unwstart
= 0;
5968 struct ia64_unw_aux_info aux
;
5970 memset (& aux
, 0, sizeof (aux
));
5972 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5974 if (sec
->sh_type
== SHT_SYMTAB
5975 && sec
->sh_link
< elf_header
.e_shnum
)
5977 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
5979 strsec
= section_headers
+ sec
->sh_link
;
5980 assert (aux
.strtab
== NULL
);
5981 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5984 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5986 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5991 printf (_("\nThere are no unwind sections in this file.\n"));
5993 while (unwcount
-- > 0)
5998 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5999 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6000 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6007 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6009 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6011 /* We need to find which section group it is in. */
6012 struct group_list
* g
= section_headers_groups
[i
]->root
;
6014 for (; g
!= NULL
; g
= g
->next
)
6016 sec
= section_headers
+ g
->section_index
;
6018 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6023 i
= elf_header
.e_shnum
;
6025 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6027 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6028 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6029 suffix
= SECTION_NAME (unwsec
) + len
;
6030 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6032 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6033 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6038 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6039 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6040 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6041 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6043 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6044 suffix
= SECTION_NAME (unwsec
) + len
;
6045 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6047 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6048 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6052 if (i
== elf_header
.e_shnum
)
6054 printf (_("\nCould not find unwind info section for "));
6056 if (string_table
== NULL
)
6057 printf ("%d", unwsec
->sh_name
);
6059 printf (_("'%s'"), SECTION_NAME (unwsec
));
6063 aux
.info_addr
= sec
->sh_addr
;
6064 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6067 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6069 printf (_("\nUnwind section "));
6071 if (string_table
== NULL
)
6072 printf ("%d", unwsec
->sh_name
);
6074 printf (_("'%s'"), SECTION_NAME (unwsec
));
6076 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6077 (unsigned long) unwsec
->sh_offset
,
6078 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6080 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6082 if (aux
.table_len
> 0)
6083 dump_ia64_unwind (& aux
);
6086 free ((char *) aux
.table
);
6088 free ((char *) aux
.info
);
6097 free ((char *) aux
.strtab
);
6100 struct hppa_unw_table_entry
6102 struct absaddr start
;
6104 unsigned int Cannot_unwind
:1; /* 0 */
6105 unsigned int Millicode
:1; /* 1 */
6106 unsigned int Millicode_save_sr0
:1; /* 2 */
6107 unsigned int Region_description
:2; /* 3..4 */
6108 unsigned int reserved1
:1; /* 5 */
6109 unsigned int Entry_SR
:1; /* 6 */
6110 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6111 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6112 unsigned int Args_stored
:1; /* 16 */
6113 unsigned int Variable_Frame
:1; /* 17 */
6114 unsigned int Separate_Package_Body
:1; /* 18 */
6115 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6116 unsigned int Stack_Overflow_Check
:1; /* 20 */
6117 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6118 unsigned int Ada_Region
:1; /* 22 */
6119 unsigned int cxx_info
:1; /* 23 */
6120 unsigned int cxx_try_catch
:1; /* 24 */
6121 unsigned int sched_entry_seq
:1; /* 25 */
6122 unsigned int reserved2
:1; /* 26 */
6123 unsigned int Save_SP
:1; /* 27 */
6124 unsigned int Save_RP
:1; /* 28 */
6125 unsigned int Save_MRP_in_frame
:1; /* 29 */
6126 unsigned int extn_ptr_defined
:1; /* 30 */
6127 unsigned int Cleanup_defined
:1; /* 31 */
6129 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6130 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6131 unsigned int Large_frame
:1; /* 2 */
6132 unsigned int Pseudo_SP_Set
:1; /* 3 */
6133 unsigned int reserved4
:1; /* 4 */
6134 unsigned int Total_frame_size
:27; /* 5..31 */
6137 struct hppa_unw_aux_info
6139 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6140 unsigned long table_len
; /* Length of unwind table. */
6141 bfd_vma seg_base
; /* Starting address of segment. */
6142 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6143 unsigned long nsyms
; /* Number of symbols. */
6144 char * strtab
; /* The string table. */
6145 unsigned long strtab_size
; /* Size of string table. */
6149 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6151 struct hppa_unw_table_entry
* tp
;
6153 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6156 const char * procname
;
6158 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6159 aux
->strtab_size
, tp
->start
, &procname
,
6162 fputs ("\n<", stdout
);
6166 fputs (procname
, stdout
);
6169 printf ("+%lx", (unsigned long) offset
);
6172 fputs (">: [", stdout
);
6173 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6174 fputc ('-', stdout
);
6175 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6178 #define PF(_m) if (tp->_m) printf (#_m " ");
6179 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6182 PF(Millicode_save_sr0
);
6183 /* PV(Region_description); */
6189 PF(Separate_Package_Body
);
6190 PF(Frame_Extension_Millicode
);
6191 PF(Stack_Overflow_Check
);
6192 PF(Two_Instruction_SP_Increment
);
6196 PF(sched_entry_seq
);
6199 PF(Save_MRP_in_frame
);
6200 PF(extn_ptr_defined
);
6201 PF(Cleanup_defined
);
6202 PF(MPE_XL_interrupt_marker
);
6203 PF(HP_UX_interrupt_marker
);
6206 PV(Total_frame_size
);
6215 slurp_hppa_unwind_table (FILE * file
,
6216 struct hppa_unw_aux_info
* aux
,
6217 Elf_Internal_Shdr
* sec
)
6219 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6220 Elf_Internal_Phdr
* seg
;
6221 struct hppa_unw_table_entry
* tep
;
6222 Elf_Internal_Shdr
* relsec
;
6223 Elf_Internal_Rela
* rela
;
6224 Elf_Internal_Rela
* rp
;
6225 unsigned char * table
;
6227 Elf_Internal_Sym
* sym
;
6228 const char * relname
;
6230 /* First, find the starting address of the segment that includes
6233 if (elf_header
.e_phnum
)
6235 if (! get_program_headers (file
))
6238 for (seg
= program_headers
;
6239 seg
< program_headers
+ elf_header
.e_phnum
;
6242 if (seg
->p_type
!= PT_LOAD
)
6245 if (sec
->sh_addr
>= seg
->p_vaddr
6246 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6248 aux
->seg_base
= seg
->p_vaddr
;
6254 /* Second, build the unwind table from the contents of the unwind
6256 size
= sec
->sh_size
;
6257 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6263 nentries
= size
/ unw_ent_size
;
6264 size
= unw_ent_size
* nentries
;
6266 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6267 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6269 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6271 unsigned int tmp1
, tmp2
;
6273 tep
->start
.section
= SHN_UNDEF
;
6274 tep
->end
.section
= SHN_UNDEF
;
6276 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6277 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6278 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6279 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6281 tep
->start
.offset
+= aux
->seg_base
;
6282 tep
->end
.offset
+= aux
->seg_base
;
6284 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6285 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6286 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6287 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6288 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6289 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6290 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6291 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6292 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6293 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6294 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6295 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6296 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6297 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6298 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6299 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6300 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6301 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6302 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6303 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6304 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6305 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6306 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6307 tep
->Cleanup_defined
= tmp1
& 0x1;
6309 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6310 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6311 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6312 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6313 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6314 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6318 /* Third, apply any relocations to the unwind table. */
6319 for (relsec
= section_headers
;
6320 relsec
< section_headers
+ elf_header
.e_shnum
;
6323 if (relsec
->sh_type
!= SHT_RELA
6324 || relsec
->sh_info
>= elf_header
.e_shnum
6325 || section_headers
+ relsec
->sh_info
!= sec
)
6328 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6332 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6334 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6335 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6337 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6338 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6340 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6344 i
= rp
->r_offset
/ unw_ent_size
;
6346 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6349 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6350 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6353 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6354 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6364 aux
->table_len
= nentries
;
6370 hppa_process_unwind (FILE * file
)
6372 struct hppa_unw_aux_info aux
;
6373 Elf_Internal_Shdr
* unwsec
= NULL
;
6374 Elf_Internal_Shdr
* strsec
;
6375 Elf_Internal_Shdr
* sec
;
6378 if (string_table
== NULL
)
6381 memset (& aux
, 0, sizeof (aux
));
6383 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6385 if (sec
->sh_type
== SHT_SYMTAB
6386 && sec
->sh_link
< elf_header
.e_shnum
)
6388 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6390 strsec
= section_headers
+ sec
->sh_link
;
6391 assert (aux
.strtab
== NULL
);
6392 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6395 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6397 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6402 printf (_("\nThere are no unwind sections in this file.\n"));
6404 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6406 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6408 printf (_("\nUnwind section "));
6409 printf (_("'%s'"), SECTION_NAME (sec
));
6411 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6412 (unsigned long) sec
->sh_offset
,
6413 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6415 slurp_hppa_unwind_table (file
, &aux
, sec
);
6416 if (aux
.table_len
> 0)
6417 dump_hppa_unwind (&aux
);
6420 free ((char *) aux
.table
);
6428 free ((char *) aux
.strtab
);
6433 unsigned char * data
; /* The unwind data. */
6434 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6435 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6436 unsigned long nrelas
; /* The number of relocations. */
6437 unsigned int rel_type
; /* REL or RELA ? */
6438 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6441 struct arm_unw_aux_info
6443 FILE * file
; /* The file containing the unwind sections. */
6444 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6445 unsigned long nsyms
; /* Number of symbols. */
6446 char * strtab
; /* The file's string table. */
6447 unsigned long strtab_size
; /* Size of string table. */
6451 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6452 bfd_vma fn
, struct absaddr addr
)
6454 const char *procname
;
6457 if (addr
.section
== SHN_UNDEF
)
6460 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6461 aux
->strtab_size
, addr
, &procname
,
6464 print_vma (fn
, PREFIX_HEX
);
6468 fputs (" <", stdout
);
6469 fputs (procname
, stdout
);
6472 printf ("+0x%lx", (unsigned long) sym_offset
);
6473 fputc ('>', stdout
);
6480 arm_free_section (struct arm_section
*arm_sec
)
6482 if (arm_sec
->data
!= NULL
)
6483 free (arm_sec
->data
);
6485 if (arm_sec
->rela
!= NULL
)
6486 free (arm_sec
->rela
);
6489 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6490 cached section and install SEC instead.
6491 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6492 and return its valued in * WORDP, relocating if necessary.
6493 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6494 relocation's offset in ADDR.
6495 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6496 into the string table of the symbol associated with the reloc. If no
6497 reloc was applied store -1 there.
6498 5) Return TRUE upon success, FALSE otherwise. */
6501 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6502 struct arm_section
* arm_sec
,
6503 Elf_Internal_Shdr
* sec
,
6504 bfd_vma word_offset
,
6505 unsigned int * wordp
,
6506 struct absaddr
* addr
,
6509 Elf_Internal_Rela
*rp
;
6510 Elf_Internal_Sym
*sym
;
6511 const char * relname
;
6513 bfd_boolean wrapped
;
6515 addr
->section
= SHN_UNDEF
;
6518 if (sym_name
!= NULL
)
6519 *sym_name
= (bfd_vma
) -1;
6521 /* If necessary, update the section cache. */
6522 if (sec
!= arm_sec
->sec
)
6524 Elf_Internal_Shdr
*relsec
;
6526 arm_free_section (arm_sec
);
6529 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6530 sec
->sh_size
, _("unwind data"));
6531 arm_sec
->rela
= NULL
;
6532 arm_sec
->nrelas
= 0;
6534 for (relsec
= section_headers
;
6535 relsec
< section_headers
+ elf_header
.e_shnum
;
6538 if (relsec
->sh_info
>= elf_header
.e_shnum
6539 || section_headers
+ relsec
->sh_info
!= sec
)
6542 arm_sec
->rel_type
= relsec
->sh_type
;
6543 if (relsec
->sh_type
== SHT_REL
)
6545 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6547 & arm_sec
->rela
, & arm_sec
->nrelas
))
6551 else if (relsec
->sh_type
== SHT_RELA
)
6553 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6555 & arm_sec
->rela
, & arm_sec
->nrelas
))
6560 warn (_("unexpected relocation type (%d) for section %d"),
6561 relsec
->sh_type
, relsec
->sh_info
);
6564 arm_sec
->next_rela
= arm_sec
->rela
;
6567 /* If there is no unwind data we can do nothing. */
6568 if (arm_sec
->data
== NULL
)
6571 /* Get the word at the required offset. */
6572 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6574 /* Look through the relocs to find the one that applies to the provided offset. */
6576 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6578 bfd_vma prelval
, offset
;
6580 if (rp
->r_offset
> word_offset
&& !wrapped
)
6585 if (rp
->r_offset
> word_offset
)
6588 if (rp
->r_offset
& 3)
6590 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6591 (unsigned long) rp
->r_offset
);
6595 if (rp
->r_offset
< word_offset
)
6598 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6600 if (arm_sec
->rel_type
== SHT_REL
)
6602 offset
= word
& 0x7fffffff;
6603 if (offset
& 0x40000000)
6604 offset
|= ~ (bfd_vma
) 0x7fffffff;
6606 else if (arm_sec
->rel_type
== SHT_RELA
)
6607 offset
= rp
->r_addend
;
6611 offset
+= sym
->st_value
;
6612 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6614 /* Check that we are processing the expected reloc type. */
6615 if (elf_header
.e_machine
== EM_ARM
)
6617 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6619 if (streq (relname
, "R_ARM_NONE"))
6622 if (! streq (relname
, "R_ARM_PREL31"))
6624 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6628 else if (elf_header
.e_machine
== EM_TI_C6000
)
6630 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6632 if (streq (relname
, "R_C6000_NONE"))
6635 if (! streq (relname
, "R_C6000_PREL31"))
6637 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6644 /* This function currently only supports ARM and TI unwinders. */
6647 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6648 addr
->section
= sym
->st_shndx
;
6649 addr
->offset
= offset
;
6651 * sym_name
= sym
->st_name
;
6656 arm_sec
->next_rela
= rp
;
6661 static const char *tic6x_unwind_regnames
[16] =
6663 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6664 "A14", "A13", "A12", "A11", "A10",
6665 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6669 decode_tic6x_unwind_regmask (unsigned int mask
)
6673 for (i
= 12; mask
; mask
>>= 1, i
--)
6677 fputs (tic6x_unwind_regnames
[i
], stdout
);
6679 fputs (", ", stdout
);
6685 if (remaining == 0 && more_words) \
6688 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6689 data_offset, & word, & addr, NULL)) \
6695 #define GET_OP(OP) \
6700 (OP) = word >> 24; \
6705 printf (_("[Truncated opcode]\n")); \
6708 printf ("0x%02x ", OP)
6711 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6712 unsigned int word
, unsigned int remaining
,
6713 unsigned int more_words
,
6714 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6715 struct arm_section
*data_arm_sec
)
6717 struct absaddr addr
;
6719 /* Decode the unwinding instructions. */
6722 unsigned int op
, op2
;
6731 printf (" 0x%02x ", op
);
6733 if ((op
& 0xc0) == 0x00)
6735 int offset
= ((op
& 0x3f) << 2) + 4;
6737 printf (" vsp = vsp + %d", offset
);
6739 else if ((op
& 0xc0) == 0x40)
6741 int offset
= ((op
& 0x3f) << 2) + 4;
6743 printf (" vsp = vsp - %d", offset
);
6745 else if ((op
& 0xf0) == 0x80)
6748 if (op
== 0x80 && op2
== 0)
6749 printf (_("Refuse to unwind"));
6752 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6757 for (i
= 0; i
< 12; i
++)
6758 if (mask
& (1 << i
))
6764 printf ("r%d", 4 + i
);
6769 else if ((op
& 0xf0) == 0x90)
6771 if (op
== 0x9d || op
== 0x9f)
6772 printf (_(" [Reserved]"));
6774 printf (" vsp = r%d", op
& 0x0f);
6776 else if ((op
& 0xf0) == 0xa0)
6778 int end
= 4 + (op
& 0x07);
6783 for (i
= 4; i
<= end
; i
++)
6799 else if (op
== 0xb0)
6800 printf (_(" finish"));
6801 else if (op
== 0xb1)
6804 if (op2
== 0 || (op2
& 0xf0) != 0)
6805 printf (_("[Spare]"));
6808 unsigned int mask
= op2
& 0x0f;
6813 for (i
= 0; i
< 12; i
++)
6814 if (mask
& (1 << i
))
6825 else if (op
== 0xb2)
6827 unsigned char buf
[9];
6828 unsigned int i
, len
;
6829 unsigned long offset
;
6831 for (i
= 0; i
< sizeof (buf
); i
++)
6834 if ((buf
[i
] & 0x80) == 0)
6837 assert (i
< sizeof (buf
));
6838 offset
= read_uleb128 (buf
, &len
);
6839 assert (len
== i
+ 1);
6840 offset
= offset
* 4 + 0x204;
6841 printf ("vsp = vsp + %ld", offset
);
6843 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6845 unsigned int first
, last
;
6852 printf ("pop {D%d", first
);
6854 printf ("-D%d", first
+ last
);
6857 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6859 unsigned int count
= op
& 0x07;
6863 printf ("-D%d", 8 + count
);
6866 else if (op
>= 0xc0 && op
<= 0xc5)
6868 unsigned int count
= op
& 0x07;
6870 printf (" pop {wR10");
6872 printf ("-wR%d", 10 + count
);
6875 else if (op
== 0xc6)
6877 unsigned int first
, last
;
6882 printf ("pop {wR%d", first
);
6884 printf ("-wR%d", first
+ last
);
6887 else if (op
== 0xc7)
6890 if (op2
== 0 || (op2
& 0xf0) != 0)
6891 printf (_("[Spare]"));
6894 unsigned int mask
= op2
& 0x0f;
6899 for (i
= 0; i
< 4; i
++)
6900 if (mask
& (1 << i
))
6906 printf ("wCGR%d", i
);
6912 printf (_(" [unsupported opcode]"));
6918 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6919 unsigned int word
, unsigned int remaining
,
6920 unsigned int more_words
,
6921 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6922 struct arm_section
*data_arm_sec
)
6924 struct absaddr addr
;
6926 /* Decode the unwinding instructions. */
6929 unsigned int op
, op2
;
6938 printf (" 0x%02x ", op
);
6940 if ((op
& 0xc0) == 0x00)
6942 int offset
= ((op
& 0x3f) << 3) + 8;
6943 printf (" sp = sp + %d", offset
);
6945 else if ((op
& 0xc0) == 0x80)
6948 if (op
== 0x80 && op2
== 0)
6949 printf (_("Refuse to unwind"));
6952 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6954 printf ("pop compact {");
6958 decode_tic6x_unwind_regmask (mask
);
6962 else if ((op
& 0xf0) == 0xc0)
6970 unsigned int offset
;
6974 /* Scan entire instruction first so that GET_OP output is not
6975 interleaved with disassembly. */
6977 for (i
= 0; nregs
< (op
& 0xf); i
++)
6983 regpos
[nregs
].offset
= i
* 2;
6984 regpos
[nregs
].reg
= reg
;
6991 regpos
[nregs
].offset
= i
* 2 + 1;
6992 regpos
[nregs
].reg
= reg
;
6997 printf (_("pop frame {"));
6999 for (i
= i
* 2; i
> 0; i
--)
7001 if (regpos
[reg
].offset
== i
- 1)
7003 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7010 fputs (name
, stdout
);
7017 else if (op
== 0xd0)
7018 printf (" MOV FP, SP");
7019 else if (op
== 0xd1)
7020 printf (" __c6xabi_pop_rts");
7021 else if (op
== 0xd2)
7023 unsigned char buf
[9];
7024 unsigned int i
, len
;
7025 unsigned long offset
;
7027 for (i
= 0; i
< sizeof (buf
); i
++)
7030 if ((buf
[i
] & 0x80) == 0)
7033 assert (i
< sizeof (buf
));
7034 offset
= read_uleb128 (buf
, &len
);
7035 assert (len
== i
+ 1);
7036 offset
= offset
* 8 + 0x408;
7037 printf (_("sp = sp + %ld"), offset
);
7039 else if ((op
& 0xf0) == 0xe0)
7041 if ((op
& 0x0f) == 7)
7044 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7048 printf (_(" [unsupported opcode]"));
7055 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7059 offset
= word
& 0x7fffffff;
7060 if (offset
& 0x40000000)
7061 offset
|= ~ (bfd_vma
) 0x7fffffff;
7063 if (elf_header
.e_machine
== EM_TI_C6000
)
7066 return offset
+ where
;
7070 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7072 unsigned int remaining
,
7073 bfd_vma data_offset
,
7074 Elf_Internal_Shdr
* data_sec
,
7075 struct arm_section
* data_arm_sec
)
7078 unsigned int more_words
= 0;
7079 struct absaddr addr
;
7080 bfd_vma sym_name
= (bfd_vma
) -1;
7084 /* Fetch the first word.
7085 Note - when decoding an object file the address extracted
7086 here will always be 0. So we also pass in the sym_name
7087 parameter so that we can find the symbol associated with
7088 the personality routine. */
7089 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7090 & word
, & addr
, & sym_name
))
7096 if ((word
& 0x80000000) == 0)
7098 /* Expand prel31 for personality routine. */
7100 const char *procname
;
7102 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7103 printf (_(" Personality routine: "));
7105 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7106 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7108 procname
= aux
->strtab
+ sym_name
;
7109 print_vma (fn
, PREFIX_HEX
);
7112 fputs (" <", stdout
);
7113 fputs (procname
, stdout
);
7114 fputc ('>', stdout
);
7118 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7119 fputc ('\n', stdout
);
7121 /* The GCC personality routines use the standard compact
7122 encoding, starting with one byte giving the number of
7124 if (procname
!= NULL
7125 && (const_strneq (procname
, "__gcc_personality_v0")
7126 || const_strneq (procname
, "__gxx_personality_v0")
7127 || const_strneq (procname
, "__gcj_personality_v0")
7128 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7135 printf (_(" [Truncated data]\n"));
7138 more_words
= word
>> 24;
7148 /* ARM EHABI Section 6.3:
7150 An exception-handling table entry for the compact model looks like:
7154 1 0 index Data for personalityRoutine[index] */
7156 if (elf_header
.e_machine
== EM_ARM
7157 && (word
& 0x70000000))
7158 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7160 per_index
= (word
>> 24) & 0x7f;
7161 printf (_(" Compact model index: %d\n"), per_index
);
7168 else if (per_index
< 3)
7170 more_words
= (word
>> 16) & 0xff;
7176 switch (elf_header
.e_machine
)
7181 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7182 data_offset
, data_sec
, data_arm_sec
);
7186 warn (_("Unknown ARM compact model index encountered\n"));
7187 printf (_(" [reserved]\n"));
7194 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7195 data_offset
, data_sec
, data_arm_sec
);
7197 else if (per_index
< 5)
7199 if (((word
>> 17) & 0x7f) == 0x7f)
7200 printf (_(" Restore stack from frame pointer\n"));
7202 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7203 printf (_(" Registers restored: "));
7205 printf (" (compact) ");
7206 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7208 printf (_(" Return register: %s\n"),
7209 tic6x_unwind_regnames
[word
& 0xf]);
7212 printf (_(" [reserved (%d)]\n"), per_index
);
7216 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7217 elf_header
.e_machine
);
7220 /* Decode the descriptors. Not implemented. */
7224 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7226 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7227 unsigned int i
, exidx_len
;
7229 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7230 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7231 exidx_len
= exidx_sec
->sh_size
/ 8;
7233 for (i
= 0; i
< exidx_len
; i
++)
7235 unsigned int exidx_fn
, exidx_entry
;
7236 struct absaddr fn_addr
, entry_addr
;
7239 fputc ('\n', stdout
);
7241 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7242 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7243 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7244 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7246 arm_free_section (& exidx_arm_sec
);
7247 arm_free_section (& extab_arm_sec
);
7251 /* ARM EHABI, Section 5:
7252 An index table entry consists of 2 words.
7253 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7254 if (exidx_fn
& 0x80000000)
7255 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7257 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7259 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7260 fputs (": ", stdout
);
7262 if (exidx_entry
== 1)
7264 print_vma (exidx_entry
, PREFIX_HEX
);
7265 fputs (" [cantunwind]\n", stdout
);
7267 else if (exidx_entry
& 0x80000000)
7269 print_vma (exidx_entry
, PREFIX_HEX
);
7270 fputc ('\n', stdout
);
7271 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7275 bfd_vma table
, table_offset
= 0;
7276 Elf_Internal_Shdr
*table_sec
;
7278 fputs ("@", stdout
);
7279 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7280 print_vma (table
, PREFIX_HEX
);
7283 /* Locate the matching .ARM.extab. */
7284 if (entry_addr
.section
!= SHN_UNDEF
7285 && entry_addr
.section
< elf_header
.e_shnum
)
7287 table_sec
= section_headers
+ entry_addr
.section
;
7288 table_offset
= entry_addr
.offset
;
7292 table_sec
= find_section_by_address (table
);
7293 if (table_sec
!= NULL
)
7294 table_offset
= table
- table_sec
->sh_addr
;
7296 if (table_sec
== NULL
)
7298 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7299 (unsigned long) table
);
7302 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7309 arm_free_section (&exidx_arm_sec
);
7310 arm_free_section (&extab_arm_sec
);
7313 /* Used for both ARM and C6X unwinding tables. */
7316 arm_process_unwind (FILE *file
)
7318 struct arm_unw_aux_info aux
;
7319 Elf_Internal_Shdr
*unwsec
= NULL
;
7320 Elf_Internal_Shdr
*strsec
;
7321 Elf_Internal_Shdr
*sec
;
7323 unsigned int sec_type
;
7325 switch (elf_header
.e_machine
)
7328 sec_type
= SHT_ARM_EXIDX
;
7332 sec_type
= SHT_C6000_UNWIND
;
7336 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7337 elf_header
.e_machine
);
7341 if (string_table
== NULL
)
7344 memset (& aux
, 0, sizeof (aux
));
7347 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7349 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7351 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7353 strsec
= section_headers
+ sec
->sh_link
;
7354 assert (aux
.strtab
== NULL
);
7355 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7356 1, strsec
->sh_size
, _("string table"));
7357 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7359 else if (sec
->sh_type
== sec_type
)
7364 printf (_("\nThere are no unwind sections in this file.\n"));
7366 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7368 if (sec
->sh_type
== sec_type
)
7370 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7372 (unsigned long) sec
->sh_offset
,
7373 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7375 dump_arm_unwind (&aux
, sec
);
7382 free ((char *) aux
.strtab
);
7386 process_unwind (FILE * file
)
7388 struct unwind_handler
7391 void (* handler
)(FILE *);
7394 { EM_ARM
, arm_process_unwind
},
7395 { EM_IA_64
, ia64_process_unwind
},
7396 { EM_PARISC
, hppa_process_unwind
},
7397 { EM_TI_C6000
, arm_process_unwind
},
7405 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7406 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7407 return handlers
[i
].handler (file
);
7409 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7410 get_machine_name (elf_header
.e_machine
));
7414 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7416 switch (entry
->d_tag
)
7419 if (entry
->d_un
.d_val
== 0)
7423 static const char * opts
[] =
7425 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7426 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7427 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7428 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7434 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7435 if (entry
->d_un
.d_val
& (1 << cnt
))
7437 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7443 case DT_MIPS_IVERSION
:
7444 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7445 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7447 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7450 case DT_MIPS_TIME_STAMP
:
7455 time_t atime
= entry
->d_un
.d_val
;
7456 tmp
= gmtime (&atime
);
7457 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7458 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7459 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7460 printf (_("Time Stamp: %s"), timebuf
);
7464 case DT_MIPS_RLD_VERSION
:
7465 case DT_MIPS_LOCAL_GOTNO
:
7466 case DT_MIPS_CONFLICTNO
:
7467 case DT_MIPS_LIBLISTNO
:
7468 case DT_MIPS_SYMTABNO
:
7469 case DT_MIPS_UNREFEXTNO
:
7470 case DT_MIPS_HIPAGENO
:
7471 case DT_MIPS_DELTA_CLASS_NO
:
7472 case DT_MIPS_DELTA_INSTANCE_NO
:
7473 case DT_MIPS_DELTA_RELOC_NO
:
7474 case DT_MIPS_DELTA_SYM_NO
:
7475 case DT_MIPS_DELTA_CLASSSYM_NO
:
7476 case DT_MIPS_COMPACT_SIZE
:
7477 print_vma (entry
->d_un
.d_ptr
, DEC
);
7481 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7487 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7489 switch (entry
->d_tag
)
7491 case DT_HP_DLD_FLAGS
:
7500 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7501 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7502 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7503 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7504 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7505 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7506 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7507 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7508 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7509 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7510 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7511 { DT_HP_GST
, "HP_GST" },
7512 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7513 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7514 { DT_HP_NODELETE
, "HP_NODELETE" },
7515 { DT_HP_GROUP
, "HP_GROUP" },
7516 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7520 bfd_vma val
= entry
->d_un
.d_val
;
7522 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7523 if (val
& flags
[cnt
].bit
)
7527 fputs (flags
[cnt
].str
, stdout
);
7529 val
^= flags
[cnt
].bit
;
7532 if (val
!= 0 || first
)
7536 print_vma (val
, HEX
);
7542 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7550 /* VMS vs Unix time offset and factor. */
7552 #define VMS_EPOCH_OFFSET 35067168000000000LL
7553 #define VMS_GRANULARITY_FACTOR 10000000
7555 /* Display a VMS time in a human readable format. */
7558 print_vms_time (bfd_int64_t vmstime
)
7563 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7564 tm
= gmtime (&unxtime
);
7565 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7566 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7567 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7572 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7574 switch (entry
->d_tag
)
7576 case DT_IA_64_PLT_RESERVE
:
7577 /* First 3 slots reserved. */
7578 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7580 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7583 case DT_IA_64_VMS_LINKTIME
:
7585 print_vms_time (entry
->d_un
.d_val
);
7589 case DT_IA_64_VMS_LNKFLAGS
:
7590 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7591 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7592 printf (" CALL_DEBUG");
7593 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7594 printf (" NOP0BUFS");
7595 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7596 printf (" P0IMAGE");
7597 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7598 printf (" MKTHREADS");
7599 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7600 printf (" UPCALLS");
7601 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7603 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7604 printf (" INITIALIZE");
7605 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7607 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7608 printf (" EXE_INIT");
7609 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7610 printf (" TBK_IN_IMG");
7611 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7612 printf (" DBG_IN_IMG");
7613 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7614 printf (" TBK_IN_DSF");
7615 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7616 printf (" DBG_IN_DSF");
7617 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7618 printf (" SIGNATURES");
7619 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7620 printf (" REL_SEG_OFF");
7624 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7631 get_32bit_dynamic_section (FILE * file
)
7633 Elf32_External_Dyn
* edyn
;
7634 Elf32_External_Dyn
* ext
;
7635 Elf_Internal_Dyn
* entry
;
7637 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7638 dynamic_size
, _("dynamic section"));
7642 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7643 might not have the luxury of section headers. Look for the DT_NULL
7644 terminator to determine the number of entries. */
7645 for (ext
= edyn
, dynamic_nent
= 0;
7646 (char *) ext
< (char *) edyn
+ dynamic_size
;
7650 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7654 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7656 if (dynamic_section
== NULL
)
7658 error (_("Out of memory\n"));
7663 for (ext
= edyn
, entry
= dynamic_section
;
7664 entry
< dynamic_section
+ dynamic_nent
;
7667 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7668 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7677 get_64bit_dynamic_section (FILE * file
)
7679 Elf64_External_Dyn
* edyn
;
7680 Elf64_External_Dyn
* ext
;
7681 Elf_Internal_Dyn
* entry
;
7683 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7684 dynamic_size
, _("dynamic section"));
7688 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7689 might not have the luxury of section headers. Look for the DT_NULL
7690 terminator to determine the number of entries. */
7691 for (ext
= edyn
, dynamic_nent
= 0;
7692 (char *) ext
< (char *) edyn
+ dynamic_size
;
7696 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7700 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7702 if (dynamic_section
== NULL
)
7704 error (_("Out of memory\n"));
7709 for (ext
= edyn
, entry
= dynamic_section
;
7710 entry
< dynamic_section
+ dynamic_nent
;
7713 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7714 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7723 print_dynamic_flags (bfd_vma flags
)
7731 flag
= flags
& - flags
;
7741 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7742 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7743 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7744 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7745 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7746 default: fputs (_("unknown"), stdout
); break;
7752 /* Parse and display the contents of the dynamic section. */
7755 process_dynamic_section (FILE * file
)
7757 Elf_Internal_Dyn
* entry
;
7759 if (dynamic_size
== 0)
7762 printf (_("\nThere is no dynamic section in this file.\n"));
7769 if (! get_32bit_dynamic_section (file
))
7772 else if (! get_64bit_dynamic_section (file
))
7775 /* Find the appropriate symbol table. */
7776 if (dynamic_symbols
== NULL
)
7778 for (entry
= dynamic_section
;
7779 entry
< dynamic_section
+ dynamic_nent
;
7782 Elf_Internal_Shdr section
;
7784 if (entry
->d_tag
!= DT_SYMTAB
)
7787 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7789 /* Since we do not know how big the symbol table is,
7790 we default to reading in the entire file (!) and
7791 processing that. This is overkill, I know, but it
7793 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7795 if (archive_file_offset
!= 0)
7796 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7799 if (fseek (file
, 0, SEEK_END
))
7800 error (_("Unable to seek to end of file!\n"));
7802 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7806 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7808 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7810 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7811 if (num_dynamic_syms
< 1)
7813 error (_("Unable to determine the number of symbols to load\n"));
7819 /* Similarly find a string table. */
7820 if (dynamic_strings
== NULL
)
7822 for (entry
= dynamic_section
;
7823 entry
< dynamic_section
+ dynamic_nent
;
7826 unsigned long offset
;
7829 if (entry
->d_tag
!= DT_STRTAB
)
7832 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7834 /* Since we do not know how big the string table is,
7835 we default to reading in the entire file (!) and
7836 processing that. This is overkill, I know, but it
7839 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7841 if (archive_file_offset
!= 0)
7842 str_tab_len
= archive_file_size
- offset
;
7845 if (fseek (file
, 0, SEEK_END
))
7846 error (_("Unable to seek to end of file\n"));
7847 str_tab_len
= ftell (file
) - offset
;
7850 if (str_tab_len
< 1)
7853 (_("Unable to determine the length of the dynamic string table\n"));
7857 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7859 _("dynamic string table"));
7860 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7865 /* And find the syminfo section if available. */
7866 if (dynamic_syminfo
== NULL
)
7868 unsigned long syminsz
= 0;
7870 for (entry
= dynamic_section
;
7871 entry
< dynamic_section
+ dynamic_nent
;
7874 if (entry
->d_tag
== DT_SYMINENT
)
7876 /* Note: these braces are necessary to avoid a syntax
7877 error from the SunOS4 C compiler. */
7878 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7880 else if (entry
->d_tag
== DT_SYMINSZ
)
7881 syminsz
= entry
->d_un
.d_val
;
7882 else if (entry
->d_tag
== DT_SYMINFO
)
7883 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7887 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7889 Elf_External_Syminfo
* extsyminfo
;
7890 Elf_External_Syminfo
* extsym
;
7891 Elf_Internal_Syminfo
* syminfo
;
7893 /* There is a syminfo section. Read the data. */
7894 extsyminfo
= (Elf_External_Syminfo
*)
7895 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7896 _("symbol information"));
7900 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7901 if (dynamic_syminfo
== NULL
)
7903 error (_("Out of memory\n"));
7907 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7908 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7909 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7910 ++syminfo
, ++extsym
)
7912 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7913 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7920 if (do_dynamic
&& dynamic_addr
)
7921 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7922 dynamic_addr
, dynamic_nent
);
7924 printf (_(" Tag Type Name/Value\n"));
7926 for (entry
= dynamic_section
;
7927 entry
< dynamic_section
+ dynamic_nent
;
7935 print_vma (entry
->d_tag
, FULL_HEX
);
7936 dtype
= get_dynamic_type (entry
->d_tag
);
7937 printf (" (%s)%*s", dtype
,
7938 ((is_32bit_elf
? 27 : 19)
7939 - (int) strlen (dtype
)),
7943 switch (entry
->d_tag
)
7947 print_dynamic_flags (entry
->d_un
.d_val
);
7957 switch (entry
->d_tag
)
7960 printf (_("Auxiliary library"));
7964 printf (_("Filter library"));
7968 printf (_("Configuration file"));
7972 printf (_("Dependency audit library"));
7976 printf (_("Audit library"));
7980 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7981 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7985 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7994 printf (_("Flags:"));
7996 if (entry
->d_un
.d_val
== 0)
7997 printf (_(" None\n"));
8000 unsigned long int val
= entry
->d_un
.d_val
;
8002 if (val
& DTF_1_PARINIT
)
8004 printf (" PARINIT");
8005 val
^= DTF_1_PARINIT
;
8007 if (val
& DTF_1_CONFEXP
)
8009 printf (" CONFEXP");
8010 val
^= DTF_1_CONFEXP
;
8013 printf (" %lx", val
);
8022 printf (_("Flags:"));
8024 if (entry
->d_un
.d_val
== 0)
8025 printf (_(" None\n"));
8028 unsigned long int val
= entry
->d_un
.d_val
;
8030 if (val
& DF_P1_LAZYLOAD
)
8032 printf (" LAZYLOAD");
8033 val
^= DF_P1_LAZYLOAD
;
8035 if (val
& DF_P1_GROUPPERM
)
8037 printf (" GROUPPERM");
8038 val
^= DF_P1_GROUPPERM
;
8041 printf (" %lx", val
);
8050 printf (_("Flags:"));
8051 if (entry
->d_un
.d_val
== 0)
8052 printf (_(" None\n"));
8055 unsigned long int val
= entry
->d_un
.d_val
;
8062 if (val
& DF_1_GLOBAL
)
8067 if (val
& DF_1_GROUP
)
8072 if (val
& DF_1_NODELETE
)
8074 printf (" NODELETE");
8075 val
^= DF_1_NODELETE
;
8077 if (val
& DF_1_LOADFLTR
)
8079 printf (" LOADFLTR");
8080 val
^= DF_1_LOADFLTR
;
8082 if (val
& DF_1_INITFIRST
)
8084 printf (" INITFIRST");
8085 val
^= DF_1_INITFIRST
;
8087 if (val
& DF_1_NOOPEN
)
8092 if (val
& DF_1_ORIGIN
)
8097 if (val
& DF_1_DIRECT
)
8102 if (val
& DF_1_TRANS
)
8107 if (val
& DF_1_INTERPOSE
)
8109 printf (" INTERPOSE");
8110 val
^= DF_1_INTERPOSE
;
8112 if (val
& DF_1_NODEFLIB
)
8114 printf (" NODEFLIB");
8115 val
^= DF_1_NODEFLIB
;
8117 if (val
& DF_1_NODUMP
)
8122 if (val
& DF_1_CONFALT
)
8124 printf (" CONFALT");
8125 val
^= DF_1_CONFALT
;
8127 if (val
& DF_1_ENDFILTEE
)
8129 printf (" ENDFILTEE");
8130 val
^= DF_1_ENDFILTEE
;
8132 if (val
& DF_1_DISPRELDNE
)
8134 printf (" DISPRELDNE");
8135 val
^= DF_1_DISPRELDNE
;
8137 if (val
& DF_1_DISPRELPND
)
8139 printf (" DISPRELPND");
8140 val
^= DF_1_DISPRELPND
;
8142 if (val
& DF_1_NODIRECT
)
8144 printf (" NODIRECT");
8145 val
^= DF_1_NODIRECT
;
8147 if (val
& DF_1_IGNMULDEF
)
8149 printf (" IGNMULDEF");
8150 val
^= DF_1_IGNMULDEF
;
8152 if (val
& DF_1_NOKSYMS
)
8154 printf (" NOKSYMS");
8155 val
^= DF_1_NOKSYMS
;
8157 if (val
& DF_1_NOHDR
)
8162 if (val
& DF_1_EDITED
)
8167 if (val
& DF_1_NORELOC
)
8169 printf (" NORELOC");
8170 val
^= DF_1_NORELOC
;
8172 if (val
& DF_1_SYMINTPOSE
)
8174 printf (" SYMINTPOSE");
8175 val
^= DF_1_SYMINTPOSE
;
8177 if (val
& DF_1_GLOBAUDIT
)
8179 printf (" GLOBAUDIT");
8180 val
^= DF_1_GLOBAUDIT
;
8182 if (val
& DF_1_SINGLETON
)
8184 printf (" SINGLETON");
8185 val
^= DF_1_SINGLETON
;
8188 printf (" %lx", val
);
8195 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8197 puts (get_dynamic_type (entry
->d_un
.d_val
));
8217 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8223 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8224 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8230 switch (entry
->d_tag
)
8233 printf (_("Shared library: [%s]"), name
);
8235 if (streq (name
, program_interpreter
))
8236 printf (_(" program interpreter"));
8240 printf (_("Library soname: [%s]"), name
);
8244 printf (_("Library rpath: [%s]"), name
);
8248 printf (_("Library runpath: [%s]"), name
);
8252 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8257 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8270 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8274 case DT_INIT_ARRAYSZ
:
8275 case DT_FINI_ARRAYSZ
:
8276 case DT_GNU_CONFLICTSZ
:
8277 case DT_GNU_LIBLISTSZ
:
8280 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8281 printf (_(" (bytes)\n"));
8291 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8304 if (entry
->d_tag
== DT_USED
8305 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8307 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8311 printf (_("Not needed object: [%s]\n"), name
);
8316 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8322 /* The value of this entry is ignored. */
8327 case DT_GNU_PRELINKED
:
8331 time_t atime
= entry
->d_un
.d_val
;
8333 tmp
= gmtime (&atime
);
8334 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8335 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8336 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8342 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8345 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8351 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8352 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8357 switch (elf_header
.e_machine
)
8360 case EM_MIPS_RS3_LE
:
8361 dynamic_section_mips_val (entry
);
8364 dynamic_section_parisc_val (entry
);
8367 dynamic_section_ia64_val (entry
);
8370 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8382 get_ver_flags (unsigned int flags
)
8384 static char buff
[32];
8391 if (flags
& VER_FLG_BASE
)
8392 strcat (buff
, "BASE ");
8394 if (flags
& VER_FLG_WEAK
)
8396 if (flags
& VER_FLG_BASE
)
8397 strcat (buff
, "| ");
8399 strcat (buff
, "WEAK ");
8402 if (flags
& VER_FLG_INFO
)
8404 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8405 strcat (buff
, "| ");
8407 strcat (buff
, "INFO ");
8410 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8411 strcat (buff
, _("| <unknown>"));
8416 /* Display the contents of the version sections. */
8419 process_version_sections (FILE * file
)
8421 Elf_Internal_Shdr
* section
;
8428 for (i
= 0, section
= section_headers
;
8429 i
< elf_header
.e_shnum
;
8432 switch (section
->sh_type
)
8434 case SHT_GNU_verdef
:
8436 Elf_External_Verdef
* edefs
;
8444 (_("\nVersion definition section '%s' contains %u entries:\n"),
8445 SECTION_NAME (section
), section
->sh_info
);
8447 printf (_(" Addr: 0x"));
8448 printf_vma (section
->sh_addr
);
8449 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8450 (unsigned long) section
->sh_offset
, section
->sh_link
,
8451 section
->sh_link
< elf_header
.e_shnum
8452 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8455 edefs
= (Elf_External_Verdef
*)
8456 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8457 _("version definition section"));
8460 endbuf
= (char *) edefs
+ section
->sh_size
;
8462 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8465 Elf_External_Verdef
* edef
;
8466 Elf_Internal_Verdef ent
;
8467 Elf_External_Verdaux
* eaux
;
8468 Elf_Internal_Verdaux aux
;
8472 /* Check for negative or very large indicies. */
8473 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
8476 vstart
= ((char *) edefs
) + idx
;
8477 if (vstart
+ sizeof (*edef
) > endbuf
)
8480 edef
= (Elf_External_Verdef
*) vstart
;
8482 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8483 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8484 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8485 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8486 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8487 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8488 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8490 printf (_(" %#06x: Rev: %d Flags: %s"),
8491 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8493 printf (_(" Index: %d Cnt: %d "),
8494 ent
.vd_ndx
, ent
.vd_cnt
);
8496 /* Check for overflow. */
8497 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
8498 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
8501 vstart
+= ent
.vd_aux
;
8503 eaux
= (Elf_External_Verdaux
*) vstart
;
8505 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8506 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8508 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8509 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8511 printf (_("Name index: %ld\n"), aux
.vda_name
);
8513 isum
= idx
+ ent
.vd_aux
;
8515 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8517 /* Check for overflow. */
8518 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
8519 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
8522 isum
+= aux
.vda_next
;
8523 vstart
+= aux
.vda_next
;
8525 eaux
= (Elf_External_Verdaux
*) vstart
;
8526 if (vstart
+ sizeof (*eaux
) > endbuf
)
8529 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8530 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8532 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8533 printf (_(" %#06x: Parent %d: %s\n"),
8534 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8536 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8537 isum
, j
, aux
.vda_name
);
8541 printf (_(" Version def aux past end of section\n"));
8546 if (cnt
< section
->sh_info
)
8547 printf (_(" Version definition past end of section\n"));
8553 case SHT_GNU_verneed
:
8555 Elf_External_Verneed
* eneed
;
8562 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8563 SECTION_NAME (section
), section
->sh_info
);
8565 printf (_(" Addr: 0x"));
8566 printf_vma (section
->sh_addr
);
8567 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8568 (unsigned long) section
->sh_offset
, section
->sh_link
,
8569 section
->sh_link
< elf_header
.e_shnum
8570 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8573 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8574 section
->sh_offset
, 1,
8576 _("Version Needs section"));
8579 endbuf
= (char *) eneed
+ section
->sh_size
;
8581 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8583 Elf_External_Verneed
* entry
;
8584 Elf_Internal_Verneed ent
;
8589 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
8592 vstart
= ((char *) eneed
) + idx
;
8593 if (vstart
+ sizeof (*entry
) > endbuf
)
8596 entry
= (Elf_External_Verneed
*) vstart
;
8598 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8599 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8600 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8601 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8602 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8604 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8606 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8607 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8609 printf (_(" File: %lx"), ent
.vn_file
);
8611 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8613 /* Check for overflow. */
8614 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
8615 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
8618 vstart
+= ent
.vn_aux
;
8620 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8622 Elf_External_Vernaux
* eaux
;
8623 Elf_Internal_Vernaux aux
;
8625 if (vstart
+ sizeof (*eaux
) > endbuf
)
8627 eaux
= (Elf_External_Vernaux
*) vstart
;
8629 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8630 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8631 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8632 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8633 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8635 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8636 printf (_(" %#06x: Name: %s"),
8637 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8639 printf (_(" %#06x: Name index: %lx"),
8640 isum
, aux
.vna_name
);
8642 printf (_(" Flags: %s Version: %d\n"),
8643 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8645 /* Check for overflow. */
8646 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
8647 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
8650 isum
+= aux
.vna_next
;
8651 vstart
+= aux
.vna_next
;
8655 warn (_("Missing Version Needs auxillary information\n"));
8660 if (cnt
< section
->sh_info
)
8661 warn (_("Missing Version Needs information\n"));
8667 case SHT_GNU_versym
:
8669 Elf_Internal_Shdr
* link_section
;
8672 unsigned char * edata
;
8673 unsigned short * data
;
8675 Elf_Internal_Sym
* symbols
;
8676 Elf_Internal_Shdr
* string_sec
;
8677 unsigned long num_syms
;
8680 if (section
->sh_link
>= elf_header
.e_shnum
)
8683 link_section
= section_headers
+ section
->sh_link
;
8684 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8686 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8691 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8692 if (symbols
== NULL
)
8695 string_sec
= section_headers
+ link_section
->sh_link
;
8697 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8698 string_sec
->sh_size
,
8699 _("version string table"));
8706 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8707 SECTION_NAME (section
), total
);
8709 printf (_(" Addr: "));
8710 printf_vma (section
->sh_addr
);
8711 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8712 (unsigned long) section
->sh_offset
, section
->sh_link
,
8713 SECTION_NAME (link_section
));
8715 off
= offset_from_vma (file
,
8716 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8717 total
* sizeof (short));
8718 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8720 _("version symbol data"));
8728 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8730 for (cnt
= total
; cnt
--;)
8731 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8736 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8739 int check_def
, check_need
;
8742 printf (" %03x:", cnt
);
8744 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8745 switch (data
[cnt
+ j
])
8748 fputs (_(" 0 (*local*) "), stdout
);
8752 fputs (_(" 1 (*global*) "), stdout
);
8756 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8757 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8759 /* If this index value is greater than the size of the symbols
8760 array, break to avoid an out-of-bounds read. */
8761 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8763 warn (_("invalid index into symbol array\n"));
8769 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8770 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8773 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8780 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8782 Elf_Internal_Verneed ivn
;
8783 unsigned long offset
;
8785 offset
= offset_from_vma
8786 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8787 sizeof (Elf_External_Verneed
));
8791 Elf_Internal_Vernaux ivna
;
8792 Elf_External_Verneed evn
;
8793 Elf_External_Vernaux evna
;
8794 unsigned long a_off
;
8796 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8797 _("version need")) == NULL
)
8800 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8801 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8803 a_off
= offset
+ ivn
.vn_aux
;
8807 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8808 1, _("version need aux (2)")) == NULL
)
8815 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8816 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8819 a_off
+= ivna
.vna_next
;
8821 while (ivna
.vna_other
!= data
[cnt
+ j
]
8822 && ivna
.vna_next
!= 0);
8824 if (ivna
.vna_other
== data
[cnt
+ j
])
8826 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8828 if (ivna
.vna_name
>= string_sec
->sh_size
)
8829 name
= _("*invalid*");
8831 name
= strtab
+ ivna
.vna_name
;
8832 nn
+= printf ("(%s%-*s",
8834 12 - (int) strlen (name
),
8840 offset
+= ivn
.vn_next
;
8842 while (ivn
.vn_next
);
8845 if (check_def
&& data
[cnt
+ j
] != 0x8001
8846 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8848 Elf_Internal_Verdef ivd
;
8849 Elf_External_Verdef evd
;
8850 unsigned long offset
;
8852 offset
= offset_from_vma
8853 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8858 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8859 _("version def")) == NULL
)
8866 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8867 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8870 offset
+= ivd
.vd_next
;
8872 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8873 && ivd
.vd_next
!= 0);
8875 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8877 Elf_External_Verdaux evda
;
8878 Elf_Internal_Verdaux ivda
;
8880 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8882 if (get_data (&evda
, file
,
8883 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8885 _("version def aux")) == NULL
)
8888 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8890 if (ivda
.vda_name
>= string_sec
->sh_size
)
8891 name
= _("*invalid*");
8893 name
= strtab
+ ivda
.vda_name
;
8894 nn
+= printf ("(%s%-*s",
8896 12 - (int) strlen (name
),
8902 printf ("%*c", 18 - nn
, ' ');
8920 printf (_("\nNo version information found in this file.\n"));
8926 get_symbol_binding (unsigned int binding
)
8928 static char buff
[32];
8932 case STB_LOCAL
: return "LOCAL";
8933 case STB_GLOBAL
: return "GLOBAL";
8934 case STB_WEAK
: return "WEAK";
8936 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8937 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8939 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8941 if (binding
== STB_GNU_UNIQUE
8942 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8943 /* GNU is still using the default value 0. */
8944 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8946 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8949 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8955 get_symbol_type (unsigned int type
)
8957 static char buff
[32];
8961 case STT_NOTYPE
: return "NOTYPE";
8962 case STT_OBJECT
: return "OBJECT";
8963 case STT_FUNC
: return "FUNC";
8964 case STT_SECTION
: return "SECTION";
8965 case STT_FILE
: return "FILE";
8966 case STT_COMMON
: return "COMMON";
8967 case STT_TLS
: return "TLS";
8968 case STT_RELC
: return "RELC";
8969 case STT_SRELC
: return "SRELC";
8971 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8973 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8974 return "THUMB_FUNC";
8976 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8979 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8980 return "PARISC_MILLI";
8982 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8984 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8986 if (elf_header
.e_machine
== EM_PARISC
)
8988 if (type
== STT_HP_OPAQUE
)
8990 if (type
== STT_HP_STUB
)
8994 if (type
== STT_GNU_IFUNC
8995 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8996 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
8997 /* GNU is still using the default value 0. */
8998 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
9001 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
9004 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
9010 get_symbol_visibility (unsigned int visibility
)
9014 case STV_DEFAULT
: return "DEFAULT";
9015 case STV_INTERNAL
: return "INTERNAL";
9016 case STV_HIDDEN
: return "HIDDEN";
9017 case STV_PROTECTED
: return "PROTECTED";
9023 get_mips_symbol_other (unsigned int other
)
9035 case STO_MICROMIPS
| STO_MIPS_PIC
:
9036 return "MICROMIPS, MIPS PIC";
9045 get_ia64_symbol_other (unsigned int other
)
9049 static char res
[32];
9053 /* Function types is for images and .STB files only. */
9054 switch (elf_header
.e_type
)
9058 switch (VMS_ST_FUNC_TYPE (other
))
9060 case VMS_SFT_CODE_ADDR
:
9061 strcat (res
, " CA");
9063 case VMS_SFT_SYMV_IDX
:
9064 strcat (res
, " VEC");
9067 strcat (res
, " FD");
9069 case VMS_SFT_RESERVE
:
9070 strcat (res
, " RSV");
9079 switch (VMS_ST_LINKAGE (other
))
9081 case VMS_STL_IGNORE
:
9082 strcat (res
, " IGN");
9084 case VMS_STL_RESERVE
:
9085 strcat (res
, " RSV");
9088 strcat (res
, " STD");
9091 strcat (res
, " LNK");
9106 get_symbol_other (unsigned int other
)
9108 const char * result
= NULL
;
9109 static char buff
[32];
9114 switch (elf_header
.e_machine
)
9117 result
= get_mips_symbol_other (other
);
9120 result
= get_ia64_symbol_other (other
);
9129 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9134 get_symbol_index_type (unsigned int type
)
9136 static char buff
[32];
9140 case SHN_UNDEF
: return "UND";
9141 case SHN_ABS
: return "ABS";
9142 case SHN_COMMON
: return "COM";
9144 if (type
== SHN_IA_64_ANSI_COMMON
9145 && elf_header
.e_machine
== EM_IA_64
9146 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9148 else if ((elf_header
.e_machine
== EM_X86_64
9149 || elf_header
.e_machine
== EM_L1OM
9150 || elf_header
.e_machine
== EM_K1OM
)
9151 && type
== SHN_X86_64_LCOMMON
)
9153 else if ((type
== SHN_MIPS_SCOMMON
9154 && elf_header
.e_machine
== EM_MIPS
)
9155 || (type
== SHN_TIC6X_SCOMMON
9156 && elf_header
.e_machine
== EM_TI_C6000
))
9158 else if (type
== SHN_MIPS_SUNDEFINED
9159 && elf_header
.e_machine
== EM_MIPS
)
9161 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9162 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9163 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9164 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9165 else if (type
>= SHN_LORESERVE
)
9166 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9167 else if (type
>= elf_header
.e_shnum
)
9168 sprintf (buff
, "bad section index[%3d]", type
);
9170 sprintf (buff
, "%3d", type
);
9178 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9180 unsigned char * e_data
;
9183 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9187 error (_("Out of memory\n"));
9191 if (fread (e_data
, ent_size
, number
, file
) != number
)
9193 error (_("Unable to read in dynamic data\n"));
9197 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9201 error (_("Out of memory\n"));
9207 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9215 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9217 Elf_Internal_Sym
* psym
;
9220 psym
= dynamic_symbols
+ si
;
9222 n
= print_vma (si
, DEC_5
);
9224 fputs (" " + n
, stdout
);
9225 printf (" %3lu: ", hn
);
9226 print_vma (psym
->st_value
, LONG_HEX
);
9228 print_vma (psym
->st_size
, DEC_5
);
9230 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9231 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9232 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9233 /* Check to see if any other bits in the st_other field are set.
9234 Note - displaying this information disrupts the layout of the
9235 table being generated, but for the moment this case is very
9237 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9238 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9239 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9240 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9241 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9243 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9247 /* Dump the symbol table. */
9249 process_symbol_table (FILE * file
)
9251 Elf_Internal_Shdr
* section
;
9252 bfd_vma nbuckets
= 0;
9253 bfd_vma nchains
= 0;
9254 bfd_vma
* buckets
= NULL
;
9255 bfd_vma
* chains
= NULL
;
9256 bfd_vma ngnubuckets
= 0;
9257 bfd_vma
* gnubuckets
= NULL
;
9258 bfd_vma
* gnuchains
= NULL
;
9259 bfd_vma gnusymidx
= 0;
9261 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9264 if (dynamic_info
[DT_HASH
]
9266 || (do_using_dynamic
9268 && dynamic_strings
!= NULL
)))
9270 unsigned char nb
[8];
9271 unsigned char nc
[8];
9272 int hash_ent_size
= 4;
9274 if ((elf_header
.e_machine
== EM_ALPHA
9275 || elf_header
.e_machine
== EM_S390
9276 || elf_header
.e_machine
== EM_S390_OLD
)
9277 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9281 (archive_file_offset
9282 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9283 sizeof nb
+ sizeof nc
)),
9286 error (_("Unable to seek to start of dynamic information\n"));
9290 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9292 error (_("Failed to read in number of buckets\n"));
9296 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9298 error (_("Failed to read in number of chains\n"));
9302 nbuckets
= byte_get (nb
, hash_ent_size
);
9303 nchains
= byte_get (nc
, hash_ent_size
);
9305 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9306 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9309 if (buckets
== NULL
|| chains
== NULL
)
9311 if (do_using_dynamic
)
9322 if (dynamic_info_DT_GNU_HASH
9324 || (do_using_dynamic
9326 && dynamic_strings
!= NULL
)))
9328 unsigned char nb
[16];
9329 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9330 bfd_vma buckets_vma
;
9333 (archive_file_offset
9334 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9338 error (_("Unable to seek to start of dynamic information\n"));
9342 if (fread (nb
, 16, 1, file
) != 1)
9344 error (_("Failed to read in number of buckets\n"));
9348 ngnubuckets
= byte_get (nb
, 4);
9349 gnusymidx
= byte_get (nb
+ 4, 4);
9350 bitmaskwords
= byte_get (nb
+ 8, 4);
9351 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9353 buckets_vma
+= bitmaskwords
* 4;
9355 buckets_vma
+= bitmaskwords
* 8;
9358 (archive_file_offset
9359 + offset_from_vma (file
, buckets_vma
, 4)),
9362 error (_("Unable to seek to start of dynamic information\n"));
9366 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9368 if (gnubuckets
== NULL
)
9371 for (i
= 0; i
< ngnubuckets
; i
++)
9372 if (gnubuckets
[i
] != 0)
9374 if (gnubuckets
[i
] < gnusymidx
)
9377 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9378 maxchain
= gnubuckets
[i
];
9381 if (maxchain
== 0xffffffff)
9384 maxchain
-= gnusymidx
;
9387 (archive_file_offset
9388 + offset_from_vma (file
, buckets_vma
9389 + 4 * (ngnubuckets
+ maxchain
), 4)),
9392 error (_("Unable to seek to start of dynamic information\n"));
9398 if (fread (nb
, 4, 1, file
) != 1)
9400 error (_("Failed to determine last chain length\n"));
9404 if (maxchain
+ 1 == 0)
9409 while ((byte_get (nb
, 4) & 1) == 0);
9412 (archive_file_offset
9413 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9416 error (_("Unable to seek to start of dynamic information\n"));
9420 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9423 if (gnuchains
== NULL
)
9428 if (do_using_dynamic
)
9433 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9436 && dynamic_strings
!= NULL
)
9440 if (dynamic_info
[DT_HASH
])
9444 printf (_("\nSymbol table for image:\n"));
9446 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9448 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9450 for (hn
= 0; hn
< nbuckets
; hn
++)
9455 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9456 print_dynamic_symbol (si
, hn
);
9460 if (dynamic_info_DT_GNU_HASH
)
9462 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9464 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9466 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9468 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9469 if (gnubuckets
[hn
] != 0)
9471 bfd_vma si
= gnubuckets
[hn
];
9472 bfd_vma off
= si
- gnusymidx
;
9476 print_dynamic_symbol (si
, hn
);
9479 while ((gnuchains
[off
++] & 1) == 0);
9483 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9487 for (i
= 0, section
= section_headers
;
9488 i
< elf_header
.e_shnum
;
9492 char * strtab
= NULL
;
9493 unsigned long int strtab_size
= 0;
9494 Elf_Internal_Sym
* symtab
;
9495 Elf_Internal_Sym
* psym
;
9496 unsigned long num_syms
;
9498 if ((section
->sh_type
!= SHT_SYMTAB
9499 && section
->sh_type
!= SHT_DYNSYM
)
9501 && section
->sh_type
== SHT_SYMTAB
))
9504 if (section
->sh_entsize
== 0)
9506 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9507 SECTION_NAME (section
));
9511 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9512 SECTION_NAME (section
),
9513 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9516 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9518 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9520 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9524 if (section
->sh_link
== elf_header
.e_shstrndx
)
9526 strtab
= string_table
;
9527 strtab_size
= string_table_length
;
9529 else if (section
->sh_link
< elf_header
.e_shnum
)
9531 Elf_Internal_Shdr
* string_sec
;
9533 string_sec
= section_headers
+ section
->sh_link
;
9535 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9536 1, string_sec
->sh_size
,
9538 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9541 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9543 printf ("%6d: ", si
);
9544 print_vma (psym
->st_value
, LONG_HEX
);
9546 print_vma (psym
->st_size
, DEC_5
);
9547 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9548 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9549 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9550 /* Check to see if any other bits in the st_other field are set.
9551 Note - displaying this information disrupts the layout of the
9552 table being generated, but for the moment this case is very rare. */
9553 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9554 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9555 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9556 print_symbol (25, psym
->st_name
< strtab_size
9557 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9559 if (section
->sh_type
== SHT_DYNSYM
9560 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9562 unsigned char data
[2];
9563 unsigned short vers_data
;
9564 unsigned long offset
;
9568 offset
= offset_from_vma
9569 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9570 sizeof data
+ si
* sizeof (vers_data
));
9572 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9573 sizeof (data
), 1, _("version data")) == NULL
)
9576 vers_data
= byte_get (data
, 2);
9578 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9579 && section_headers
[psym
->st_shndx
].sh_type
9582 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9584 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9586 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9587 && (is_nobits
|| ! check_def
))
9589 Elf_External_Verneed evn
;
9590 Elf_Internal_Verneed ivn
;
9591 Elf_Internal_Vernaux ivna
;
9593 /* We must test both. */
9594 offset
= offset_from_vma
9595 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9600 unsigned long vna_off
;
9602 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9603 _("version need")) == NULL
)
9611 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9612 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9614 vna_off
= offset
+ ivn
.vn_aux
;
9618 Elf_External_Vernaux evna
;
9620 if (get_data (&evna
, file
, vna_off
,
9622 _("version need aux (3)")) == NULL
)
9630 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9631 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9632 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9635 vna_off
+= ivna
.vna_next
;
9637 while (ivna
.vna_other
!= vers_data
9638 && ivna
.vna_next
!= 0);
9640 if (ivna
.vna_other
== vers_data
)
9643 offset
+= ivn
.vn_next
;
9645 while (ivn
.vn_next
!= 0);
9647 if (ivna
.vna_other
== vers_data
)
9650 ivna
.vna_name
< strtab_size
9651 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9655 else if (! is_nobits
)
9656 error (_("bad dynamic symbol\n"));
9663 if (vers_data
!= 0x8001
9664 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9666 Elf_Internal_Verdef ivd
;
9667 Elf_Internal_Verdaux ivda
;
9668 Elf_External_Verdaux evda
;
9671 off
= offset_from_vma
9673 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9674 sizeof (Elf_External_Verdef
));
9678 Elf_External_Verdef evd
;
9680 if (get_data (&evd
, file
, off
, sizeof (evd
),
9681 1, _("version def")) == NULL
)
9689 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9690 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9691 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9696 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9697 && ivd
.vd_next
!= 0);
9702 if (get_data (&evda
, file
, off
, sizeof (evda
),
9703 1, _("version def aux")) == NULL
)
9706 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9708 if (psym
->st_name
!= ivda
.vda_name
)
9709 printf ((vers_data
& VERSYM_HIDDEN
)
9711 ivda
.vda_name
< strtab_size
9712 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9722 if (strtab
!= string_table
)
9728 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9730 if (do_histogram
&& buckets
!= NULL
)
9732 unsigned long * lengths
;
9733 unsigned long * counts
;
9736 unsigned long maxlength
= 0;
9737 unsigned long nzero_counts
= 0;
9738 unsigned long nsyms
= 0;
9740 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9741 (unsigned long) nbuckets
);
9742 printf (_(" Length Number %% of total Coverage\n"));
9744 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9745 if (lengths
== NULL
)
9747 error (_("Out of memory\n"));
9750 for (hn
= 0; hn
< nbuckets
; ++hn
)
9752 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9755 if (maxlength
< ++lengths
[hn
])
9760 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9763 error (_("Out of memory\n"));
9767 for (hn
= 0; hn
< nbuckets
; ++hn
)
9768 ++counts
[lengths
[hn
]];
9773 printf (" 0 %-10lu (%5.1f%%)\n",
9774 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9775 for (i
= 1; i
<= maxlength
; ++i
)
9777 nzero_counts
+= counts
[i
] * i
;
9778 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9779 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9780 (nzero_counts
* 100.0) / nsyms
);
9788 if (buckets
!= NULL
)
9794 if (do_histogram
&& gnubuckets
!= NULL
)
9796 unsigned long * lengths
;
9797 unsigned long * counts
;
9799 unsigned long maxlength
= 0;
9800 unsigned long nzero_counts
= 0;
9801 unsigned long nsyms
= 0;
9803 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9804 if (lengths
== NULL
)
9806 error (_("Out of memory\n"));
9810 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9811 (unsigned long) ngnubuckets
);
9812 printf (_(" Length Number %% of total Coverage\n"));
9814 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9815 if (gnubuckets
[hn
] != 0)
9817 bfd_vma off
, length
= 1;
9819 for (off
= gnubuckets
[hn
] - gnusymidx
;
9820 (gnuchains
[off
] & 1) == 0; ++off
)
9822 lengths
[hn
] = length
;
9823 if (length
> maxlength
)
9828 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9831 error (_("Out of memory\n"));
9835 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9836 ++counts
[lengths
[hn
]];
9838 if (ngnubuckets
> 0)
9841 printf (" 0 %-10lu (%5.1f%%)\n",
9842 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9843 for (j
= 1; j
<= maxlength
; ++j
)
9845 nzero_counts
+= counts
[j
] * j
;
9846 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9847 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9848 (nzero_counts
* 100.0) / nsyms
);
9862 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9866 if (dynamic_syminfo
== NULL
9868 /* No syminfo, this is ok. */
9871 /* There better should be a dynamic symbol section. */
9872 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9876 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9877 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9879 printf (_(" Num: Name BoundTo Flags\n"));
9880 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9882 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9884 printf ("%4d: ", i
);
9885 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9886 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9888 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9891 switch (dynamic_syminfo
[i
].si_boundto
)
9893 case SYMINFO_BT_SELF
:
9894 fputs ("SELF ", stdout
);
9896 case SYMINFO_BT_PARENT
:
9897 fputs ("PARENT ", stdout
);
9900 if (dynamic_syminfo
[i
].si_boundto
> 0
9901 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9902 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9904 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9908 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9912 if (flags
& SYMINFO_FLG_DIRECT
)
9914 if (flags
& SYMINFO_FLG_PASSTHRU
)
9915 printf (" PASSTHRU");
9916 if (flags
& SYMINFO_FLG_COPY
)
9918 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9919 printf (" LAZYLOAD");
9927 /* Check to see if the given reloc needs to be handled in a target specific
9928 manner. If so then process the reloc and return TRUE otherwise return
9932 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9933 unsigned char * start
,
9934 Elf_Internal_Sym
* symtab
)
9936 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9938 switch (elf_header
.e_machine
)
9941 case EM_CYGNUS_MN10300
:
9943 static Elf_Internal_Sym
* saved_sym
= NULL
;
9947 case 34: /* R_MN10300_ALIGN */
9949 case 33: /* R_MN10300_SYM_DIFF */
9950 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9952 case 1: /* R_MN10300_32 */
9953 case 2: /* R_MN10300_16 */
9954 if (saved_sym
!= NULL
)
9958 value
= reloc
->r_addend
9959 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9960 - saved_sym
->st_value
);
9962 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9969 if (saved_sym
!= NULL
)
9970 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9980 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9981 DWARF debug sections. This is a target specific test. Note - we do not
9982 go through the whole including-target-headers-multiple-times route, (as
9983 we have already done with <elf/h8.h>) because this would become very
9984 messy and even then this function would have to contain target specific
9985 information (the names of the relocs instead of their numeric values).
9986 FIXME: This is not the correct way to solve this problem. The proper way
9987 is to have target specific reloc sizing and typing functions created by
9988 the reloc-macros.h header, in the same way that it already creates the
9989 reloc naming functions. */
9992 is_32bit_abs_reloc (unsigned int reloc_type
)
9994 switch (elf_header
.e_machine
)
9998 return reloc_type
== 1; /* R_386_32. */
10000 return reloc_type
== 1; /* R_68K_32. */
10002 return reloc_type
== 1; /* R_860_32. */
10004 return reloc_type
== 2; /* R_960_32. */
10006 return reloc_type
== 258; /* R_AARCH64_ABS32 */
10008 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
10010 return reloc_type
== 1; /* R_ARC_32. */
10012 return reloc_type
== 2; /* R_ARM_ABS32 */
10015 return reloc_type
== 1;
10016 case EM_ADAPTEVA_EPIPHANY
:
10017 return reloc_type
== 3;
10019 return reloc_type
== 0x12; /* R_byte4_data. */
10021 return reloc_type
== 3; /* R_CRIS_32. */
10023 return reloc_type
== 3; /* R_CR16_NUM32. */
10025 return reloc_type
== 15; /* R_CRX_NUM32. */
10026 case EM_CYGNUS_FRV
:
10027 return reloc_type
== 1;
10028 case EM_CYGNUS_D10V
:
10030 return reloc_type
== 6; /* R_D10V_32. */
10031 case EM_CYGNUS_D30V
:
10033 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
10035 return reloc_type
== 3; /* R_DLX_RELOC_32. */
10036 case EM_CYGNUS_FR30
:
10038 return reloc_type
== 3; /* R_FR30_32. */
10042 return reloc_type
== 1; /* R_H8_DIR32. */
10044 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
10047 return reloc_type
== 2; /* R_IP2K_32. */
10049 return reloc_type
== 2; /* R_IQ2000_32. */
10050 case EM_LATTICEMICO32
:
10051 return reloc_type
== 3; /* R_LM32_32. */
10054 return reloc_type
== 3; /* R_M32C_32. */
10056 return reloc_type
== 34; /* R_M32R_32_RELA. */
10058 return reloc_type
== 1; /* R_MCORE_ADDR32. */
10059 case EM_CYGNUS_MEP
:
10060 return reloc_type
== 4; /* R_MEP_32. */
10062 return reloc_type
== 2; /* R_METAG_ADDR32. */
10063 case EM_MICROBLAZE
:
10064 return reloc_type
== 1; /* R_MICROBLAZE_32. */
10066 return reloc_type
== 2; /* R_MIPS_32. */
10068 return reloc_type
== 4; /* R_MMIX_32. */
10069 case EM_CYGNUS_MN10200
:
10071 return reloc_type
== 1; /* R_MN10200_32. */
10072 case EM_CYGNUS_MN10300
:
10074 return reloc_type
== 1; /* R_MN10300_32. */
10076 return reloc_type
== 1; /* R_MOXIE_32. */
10077 case EM_MSP430_OLD
:
10079 return reloc_type
== 1; /* R_MSP43_32. */
10081 return reloc_type
== 2; /* R_MT_32. */
10082 case EM_ALTERA_NIOS2
:
10084 return reloc_type
== 1; /* R_NIOS_32. */
10087 return reloc_type
== 1; /* R_OR32_32. */
10089 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10090 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10093 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10095 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10097 return reloc_type
== 1; /* R_PPC_ADDR32. */
10099 return reloc_type
== 1; /* R_RL78_DIR32. */
10101 return reloc_type
== 1; /* R_RX_DIR32. */
10103 return reloc_type
== 1; /* R_I370_ADDR31. */
10106 return reloc_type
== 4; /* R_S390_32. */
10108 return reloc_type
== 8; /* R_SCORE_ABS32. */
10110 return reloc_type
== 1; /* R_SH_DIR32. */
10111 case EM_SPARC32PLUS
:
10114 return reloc_type
== 3 /* R_SPARC_32. */
10115 || reloc_type
== 23; /* R_SPARC_UA32. */
10117 return reloc_type
== 6; /* R_SPU_ADDR32 */
10119 return reloc_type
== 1; /* R_C6000_ABS32. */
10121 return reloc_type
== 2; /* R_TILEGX_32. */
10123 return reloc_type
== 1; /* R_TILEPRO_32. */
10124 case EM_CYGNUS_V850
:
10126 return reloc_type
== 6; /* R_V850_ABS32. */
10128 return reloc_type
== 0x33; /* R_V810_WORD. */
10130 return reloc_type
== 1; /* R_VAX_32. */
10134 return reloc_type
== 10; /* R_X86_64_32. */
10137 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10139 return reloc_type
== 4; /* R_XGATE_32. */
10141 return reloc_type
== 1; /* R_XSTROMY16_32. */
10142 case EM_XTENSA_OLD
:
10144 return reloc_type
== 1; /* R_XTENSA_32. */
10146 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10147 elf_header
.e_machine
);
10152 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10153 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10156 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10158 switch (elf_header
.e_machine
)
10162 return reloc_type
== 2; /* R_386_PC32. */
10164 return reloc_type
== 4; /* R_68K_PC32. */
10166 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10167 case EM_ADAPTEVA_EPIPHANY
:
10168 return reloc_type
== 6;
10170 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10172 return reloc_type
== 3; /* R_ARM_REL32 */
10173 case EM_MICROBLAZE
:
10174 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10176 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10178 return reloc_type
== 26; /* R_PPC_REL32. */
10180 return reloc_type
== 26; /* R_PPC64_REL32. */
10183 return reloc_type
== 5; /* R_390_PC32. */
10185 return reloc_type
== 2; /* R_SH_REL32. */
10186 case EM_SPARC32PLUS
:
10189 return reloc_type
== 6; /* R_SPARC_DISP32. */
10191 return reloc_type
== 13; /* R_SPU_REL32. */
10193 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10195 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10199 return reloc_type
== 2; /* R_X86_64_PC32. */
10200 case EM_XTENSA_OLD
:
10202 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10204 /* Do not abort or issue an error message here. Not all targets use
10205 pc-relative 32-bit relocs in their DWARF debug information and we
10206 have already tested for target coverage in is_32bit_abs_reloc. A
10207 more helpful warning message will be generated by apply_relocations
10208 anyway, so just return. */
10213 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10214 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10217 is_64bit_abs_reloc (unsigned int reloc_type
)
10219 switch (elf_header
.e_machine
)
10222 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10224 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10226 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10228 return reloc_type
== 80; /* R_PARISC_DIR64. */
10230 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10231 case EM_SPARC32PLUS
:
10234 return reloc_type
== 54; /* R_SPARC_UA64. */
10238 return reloc_type
== 1; /* R_X86_64_64. */
10241 return reloc_type
== 22; /* R_S390_64. */
10243 return reloc_type
== 1; /* R_TILEGX_64. */
10245 return reloc_type
== 18; /* R_MIPS_64. */
10251 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10252 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10255 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10257 switch (elf_header
.e_machine
)
10260 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10262 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10264 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10266 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10268 return reloc_type
== 44; /* R_PPC64_REL64. */
10269 case EM_SPARC32PLUS
:
10272 return reloc_type
== 46; /* R_SPARC_DISP64. */
10276 return reloc_type
== 24; /* R_X86_64_PC64. */
10279 return reloc_type
== 23; /* R_S390_PC64. */
10281 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10287 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10288 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10291 is_24bit_abs_reloc (unsigned int reloc_type
)
10293 switch (elf_header
.e_machine
)
10295 case EM_CYGNUS_MN10200
:
10297 return reloc_type
== 4; /* R_MN10200_24. */
10303 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10304 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10307 is_16bit_abs_reloc (unsigned int reloc_type
)
10309 switch (elf_header
.e_machine
)
10313 return reloc_type
== 4; /* R_AVR_16. */
10314 case EM_ADAPTEVA_EPIPHANY
:
10315 return reloc_type
== 5;
10316 case EM_CYGNUS_D10V
:
10318 return reloc_type
== 3; /* R_D10V_16. */
10322 return reloc_type
== R_H8_DIR16
;
10325 return reloc_type
== 1; /* R_IP2K_16. */
10328 return reloc_type
== 1; /* R_M32C_16 */
10330 case EM_MSP430_OLD
:
10331 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10332 case EM_ALTERA_NIOS2
:
10334 return reloc_type
== 9; /* R_NIOS_16. */
10336 return reloc_type
== 2; /* R_C6000_ABS16. */
10339 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10340 case EM_CYGNUS_MN10200
:
10342 return reloc_type
== 2; /* R_MN10200_16. */
10343 case EM_CYGNUS_MN10300
:
10345 return reloc_type
== 2; /* R_MN10300_16. */
10347 return reloc_type
== 3; /* R_XGATE_16. */
10353 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10354 relocation entries (possibly formerly used for SHT_GROUP sections). */
10357 is_none_reloc (unsigned int reloc_type
)
10359 switch (elf_header
.e_machine
)
10361 case EM_68K
: /* R_68K_NONE. */
10362 case EM_386
: /* R_386_NONE. */
10363 case EM_SPARC32PLUS
:
10365 case EM_SPARC
: /* R_SPARC_NONE. */
10366 case EM_MIPS
: /* R_MIPS_NONE. */
10367 case EM_PARISC
: /* R_PARISC_NONE. */
10368 case EM_ALPHA
: /* R_ALPHA_NONE. */
10369 case EM_ADAPTEVA_EPIPHANY
:
10370 case EM_PPC
: /* R_PPC_NONE. */
10371 case EM_PPC64
: /* R_PPC64_NONE. */
10372 case EM_ARM
: /* R_ARM_NONE. */
10373 case EM_IA_64
: /* R_IA64_NONE. */
10374 case EM_SH
: /* R_SH_NONE. */
10376 case EM_S390
: /* R_390_NONE. */
10377 case EM_CRIS
: /* R_CRIS_NONE. */
10378 case EM_X86_64
: /* R_X86_64_NONE. */
10379 case EM_L1OM
: /* R_X86_64_NONE. */
10380 case EM_K1OM
: /* R_X86_64_NONE. */
10381 case EM_MN10300
: /* R_MN10300_NONE. */
10382 case EM_MOXIE
: /* R_MOXIE_NONE. */
10383 case EM_M32R
: /* R_M32R_NONE. */
10384 case EM_TI_C6000
:/* R_C6000_NONE. */
10385 case EM_TILEGX
: /* R_TILEGX_NONE. */
10386 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10388 case EM_C166
: /* R_XC16X_NONE. */
10389 return reloc_type
== 0;
10391 return reloc_type
== 0 || reloc_type
== 256;
10392 case EM_XTENSA_OLD
:
10394 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10395 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10396 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10397 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10399 return reloc_type
== 3; /* R_METAG_NONE. */
10404 /* Apply relocations to a section.
10405 Note: So far support has been added only for those relocations
10406 which can be found in debug sections.
10407 FIXME: Add support for more relocations ? */
10410 apply_relocations (void * file
,
10411 Elf_Internal_Shdr
* section
,
10412 unsigned char * start
)
10414 Elf_Internal_Shdr
* relsec
;
10415 unsigned char * end
= start
+ section
->sh_size
;
10417 if (elf_header
.e_type
!= ET_REL
)
10420 /* Find the reloc section associated with the section. */
10421 for (relsec
= section_headers
;
10422 relsec
< section_headers
+ elf_header
.e_shnum
;
10425 bfd_boolean is_rela
;
10426 unsigned long num_relocs
;
10427 Elf_Internal_Rela
* relocs
;
10428 Elf_Internal_Rela
* rp
;
10429 Elf_Internal_Shdr
* symsec
;
10430 Elf_Internal_Sym
* symtab
;
10431 unsigned long num_syms
;
10432 Elf_Internal_Sym
* sym
;
10434 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10435 || relsec
->sh_info
>= elf_header
.e_shnum
10436 || section_headers
+ relsec
->sh_info
!= section
10437 || relsec
->sh_size
== 0
10438 || relsec
->sh_link
>= elf_header
.e_shnum
)
10441 is_rela
= relsec
->sh_type
== SHT_RELA
;
10445 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10446 relsec
->sh_size
, & relocs
, & num_relocs
))
10451 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10452 relsec
->sh_size
, & relocs
, & num_relocs
))
10456 /* SH uses RELA but uses in place value instead of the addend field. */
10457 if (elf_header
.e_machine
== EM_SH
)
10460 symsec
= section_headers
+ relsec
->sh_link
;
10461 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10463 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10466 unsigned int reloc_type
;
10467 unsigned int reloc_size
;
10468 unsigned char * rloc
;
10469 unsigned long sym_index
;
10471 reloc_type
= get_reloc_type (rp
->r_info
);
10473 if (target_specific_reloc_handling (rp
, start
, symtab
))
10475 else if (is_none_reloc (reloc_type
))
10477 else if (is_32bit_abs_reloc (reloc_type
)
10478 || is_32bit_pcrel_reloc (reloc_type
))
10480 else if (is_64bit_abs_reloc (reloc_type
)
10481 || is_64bit_pcrel_reloc (reloc_type
))
10483 else if (is_24bit_abs_reloc (reloc_type
))
10485 else if (is_16bit_abs_reloc (reloc_type
))
10489 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10490 reloc_type
, SECTION_NAME (section
));
10494 rloc
= start
+ rp
->r_offset
;
10495 if ((rloc
+ reloc_size
) > end
)
10497 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10498 (unsigned long) rp
->r_offset
,
10499 SECTION_NAME (section
));
10503 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10504 if (sym_index
>= num_syms
)
10506 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10507 sym_index
, SECTION_NAME (section
));
10510 sym
= symtab
+ sym_index
;
10512 /* If the reloc has a symbol associated with it,
10513 make sure that it is of an appropriate type.
10515 Relocations against symbols without type can happen.
10516 Gcc -feliminate-dwarf2-dups may generate symbols
10517 without type for debug info.
10519 Icc generates relocations against function symbols
10520 instead of local labels.
10522 Relocations against object symbols can happen, eg when
10523 referencing a global array. For an example of this see
10524 the _clz.o binary in libgcc.a. */
10526 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10528 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10529 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10530 (long int)(rp
- relocs
),
10531 SECTION_NAME (relsec
));
10537 addend
+= rp
->r_addend
;
10538 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10539 partial_inplace. */
10541 || (elf_header
.e_machine
== EM_XTENSA
10542 && reloc_type
== 1)
10543 || ((elf_header
.e_machine
== EM_PJ
10544 || elf_header
.e_machine
== EM_PJ_OLD
)
10545 && reloc_type
== 1)
10546 || ((elf_header
.e_machine
== EM_D30V
10547 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10548 && reloc_type
== 12))
10549 addend
+= byte_get (rloc
, reloc_size
);
10551 if (is_32bit_pcrel_reloc (reloc_type
)
10552 || is_64bit_pcrel_reloc (reloc_type
))
10554 /* On HPPA, all pc-relative relocations are biased by 8. */
10555 if (elf_header
.e_machine
== EM_PARISC
)
10557 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10561 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10570 #ifdef SUPPORT_DISASSEMBLY
10572 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10574 printf (_("\nAssembly dump of section %s\n"),
10575 SECTION_NAME (section
));
10577 /* XXX -- to be done --- XXX */
10583 /* Reads in the contents of SECTION from FILE, returning a pointer
10584 to a malloc'ed buffer or NULL if something went wrong. */
10587 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10589 bfd_size_type num_bytes
;
10591 num_bytes
= section
->sh_size
;
10593 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10595 printf (_("\nSection '%s' has no data to dump.\n"),
10596 SECTION_NAME (section
));
10600 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10601 _("section contents"));
10606 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10608 Elf_Internal_Shdr
* relsec
;
10609 bfd_size_type num_bytes
;
10613 char * name
= SECTION_NAME (section
);
10614 bfd_boolean some_strings_shown
;
10616 start
= get_section_contents (section
, file
);
10620 printf (_("\nString dump of section '%s':\n"), name
);
10622 /* If the section being dumped has relocations against it the user might
10623 be expecting these relocations to have been applied. Check for this
10624 case and issue a warning message in order to avoid confusion.
10625 FIXME: Maybe we ought to have an option that dumps a section with
10626 relocs applied ? */
10627 for (relsec
= section_headers
;
10628 relsec
< section_headers
+ elf_header
.e_shnum
;
10631 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10632 || relsec
->sh_info
>= elf_header
.e_shnum
10633 || section_headers
+ relsec
->sh_info
!= section
10634 || relsec
->sh_size
== 0
10635 || relsec
->sh_link
>= elf_header
.e_shnum
)
10638 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10642 num_bytes
= section
->sh_size
;
10644 end
= start
+ num_bytes
;
10645 some_strings_shown
= FALSE
;
10649 while (!ISPRINT (* data
))
10650 if (++ data
>= end
)
10656 /* PR 11128: Use two separate invocations in order to work
10657 around bugs in the Solaris 8 implementation of printf. */
10658 printf (" [%6tx] ", data
- start
);
10659 printf ("%s\n", data
);
10661 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10663 data
+= strlen (data
);
10664 some_strings_shown
= TRUE
;
10668 if (! some_strings_shown
)
10669 printf (_(" No strings found in this section."));
10677 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10679 bfd_boolean relocate
)
10681 Elf_Internal_Shdr
* relsec
;
10682 bfd_size_type bytes
;
10684 unsigned char * data
;
10685 unsigned char * start
;
10687 start
= (unsigned char *) get_section_contents (section
, file
);
10691 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10695 apply_relocations (file
, section
, start
);
10699 /* If the section being dumped has relocations against it the user might
10700 be expecting these relocations to have been applied. Check for this
10701 case and issue a warning message in order to avoid confusion.
10702 FIXME: Maybe we ought to have an option that dumps a section with
10703 relocs applied ? */
10704 for (relsec
= section_headers
;
10705 relsec
< section_headers
+ elf_header
.e_shnum
;
10708 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10709 || relsec
->sh_info
>= elf_header
.e_shnum
10710 || section_headers
+ relsec
->sh_info
!= section
10711 || relsec
->sh_size
== 0
10712 || relsec
->sh_link
>= elf_header
.e_shnum
)
10715 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10720 addr
= section
->sh_addr
;
10721 bytes
= section
->sh_size
;
10730 lbytes
= (bytes
> 16 ? 16 : bytes
);
10732 printf (" 0x%8.8lx ", (unsigned long) addr
);
10734 for (j
= 0; j
< 16; j
++)
10737 printf ("%2.2x", data
[j
]);
10745 for (j
= 0; j
< lbytes
; j
++)
10748 if (k
>= ' ' && k
< 0x7f)
10766 /* Uncompresses a section that was compressed using zlib, in place. */
10769 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10770 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10772 #ifndef HAVE_ZLIB_H
10775 dwarf_size_type compressed_size
= *size
;
10776 unsigned char * compressed_buffer
= *buffer
;
10777 dwarf_size_type uncompressed_size
;
10778 unsigned char * uncompressed_buffer
;
10781 dwarf_size_type header_size
= 12;
10783 /* Read the zlib header. In this case, it should be "ZLIB" followed
10784 by the uncompressed section size, 8 bytes in big-endian order. */
10785 if (compressed_size
< header_size
10786 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10789 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10790 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10791 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10792 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10793 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10794 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10795 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10796 uncompressed_size
+= compressed_buffer
[11];
10798 /* It is possible the section consists of several compressed
10799 buffers concatenated together, so we uncompress in a loop. */
10800 strm
.zalloc
= NULL
;
10802 strm
.opaque
= NULL
;
10803 strm
.avail_in
= compressed_size
- header_size
;
10804 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10805 strm
.avail_out
= uncompressed_size
;
10806 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10808 rc
= inflateInit (& strm
);
10809 while (strm
.avail_in
> 0)
10813 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10814 + (uncompressed_size
- strm
.avail_out
));
10815 rc
= inflate (&strm
, Z_FINISH
);
10816 if (rc
!= Z_STREAM_END
)
10818 rc
= inflateReset (& strm
);
10820 rc
= inflateEnd (& strm
);
10822 || strm
.avail_out
!= 0)
10825 free (compressed_buffer
);
10826 *buffer
= uncompressed_buffer
;
10827 *size
= uncompressed_size
;
10831 free (uncompressed_buffer
);
10832 /* Indicate decompression failure. */
10835 #endif /* HAVE_ZLIB_H */
10839 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10840 Elf_Internal_Shdr
* sec
, void * file
)
10842 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10845 /* If it is already loaded, do nothing. */
10846 if (section
->start
!= NULL
)
10849 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10850 section
->address
= sec
->sh_addr
;
10851 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10853 sec
->sh_size
, buf
);
10854 if (section
->start
== NULL
)
10858 section
->size
= sec
->sh_size
;
10859 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10860 sec
->sh_size
= section
->size
;
10863 if (section
->start
== NULL
)
10866 if (debug_displays
[debug
].relocate
)
10867 apply_relocations ((FILE *) file
, sec
, section
->start
);
10872 /* If this is not NULL, load_debug_section will only look for sections
10873 within the list of sections given here. */
10874 unsigned int *section_subset
= NULL
;
10877 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10879 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10880 Elf_Internal_Shdr
* sec
;
10882 /* Locate the debug section. */
10883 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10885 section
->name
= section
->uncompressed_name
;
10888 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10890 section
->name
= section
->compressed_name
;
10895 /* If we're loading from a subset of sections, and we've loaded
10896 a section matching this name before, it's likely that it's a
10898 if (section_subset
!= NULL
)
10899 free_debug_section (debug
);
10901 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10905 free_debug_section (enum dwarf_section_display_enum debug
)
10907 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10909 if (section
->start
== NULL
)
10912 free ((char *) section
->start
);
10913 section
->start
= NULL
;
10914 section
->address
= 0;
10919 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10921 char * name
= SECTION_NAME (section
);
10922 bfd_size_type length
;
10926 length
= section
->sh_size
;
10929 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10932 if (section
->sh_type
== SHT_NOBITS
)
10934 /* There is no point in dumping the contents of a debugging section
10935 which has the NOBITS type - the bits in the file will be random.
10936 This can happen when a file containing a .eh_frame section is
10937 stripped with the --only-keep-debug command line option. */
10938 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10942 if (const_strneq (name
, ".gnu.linkonce.wi."))
10943 name
= ".debug_info";
10945 /* See if we know how to display the contents of this section. */
10946 for (i
= 0; i
< max
; i
++)
10947 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10948 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10950 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10951 int secondary
= (section
!= find_section (name
));
10954 free_debug_section ((enum dwarf_section_display_enum
) i
);
10956 if (streq (sec
->uncompressed_name
, name
))
10957 sec
->name
= sec
->uncompressed_name
;
10959 sec
->name
= sec
->compressed_name
;
10960 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10963 /* If this debug section is part of a CU/TU set in a .dwp file,
10964 restrict load_debug_section to the sections in that set. */
10965 section_subset
= find_cu_tu_set (file
, shndx
);
10967 result
&= debug_displays
[i
].display (sec
, file
);
10969 section_subset
= NULL
;
10971 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10972 free_debug_section ((enum dwarf_section_display_enum
) i
);
10980 printf (_("Unrecognized debug section: %s\n"), name
);
10987 /* Set DUMP_SECTS for all sections where dumps were requested
10988 based on section name. */
10991 initialise_dumps_byname (void)
10993 struct dump_list_entry
* cur
;
10995 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
11000 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
11001 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
11003 request_dump_bynumber (i
, cur
->type
);
11008 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11014 process_section_contents (FILE * file
)
11016 Elf_Internal_Shdr
* section
;
11022 initialise_dumps_byname ();
11024 for (i
= 0, section
= section_headers
;
11025 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
11028 #ifdef SUPPORT_DISASSEMBLY
11029 if (dump_sects
[i
] & DISASS_DUMP
)
11030 disassemble_section (section
, file
);
11032 if (dump_sects
[i
] & HEX_DUMP
)
11033 dump_section_as_bytes (section
, file
, FALSE
);
11035 if (dump_sects
[i
] & RELOC_DUMP
)
11036 dump_section_as_bytes (section
, file
, TRUE
);
11038 if (dump_sects
[i
] & STRING_DUMP
)
11039 dump_section_as_strings (section
, file
);
11041 if (dump_sects
[i
] & DEBUG_DUMP
)
11042 display_debug_section (i
, section
, file
);
11045 /* Check to see if the user requested a
11046 dump of a section that does not exist. */
11047 while (i
++ < num_dump_sects
)
11049 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
11053 process_mips_fpe_exception (int mask
)
11058 if (mask
& OEX_FPU_INEX
)
11059 fputs ("INEX", stdout
), first
= 0;
11060 if (mask
& OEX_FPU_UFLO
)
11061 printf ("%sUFLO", first
? "" : "|"), first
= 0;
11062 if (mask
& OEX_FPU_OFLO
)
11063 printf ("%sOFLO", first
? "" : "|"), first
= 0;
11064 if (mask
& OEX_FPU_DIV0
)
11065 printf ("%sDIV0", first
? "" : "|"), first
= 0;
11066 if (mask
& OEX_FPU_INVAL
)
11067 printf ("%sINVAL", first
? "" : "|");
11070 fputs ("0", stdout
);
11073 /* ARM EABI attributes section. */
11078 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11080 const char ** table
;
11081 } arm_attr_public_tag
;
11083 static const char * arm_attr_tag_CPU_arch
[] =
11084 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11085 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11086 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11087 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11088 {"No", "Thumb-1", "Thumb-2"};
11089 static const char * arm_attr_tag_FP_arch
[] =
11090 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11092 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11093 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11094 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11095 static const char * arm_attr_tag_PCS_config
[] =
11096 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11097 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11098 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11099 {"V6", "SB", "TLS", "Unused"};
11100 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11101 {"Absolute", "PC-relative", "SB-relative", "None"};
11102 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11103 {"Absolute", "PC-relative", "None"};
11104 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11105 {"None", "direct", "GOT-indirect"};
11106 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11107 {"None", "??? 1", "2", "??? 3", "4"};
11108 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11109 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11110 {"Unused", "Needed", "Sign only"};
11111 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11112 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11113 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11114 {"Unused", "Finite", "RTABI", "IEEE 754"};
11115 static const char * arm_attr_tag_ABI_enum_size
[] =
11116 {"Unused", "small", "int", "forced to int"};
11117 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11118 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11119 static const char * arm_attr_tag_ABI_VFP_args
[] =
11120 {"AAPCS", "VFP registers", "custom"};
11121 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11122 {"AAPCS", "WMMX registers", "custom"};
11123 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11124 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11125 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11126 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11127 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11128 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11129 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11130 static const char * arm_attr_tag_FP_HP_extension
[] =
11131 {"Not Allowed", "Allowed"};
11132 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11133 {"None", "IEEE 754", "Alternative Format"};
11134 static const char * arm_attr_tag_MPextension_use
[] =
11135 {"Not Allowed", "Allowed"};
11136 static const char * arm_attr_tag_DIV_use
[] =
11137 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11138 "Allowed in v7-A with integer division extension"};
11139 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11140 static const char * arm_attr_tag_Virtualization_use
[] =
11141 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11142 "TrustZone and Virtualization Extensions"};
11143 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11144 {"Not Allowed", "Allowed"};
11146 #define LOOKUP(id, name) \
11147 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11148 static arm_attr_public_tag arm_attr_public_tags
[] =
11150 {4, "CPU_raw_name", 1, NULL
},
11151 {5, "CPU_name", 1, NULL
},
11152 LOOKUP(6, CPU_arch
),
11153 {7, "CPU_arch_profile", 0, NULL
},
11154 LOOKUP(8, ARM_ISA_use
),
11155 LOOKUP(9, THUMB_ISA_use
),
11156 LOOKUP(10, FP_arch
),
11157 LOOKUP(11, WMMX_arch
),
11158 LOOKUP(12, Advanced_SIMD_arch
),
11159 LOOKUP(13, PCS_config
),
11160 LOOKUP(14, ABI_PCS_R9_use
),
11161 LOOKUP(15, ABI_PCS_RW_data
),
11162 LOOKUP(16, ABI_PCS_RO_data
),
11163 LOOKUP(17, ABI_PCS_GOT_use
),
11164 LOOKUP(18, ABI_PCS_wchar_t
),
11165 LOOKUP(19, ABI_FP_rounding
),
11166 LOOKUP(20, ABI_FP_denormal
),
11167 LOOKUP(21, ABI_FP_exceptions
),
11168 LOOKUP(22, ABI_FP_user_exceptions
),
11169 LOOKUP(23, ABI_FP_number_model
),
11170 {24, "ABI_align_needed", 0, NULL
},
11171 {25, "ABI_align_preserved", 0, NULL
},
11172 LOOKUP(26, ABI_enum_size
),
11173 LOOKUP(27, ABI_HardFP_use
),
11174 LOOKUP(28, ABI_VFP_args
),
11175 LOOKUP(29, ABI_WMMX_args
),
11176 LOOKUP(30, ABI_optimization_goals
),
11177 LOOKUP(31, ABI_FP_optimization_goals
),
11178 {32, "compatibility", 0, NULL
},
11179 LOOKUP(34, CPU_unaligned_access
),
11180 LOOKUP(36, FP_HP_extension
),
11181 LOOKUP(38, ABI_FP_16bit_format
),
11182 LOOKUP(42, MPextension_use
),
11183 LOOKUP(44, DIV_use
),
11184 {64, "nodefaults", 0, NULL
},
11185 {65, "also_compatible_with", 0, NULL
},
11186 LOOKUP(66, T2EE_use
),
11187 {67, "conformance", 1, NULL
},
11188 LOOKUP(68, Virtualization_use
),
11189 LOOKUP(70, MPextension_use_legacy
)
11193 static unsigned char *
11194 display_arm_attribute (unsigned char * p
)
11199 arm_attr_public_tag
* attr
;
11203 tag
= read_uleb128 (p
, &len
);
11206 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11208 if (arm_attr_public_tags
[i
].tag
== tag
)
11210 attr
= &arm_attr_public_tags
[i
];
11217 printf (" Tag_%s: ", attr
->name
);
11218 switch (attr
->type
)
11223 case 7: /* Tag_CPU_arch_profile. */
11224 val
= read_uleb128 (p
, &len
);
11228 case 0: printf (_("None\n")); break;
11229 case 'A': printf (_("Application\n")); break;
11230 case 'R': printf (_("Realtime\n")); break;
11231 case 'M': printf (_("Microcontroller\n")); break;
11232 case 'S': printf (_("Application or Realtime\n")); break;
11233 default: printf ("??? (%d)\n", val
); break;
11237 case 24: /* Tag_align_needed. */
11238 val
= read_uleb128 (p
, &len
);
11242 case 0: printf (_("None\n")); break;
11243 case 1: printf (_("8-byte\n")); break;
11244 case 2: printf (_("4-byte\n")); break;
11245 case 3: printf ("??? 3\n"); break;
11248 printf (_("8-byte and up to %d-byte extended\n"),
11251 printf ("??? (%d)\n", val
);
11256 case 25: /* Tag_align_preserved. */
11257 val
= read_uleb128 (p
, &len
);
11261 case 0: printf (_("None\n")); break;
11262 case 1: printf (_("8-byte, except leaf SP\n")); break;
11263 case 2: printf (_("8-byte\n")); break;
11264 case 3: printf ("??? 3\n"); break;
11267 printf (_("8-byte and up to %d-byte extended\n"),
11270 printf ("??? (%d)\n", val
);
11275 case 32: /* Tag_compatibility. */
11276 val
= read_uleb128 (p
, &len
);
11278 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11279 p
+= strlen ((char *) p
) + 1;
11282 case 64: /* Tag_nodefaults. */
11284 printf (_("True\n"));
11287 case 65: /* Tag_also_compatible_with. */
11288 val
= read_uleb128 (p
, &len
);
11290 if (val
== 6 /* Tag_CPU_arch. */)
11292 val
= read_uleb128 (p
, &len
);
11294 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11295 printf ("??? (%d)\n", val
);
11297 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11301 while (*(p
++) != '\0' /* NUL terminator. */);
11315 assert (attr
->type
& 0x80);
11316 val
= read_uleb128 (p
, &len
);
11318 type
= attr
->type
& 0x7f;
11320 printf ("??? (%d)\n", val
);
11322 printf ("%s\n", attr
->table
[val
]);
11329 type
= 1; /* String. */
11331 type
= 2; /* uleb128. */
11332 printf (" Tag_unknown_%d: ", tag
);
11337 printf ("\"%s\"\n", p
);
11338 p
+= strlen ((char *) p
) + 1;
11342 val
= read_uleb128 (p
, &len
);
11344 printf ("%d (0x%x)\n", val
, val
);
11350 static unsigned char *
11351 display_gnu_attribute (unsigned char * p
,
11352 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11359 tag
= read_uleb128 (p
, &len
);
11362 /* Tag_compatibility is the only generic GNU attribute defined at
11366 val
= read_uleb128 (p
, &len
);
11368 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11369 p
+= strlen ((char *) p
) + 1;
11373 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11374 return display_proc_gnu_attribute (p
, tag
);
11377 type
= 1; /* String. */
11379 type
= 2; /* uleb128. */
11380 printf (" Tag_unknown_%d: ", tag
);
11384 printf ("\"%s\"\n", p
);
11385 p
+= strlen ((char *) p
) + 1;
11389 val
= read_uleb128 (p
, &len
);
11391 printf ("%d (0x%x)\n", val
, val
);
11397 static unsigned char *
11398 display_power_gnu_attribute (unsigned char * p
, int tag
)
11404 if (tag
== Tag_GNU_Power_ABI_FP
)
11406 val
= read_uleb128 (p
, &len
);
11408 printf (" Tag_GNU_Power_ABI_FP: ");
11413 printf (_("Hard or soft float\n"));
11416 printf (_("Hard float\n"));
11419 printf (_("Soft float\n"));
11422 printf (_("Single-precision hard float\n"));
11425 printf ("??? (%d)\n", val
);
11431 if (tag
== Tag_GNU_Power_ABI_Vector
)
11433 val
= read_uleb128 (p
, &len
);
11435 printf (" Tag_GNU_Power_ABI_Vector: ");
11439 printf (_("Any\n"));
11442 printf (_("Generic\n"));
11445 printf ("AltiVec\n");
11451 printf ("??? (%d)\n", val
);
11457 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11459 val
= read_uleb128 (p
, &len
);
11461 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11465 printf (_("Any\n"));
11468 printf ("r3/r4\n");
11471 printf (_("Memory\n"));
11474 printf ("??? (%d)\n", val
);
11481 type
= 1; /* String. */
11483 type
= 2; /* uleb128. */
11484 printf (" Tag_unknown_%d: ", tag
);
11488 printf ("\"%s\"\n", p
);
11489 p
+= strlen ((char *) p
) + 1;
11493 val
= read_uleb128 (p
, &len
);
11495 printf ("%d (0x%x)\n", val
, val
);
11502 display_sparc_hwcaps (int mask
)
11507 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11508 fputs ("mul32", stdout
), first
= 0;
11509 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11510 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11511 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11512 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11513 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11514 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11515 if (mask
& ELF_SPARC_HWCAP_POPC
)
11516 printf ("%spopc", first
? "" : "|"), first
= 0;
11517 if (mask
& ELF_SPARC_HWCAP_VIS
)
11518 printf ("%svis", first
? "" : "|"), first
= 0;
11519 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11520 printf ("%svis2", first
? "" : "|"), first
= 0;
11521 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11522 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11523 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11524 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11525 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11526 printf ("%svis3", first
? "" : "|"), first
= 0;
11527 if (mask
& ELF_SPARC_HWCAP_HPC
)
11528 printf ("%shpc", first
? "" : "|"), first
= 0;
11529 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11530 printf ("%srandom", first
? "" : "|"), first
= 0;
11531 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11532 printf ("%strans", first
? "" : "|"), first
= 0;
11533 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11534 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11535 if (mask
& ELF_SPARC_HWCAP_IMA
)
11536 printf ("%sima", first
? "" : "|"), first
= 0;
11537 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11538 printf ("%scspare", first
? "" : "|"), first
= 0;
11541 fputc('0', stdout
);
11542 fputc('\n', stdout
);
11545 static unsigned char *
11546 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11552 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11554 val
= read_uleb128 (p
, &len
);
11556 printf (" Tag_GNU_Sparc_HWCAPS: ");
11558 display_sparc_hwcaps (val
);
11563 type
= 1; /* String. */
11565 type
= 2; /* uleb128. */
11566 printf (" Tag_unknown_%d: ", tag
);
11570 printf ("\"%s\"\n", p
);
11571 p
+= strlen ((char *) p
) + 1;
11575 val
= read_uleb128 (p
, &len
);
11577 printf ("%d (0x%x)\n", val
, val
);
11583 static unsigned char *
11584 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11590 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11592 val
= read_uleb128 (p
, &len
);
11594 printf (" Tag_GNU_MIPS_ABI_FP: ");
11599 printf (_("Hard or soft float\n"));
11602 printf (_("Hard float (double precision)\n"));
11605 printf (_("Hard float (single precision)\n"));
11608 printf (_("Soft float\n"));
11611 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11614 printf ("??? (%d)\n", val
);
11621 type
= 1; /* String. */
11623 type
= 2; /* uleb128. */
11624 printf (" Tag_unknown_%d: ", tag
);
11628 printf ("\"%s\"\n", p
);
11629 p
+= strlen ((char *) p
) + 1;
11633 val
= read_uleb128 (p
, &len
);
11635 printf ("%d (0x%x)\n", val
, val
);
11641 static unsigned char *
11642 display_tic6x_attribute (unsigned char * p
)
11648 tag
= read_uleb128 (p
, &len
);
11654 val
= read_uleb128 (p
, &len
);
11656 printf (" Tag_ISA: ");
11660 case C6XABI_Tag_ISA_none
:
11661 printf (_("None\n"));
11663 case C6XABI_Tag_ISA_C62X
:
11666 case C6XABI_Tag_ISA_C67X
:
11669 case C6XABI_Tag_ISA_C67XP
:
11670 printf ("C67x+\n");
11672 case C6XABI_Tag_ISA_C64X
:
11675 case C6XABI_Tag_ISA_C64XP
:
11676 printf ("C64x+\n");
11678 case C6XABI_Tag_ISA_C674X
:
11679 printf ("C674x\n");
11682 printf ("??? (%d)\n", val
);
11687 case Tag_ABI_wchar_t
:
11688 val
= read_uleb128 (p
, &len
);
11690 printf (" Tag_ABI_wchar_t: ");
11694 printf (_("Not used\n"));
11697 printf (_("2 bytes\n"));
11700 printf (_("4 bytes\n"));
11703 printf ("??? (%d)\n", val
);
11708 case Tag_ABI_stack_align_needed
:
11709 val
= read_uleb128 (p
, &len
);
11711 printf (" Tag_ABI_stack_align_needed: ");
11715 printf (_("8-byte\n"));
11718 printf (_("16-byte\n"));
11721 printf ("??? (%d)\n", val
);
11726 case Tag_ABI_stack_align_preserved
:
11727 val
= read_uleb128 (p
, &len
);
11729 printf (" Tag_ABI_stack_align_preserved: ");
11733 printf (_("8-byte\n"));
11736 printf (_("16-byte\n"));
11739 printf ("??? (%d)\n", val
);
11745 val
= read_uleb128 (p
, &len
);
11747 printf (" Tag_ABI_DSBT: ");
11751 printf (_("DSBT addressing not used\n"));
11754 printf (_("DSBT addressing used\n"));
11757 printf ("??? (%d)\n", val
);
11763 val
= read_uleb128 (p
, &len
);
11765 printf (" Tag_ABI_PID: ");
11769 printf (_("Data addressing position-dependent\n"));
11772 printf (_("Data addressing position-independent, GOT near DP\n"));
11775 printf (_("Data addressing position-independent, GOT far from DP\n"));
11778 printf ("??? (%d)\n", val
);
11784 val
= read_uleb128 (p
, &len
);
11786 printf (" Tag_ABI_PIC: ");
11790 printf (_("Code addressing position-dependent\n"));
11793 printf (_("Code addressing position-independent\n"));
11796 printf ("??? (%d)\n", val
);
11801 case Tag_ABI_array_object_alignment
:
11802 val
= read_uleb128 (p
, &len
);
11804 printf (" Tag_ABI_array_object_alignment: ");
11808 printf (_("8-byte\n"));
11811 printf (_("4-byte\n"));
11814 printf (_("16-byte\n"));
11817 printf ("??? (%d)\n", val
);
11822 case Tag_ABI_array_object_align_expected
:
11823 val
= read_uleb128 (p
, &len
);
11825 printf (" Tag_ABI_array_object_align_expected: ");
11829 printf (_("8-byte\n"));
11832 printf (_("4-byte\n"));
11835 printf (_("16-byte\n"));
11838 printf ("??? (%d)\n", val
);
11843 case Tag_ABI_compatibility
:
11844 val
= read_uleb128 (p
, &len
);
11846 printf (" Tag_ABI_compatibility: ");
11847 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11848 p
+= strlen ((char *) p
) + 1;
11851 case Tag_ABI_conformance
:
11852 printf (" Tag_ABI_conformance: ");
11853 printf ("\"%s\"\n", p
);
11854 p
+= strlen ((char *) p
) + 1;
11858 printf (" Tag_unknown_%d: ", tag
);
11862 printf ("\"%s\"\n", p
);
11863 p
+= strlen ((char *) p
) + 1;
11867 val
= read_uleb128 (p
, &len
);
11869 printf ("%d (0x%x)\n", val
, val
);
11876 process_attributes (FILE * file
,
11877 const char * public_name
,
11878 unsigned int proc_type
,
11879 unsigned char * (* display_pub_attribute
) (unsigned char *),
11880 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11882 Elf_Internal_Shdr
* sect
;
11883 unsigned char * contents
;
11885 unsigned char * end
;
11886 bfd_vma section_len
;
11890 /* Find the section header so that we get the size. */
11891 for (i
= 0, sect
= section_headers
;
11892 i
< elf_header
.e_shnum
;
11895 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11898 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11899 sect
->sh_size
, _("attributes"));
11900 if (contents
== NULL
)
11906 len
= sect
->sh_size
- 1;
11912 bfd_boolean public_section
;
11913 bfd_boolean gnu_section
;
11915 section_len
= byte_get (p
, 4);
11918 if (section_len
> len
)
11920 printf (_("ERROR: Bad section length (%d > %d)\n"),
11921 (int) section_len
, (int) len
);
11925 len
-= section_len
;
11926 printf (_("Attribute Section: %s\n"), p
);
11928 if (public_name
&& streq ((char *) p
, public_name
))
11929 public_section
= TRUE
;
11931 public_section
= FALSE
;
11933 if (streq ((char *) p
, "gnu"))
11934 gnu_section
= TRUE
;
11936 gnu_section
= FALSE
;
11938 namelen
= strlen ((char *) p
) + 1;
11940 section_len
-= namelen
+ 4;
11942 while (section_len
> 0)
11948 size
= byte_get (p
, 4);
11949 if (size
> section_len
)
11951 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11952 (int) size
, (int) section_len
);
11953 size
= section_len
;
11956 section_len
-= size
;
11957 end
= p
+ size
- 1;
11963 printf (_("File Attributes\n"));
11966 printf (_("Section Attributes:"));
11969 printf (_("Symbol Attributes:"));
11975 val
= read_uleb128 (p
, &j
);
11979 printf (" %d", val
);
11984 printf (_("Unknown tag: %d\n"), tag
);
11985 public_section
= FALSE
;
11989 if (public_section
)
11992 p
= display_pub_attribute (p
);
11994 else if (gnu_section
)
11997 p
= display_gnu_attribute (p
,
11998 display_proc_gnu_attribute
);
12002 /* ??? Do something sensible, like dump hex. */
12003 printf (_(" Unknown section contexts\n"));
12010 printf (_("Unknown format '%c'\n"), *p
);
12018 process_arm_specific (FILE * file
)
12020 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
12021 display_arm_attribute
, NULL
);
12025 process_power_specific (FILE * file
)
12027 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12028 display_power_gnu_attribute
);
12032 process_sparc_specific (FILE * file
)
12034 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12035 display_sparc_gnu_attribute
);
12039 process_tic6x_specific (FILE * file
)
12041 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
12042 display_tic6x_attribute
, NULL
);
12045 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12046 Print the Address, Access and Initial fields of an entry at VMA ADDR
12047 and return the VMA of the next entry. */
12050 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12053 print_vma (addr
, LONG_HEX
);
12055 if (addr
< pltgot
+ 0xfff0)
12056 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
12058 printf ("%10s", "");
12061 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12066 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12067 print_vma (entry
, LONG_HEX
);
12069 return addr
+ (is_32bit_elf
? 4 : 8);
12072 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12073 PLTGOT. Print the Address and Initial fields of an entry at VMA
12074 ADDR and return the VMA of the next entry. */
12077 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12080 print_vma (addr
, LONG_HEX
);
12083 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12088 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12089 print_vma (entry
, LONG_HEX
);
12091 return addr
+ (is_32bit_elf
? 4 : 8);
12095 process_mips_specific (FILE * file
)
12097 Elf_Internal_Dyn
* entry
;
12098 size_t liblist_offset
= 0;
12099 size_t liblistno
= 0;
12100 size_t conflictsno
= 0;
12101 size_t options_offset
= 0;
12102 size_t conflicts_offset
= 0;
12103 size_t pltrelsz
= 0;
12105 bfd_vma pltgot
= 0;
12106 bfd_vma mips_pltgot
= 0;
12107 bfd_vma jmprel
= 0;
12108 bfd_vma local_gotno
= 0;
12109 bfd_vma gotsym
= 0;
12110 bfd_vma symtabno
= 0;
12112 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12113 display_mips_gnu_attribute
);
12115 /* We have a lot of special sections. Thanks SGI! */
12116 if (dynamic_section
== NULL
)
12117 /* No information available. */
12120 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12121 switch (entry
->d_tag
)
12123 case DT_MIPS_LIBLIST
:
12125 = offset_from_vma (file
, entry
->d_un
.d_val
,
12126 liblistno
* sizeof (Elf32_External_Lib
));
12128 case DT_MIPS_LIBLISTNO
:
12129 liblistno
= entry
->d_un
.d_val
;
12131 case DT_MIPS_OPTIONS
:
12132 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12134 case DT_MIPS_CONFLICT
:
12136 = offset_from_vma (file
, entry
->d_un
.d_val
,
12137 conflictsno
* sizeof (Elf32_External_Conflict
));
12139 case DT_MIPS_CONFLICTNO
:
12140 conflictsno
= entry
->d_un
.d_val
;
12143 pltgot
= entry
->d_un
.d_ptr
;
12145 case DT_MIPS_LOCAL_GOTNO
:
12146 local_gotno
= entry
->d_un
.d_val
;
12148 case DT_MIPS_GOTSYM
:
12149 gotsym
= entry
->d_un
.d_val
;
12151 case DT_MIPS_SYMTABNO
:
12152 symtabno
= entry
->d_un
.d_val
;
12154 case DT_MIPS_PLTGOT
:
12155 mips_pltgot
= entry
->d_un
.d_ptr
;
12158 pltrel
= entry
->d_un
.d_val
;
12161 pltrelsz
= entry
->d_un
.d_val
;
12164 jmprel
= entry
->d_un
.d_ptr
;
12170 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12172 Elf32_External_Lib
* elib
;
12175 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12177 sizeof (Elf32_External_Lib
),
12178 _("liblist section data"));
12181 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12182 (unsigned long) liblistno
);
12183 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12186 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12193 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12194 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12195 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12196 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12197 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12199 tmp
= gmtime (&atime
);
12200 snprintf (timebuf
, sizeof (timebuf
),
12201 "%04u-%02u-%02uT%02u:%02u:%02u",
12202 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12203 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12205 printf ("%3lu: ", (unsigned long) cnt
);
12206 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12207 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12209 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12210 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12211 liblist
.l_version
);
12213 if (liblist
.l_flags
== 0)
12217 static const struct
12224 { " EXACT_MATCH", LL_EXACT_MATCH
},
12225 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12226 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12227 { " EXPORTS", LL_EXPORTS
},
12228 { " DELAY_LOAD", LL_DELAY_LOAD
},
12229 { " DELTA", LL_DELTA
}
12231 int flags
= liblist
.l_flags
;
12234 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12235 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12237 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12238 flags
^= l_flags_vals
[fcnt
].bit
;
12241 printf (" %#x", (unsigned int) flags
);
12251 if (options_offset
!= 0)
12253 Elf_External_Options
* eopt
;
12254 Elf_Internal_Shdr
* sect
= section_headers
;
12255 Elf_Internal_Options
* iopt
;
12256 Elf_Internal_Options
* option
;
12260 /* Find the section header so that we get the size. */
12261 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12264 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12265 sect
->sh_size
, _("options"));
12268 iopt
= (Elf_Internal_Options
*)
12269 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12272 error (_("Out of memory\n"));
12279 while (offset
< sect
->sh_size
)
12281 Elf_External_Options
* eoption
;
12283 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12285 option
->kind
= BYTE_GET (eoption
->kind
);
12286 option
->size
= BYTE_GET (eoption
->size
);
12287 option
->section
= BYTE_GET (eoption
->section
);
12288 option
->info
= BYTE_GET (eoption
->info
);
12290 offset
+= option
->size
;
12296 printf (_("\nSection '%s' contains %d entries:\n"),
12297 SECTION_NAME (sect
), cnt
);
12305 switch (option
->kind
)
12308 /* This shouldn't happen. */
12309 printf (" NULL %d %lx", option
->section
, option
->info
);
12312 printf (" REGINFO ");
12313 if (elf_header
.e_machine
== EM_MIPS
)
12316 Elf32_External_RegInfo
* ereg
;
12317 Elf32_RegInfo reginfo
;
12319 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12320 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12321 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12322 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12323 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12324 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12325 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12327 printf ("GPR %08lx GP 0x%lx\n",
12328 reginfo
.ri_gprmask
,
12329 (unsigned long) reginfo
.ri_gp_value
);
12330 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12331 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12332 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12337 Elf64_External_RegInfo
* ereg
;
12338 Elf64_Internal_RegInfo reginfo
;
12340 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12341 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12342 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12343 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12344 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12345 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12346 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12348 printf ("GPR %08lx GP 0x",
12349 reginfo
.ri_gprmask
);
12350 printf_vma (reginfo
.ri_gp_value
);
12353 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12354 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12355 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12359 case ODK_EXCEPTIONS
:
12360 fputs (" EXCEPTIONS fpe_min(", stdout
);
12361 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12362 fputs (") fpe_max(", stdout
);
12363 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12364 fputs (")", stdout
);
12366 if (option
->info
& OEX_PAGE0
)
12367 fputs (" PAGE0", stdout
);
12368 if (option
->info
& OEX_SMM
)
12369 fputs (" SMM", stdout
);
12370 if (option
->info
& OEX_FPDBUG
)
12371 fputs (" FPDBUG", stdout
);
12372 if (option
->info
& OEX_DISMISS
)
12373 fputs (" DISMISS", stdout
);
12376 fputs (" PAD ", stdout
);
12377 if (option
->info
& OPAD_PREFIX
)
12378 fputs (" PREFIX", stdout
);
12379 if (option
->info
& OPAD_POSTFIX
)
12380 fputs (" POSTFIX", stdout
);
12381 if (option
->info
& OPAD_SYMBOL
)
12382 fputs (" SYMBOL", stdout
);
12385 fputs (" HWPATCH ", stdout
);
12386 if (option
->info
& OHW_R4KEOP
)
12387 fputs (" R4KEOP", stdout
);
12388 if (option
->info
& OHW_R8KPFETCH
)
12389 fputs (" R8KPFETCH", stdout
);
12390 if (option
->info
& OHW_R5KEOP
)
12391 fputs (" R5KEOP", stdout
);
12392 if (option
->info
& OHW_R5KCVTL
)
12393 fputs (" R5KCVTL", stdout
);
12396 fputs (" FILL ", stdout
);
12397 /* XXX Print content of info word? */
12400 fputs (" TAGS ", stdout
);
12401 /* XXX Print content of info word? */
12404 fputs (" HWAND ", stdout
);
12405 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12406 fputs (" R4KEOP_CHECKED", stdout
);
12407 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12408 fputs (" R4KEOP_CLEAN", stdout
);
12411 fputs (" HWOR ", stdout
);
12412 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12413 fputs (" R4KEOP_CHECKED", stdout
);
12414 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12415 fputs (" R4KEOP_CLEAN", stdout
);
12418 printf (" GP_GROUP %#06lx self-contained %#06lx",
12419 option
->info
& OGP_GROUP
,
12420 (option
->info
& OGP_SELF
) >> 16);
12423 printf (" IDENT %#06lx self-contained %#06lx",
12424 option
->info
& OGP_GROUP
,
12425 (option
->info
& OGP_SELF
) >> 16);
12428 /* This shouldn't happen. */
12429 printf (" %3d ??? %d %lx",
12430 option
->kind
, option
->section
, option
->info
);
12434 len
= sizeof (* eopt
);
12435 while (len
< option
->size
)
12436 if (((char *) option
)[len
] >= ' '
12437 && ((char *) option
)[len
] < 0x7f)
12438 printf ("%c", ((char *) option
)[len
++]);
12440 printf ("\\%03o", ((char *) option
)[len
++]);
12442 fputs ("\n", stdout
);
12450 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12452 Elf32_Conflict
* iconf
;
12455 if (dynamic_symbols
== NULL
)
12457 error (_("conflict list found without a dynamic symbol table\n"));
12461 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12464 error (_("Out of memory\n"));
12470 Elf32_External_Conflict
* econf32
;
12472 econf32
= (Elf32_External_Conflict
*)
12473 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12474 sizeof (* econf32
), _("conflict"));
12478 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12479 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12485 Elf64_External_Conflict
* econf64
;
12487 econf64
= (Elf64_External_Conflict
*)
12488 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12489 sizeof (* econf64
), _("conflict"));
12493 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12494 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12499 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12500 (unsigned long) conflictsno
);
12501 puts (_(" Num: Index Value Name"));
12503 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12505 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12507 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12508 print_vma (psym
->st_value
, FULL_HEX
);
12510 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12511 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12513 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12520 if (pltgot
!= 0 && local_gotno
!= 0)
12522 bfd_vma ent
, local_end
, global_end
;
12524 unsigned char * data
;
12528 addr_size
= (is_32bit_elf
? 4 : 8);
12529 local_end
= pltgot
+ local_gotno
* addr_size
;
12530 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12532 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12533 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12534 global_end
- pltgot
, 1,
12535 _("Global Offset Table data"));
12539 printf (_("\nPrimary GOT:\n"));
12540 printf (_(" Canonical gp value: "));
12541 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12544 printf (_(" Reserved entries:\n"));
12545 printf (_(" %*s %10s %*s Purpose\n"),
12546 addr_size
* 2, _("Address"), _("Access"),
12547 addr_size
* 2, _("Initial"));
12548 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12549 printf (_(" Lazy resolver\n"));
12551 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12552 >> (addr_size
* 8 - 1)) != 0)
12554 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12555 printf (_(" Module pointer (GNU extension)\n"));
12559 if (ent
< local_end
)
12561 printf (_(" Local entries:\n"));
12562 printf (" %*s %10s %*s\n",
12563 addr_size
* 2, _("Address"), _("Access"),
12564 addr_size
* 2, _("Initial"));
12565 while (ent
< local_end
)
12567 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12573 if (gotsym
< symtabno
)
12577 printf (_(" Global entries:\n"));
12578 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12579 addr_size
* 2, _("Address"),
12581 addr_size
* 2, _("Initial"),
12582 addr_size
* 2, _("Sym.Val."),
12584 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12585 _("Ndx"), _("Name"));
12587 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12588 for (i
= gotsym
; i
< symtabno
; i
++)
12590 Elf_Internal_Sym
* psym
;
12592 psym
= dynamic_symbols
+ i
;
12593 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12595 print_vma (psym
->st_value
, LONG_HEX
);
12596 printf (" %-7s %3s ",
12597 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12598 get_symbol_index_type (psym
->st_shndx
));
12599 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12600 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12602 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12612 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12615 size_t offset
, rel_offset
;
12616 unsigned long count
, i
;
12617 unsigned char * data
;
12618 int addr_size
, sym_width
;
12619 Elf_Internal_Rela
* rels
;
12621 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12622 if (pltrel
== DT_RELA
)
12624 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12629 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12634 addr_size
= (is_32bit_elf
? 4 : 8);
12635 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12637 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12638 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12639 1, _("Procedure Linkage Table data"));
12643 printf ("\nPLT GOT:\n\n");
12644 printf (_(" Reserved entries:\n"));
12645 printf (_(" %*s %*s Purpose\n"),
12646 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12647 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12648 printf (_(" PLT lazy resolver\n"));
12649 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12650 printf (_(" Module pointer\n"));
12653 printf (_(" Entries:\n"));
12654 printf (" %*s %*s %*s %-7s %3s %s\n",
12655 addr_size
* 2, _("Address"),
12656 addr_size
* 2, _("Initial"),
12657 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12658 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12659 for (i
= 0; i
< count
; i
++)
12661 Elf_Internal_Sym
* psym
;
12663 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12664 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12666 print_vma (psym
->st_value
, LONG_HEX
);
12667 printf (" %-7s %3s ",
12668 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12669 get_symbol_index_type (psym
->st_shndx
));
12670 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12671 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12673 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12687 process_gnu_liblist (FILE * file
)
12689 Elf_Internal_Shdr
* section
;
12690 Elf_Internal_Shdr
* string_sec
;
12691 Elf32_External_Lib
* elib
;
12693 size_t strtab_size
;
12700 for (i
= 0, section
= section_headers
;
12701 i
< elf_header
.e_shnum
;
12704 switch (section
->sh_type
)
12706 case SHT_GNU_LIBLIST
:
12707 if (section
->sh_link
>= elf_header
.e_shnum
)
12710 elib
= (Elf32_External_Lib
*)
12711 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12712 _("liblist section data"));
12716 string_sec
= section_headers
+ section
->sh_link
;
12718 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12719 string_sec
->sh_size
,
12720 _("liblist string table"));
12722 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12728 strtab_size
= string_sec
->sh_size
;
12730 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12731 SECTION_NAME (section
),
12732 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12734 puts (_(" Library Time Stamp Checksum Version Flags"));
12736 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12744 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12745 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12746 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12747 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12748 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12750 tmp
= gmtime (&atime
);
12751 snprintf (timebuf
, sizeof (timebuf
),
12752 "%04u-%02u-%02uT%02u:%02u:%02u",
12753 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12754 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12756 printf ("%3lu: ", (unsigned long) cnt
);
12758 printf ("%-20s", liblist
.l_name
< strtab_size
12759 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12761 printf ("%-20.20s", liblist
.l_name
< strtab_size
12762 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12763 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12764 liblist
.l_version
, liblist
.l_flags
);
12775 static const char *
12776 get_note_type (unsigned e_type
)
12778 static char buff
[64];
12780 if (elf_header
.e_type
== ET_CORE
)
12784 return _("NT_AUXV (auxiliary vector)");
12786 return _("NT_PRSTATUS (prstatus structure)");
12788 return _("NT_FPREGSET (floating point registers)");
12790 return _("NT_PRPSINFO (prpsinfo structure)");
12791 case NT_TASKSTRUCT
:
12792 return _("NT_TASKSTRUCT (task structure)");
12794 return _("NT_PRXFPREG (user_xfpregs structure)");
12796 return _("NT_PPC_VMX (ppc Altivec registers)");
12798 return _("NT_PPC_VSX (ppc VSX registers)");
12800 return _("NT_386_TLS (x86 TLS information)");
12801 case NT_386_IOPERM
:
12802 return _("NT_386_IOPERM (x86 I/O permissions)");
12803 case NT_X86_XSTATE
:
12804 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12805 case NT_S390_HIGH_GPRS
:
12806 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12807 case NT_S390_TIMER
:
12808 return _("NT_S390_TIMER (s390 timer register)");
12809 case NT_S390_TODCMP
:
12810 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12811 case NT_S390_TODPREG
:
12812 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12814 return _("NT_S390_CTRS (s390 control registers)");
12815 case NT_S390_PREFIX
:
12816 return _("NT_S390_PREFIX (s390 prefix register)");
12817 case NT_S390_LAST_BREAK
:
12818 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
12819 case NT_S390_SYSTEM_CALL
:
12820 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
12822 return _("NT_ARM_VFP (arm VFP registers)");
12824 return _("NT_ARM_TLS (AArch TLS registers)");
12825 case NT_ARM_HW_BREAK
:
12826 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12827 case NT_ARM_HW_WATCH
:
12828 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12830 return _("NT_PSTATUS (pstatus structure)");
12832 return _("NT_FPREGS (floating point registers)");
12834 return _("NT_PSINFO (psinfo structure)");
12836 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12838 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12839 case NT_WIN32PSTATUS
:
12840 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12842 return _("NT_SIGINFO (siginfo_t data)");
12844 return _("NT_FILE (mapped files)");
12852 return _("NT_VERSION (version)");
12854 return _("NT_ARCH (architecture)");
12859 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12864 print_core_note (Elf_Internal_Note
*pnote
)
12866 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12867 bfd_vma count
, page_size
;
12868 unsigned char *descdata
, *filenames
, *descend
;
12870 if (pnote
->type
!= NT_FILE
)
12876 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12877 /* Still "successful". */
12882 if (pnote
->descsz
< 2 * addr_size
)
12884 printf (_(" Malformed note - too short for header\n"));
12888 descdata
= (unsigned char *) pnote
->descdata
;
12889 descend
= descdata
+ pnote
->descsz
;
12891 if (descdata
[pnote
->descsz
- 1] != '\0')
12893 printf (_(" Malformed note - does not end with \\0\n"));
12897 count
= byte_get (descdata
, addr_size
);
12898 descdata
+= addr_size
;
12900 page_size
= byte_get (descdata
, addr_size
);
12901 descdata
+= addr_size
;
12903 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12905 printf (_(" Malformed note - too short for supplied file count\n"));
12909 printf (_(" Page size: "));
12910 print_vma (page_size
, DEC
);
12913 printf (_(" %*s%*s%*s\n"),
12914 (int) (2 + 2 * addr_size
), _("Start"),
12915 (int) (4 + 2 * addr_size
), _("End"),
12916 (int) (4 + 2 * addr_size
), _("Page Offset"));
12917 filenames
= descdata
+ count
* 3 * addr_size
;
12918 while (--count
> 0)
12920 bfd_vma start
, end
, file_ofs
;
12922 if (filenames
== descend
)
12924 printf (_(" Malformed note - filenames end too early\n"));
12928 start
= byte_get (descdata
, addr_size
);
12929 descdata
+= addr_size
;
12930 end
= byte_get (descdata
, addr_size
);
12931 descdata
+= addr_size
;
12932 file_ofs
= byte_get (descdata
, addr_size
);
12933 descdata
+= addr_size
;
12936 print_vma (start
, FULL_HEX
);
12938 print_vma (end
, FULL_HEX
);
12940 print_vma (file_ofs
, FULL_HEX
);
12941 printf ("\n %s\n", filenames
);
12943 filenames
+= 1 + strlen ((char *) filenames
);
12949 static const char *
12950 get_gnu_elf_note_type (unsigned e_type
)
12952 static char buff
[64];
12956 case NT_GNU_ABI_TAG
:
12957 return _("NT_GNU_ABI_TAG (ABI version tag)");
12959 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12960 case NT_GNU_BUILD_ID
:
12961 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12962 case NT_GNU_GOLD_VERSION
:
12963 return _("NT_GNU_GOLD_VERSION (gold version)");
12968 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12973 print_gnu_note (Elf_Internal_Note
*pnote
)
12975 switch (pnote
->type
)
12977 case NT_GNU_BUILD_ID
:
12981 printf (_(" Build ID: "));
12982 for (i
= 0; i
< pnote
->descsz
; ++i
)
12983 printf ("%02x", pnote
->descdata
[i
] & 0xff);
12988 case NT_GNU_ABI_TAG
:
12990 unsigned long os
, major
, minor
, subminor
;
12991 const char *osname
;
12993 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
12994 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
12995 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
12996 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
13000 case GNU_ABI_TAG_LINUX
:
13003 case GNU_ABI_TAG_HURD
:
13006 case GNU_ABI_TAG_SOLARIS
:
13007 osname
= "Solaris";
13009 case GNU_ABI_TAG_FREEBSD
:
13010 osname
= "FreeBSD";
13012 case GNU_ABI_TAG_NETBSD
:
13016 osname
= "Unknown";
13020 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
13021 major
, minor
, subminor
);
13029 static const char *
13030 get_netbsd_elfcore_note_type (unsigned e_type
)
13032 static char buff
[64];
13034 if (e_type
== NT_NETBSDCORE_PROCINFO
)
13036 /* NetBSD core "procinfo" structure. */
13037 return _("NetBSD procinfo structure");
13040 /* As of Jan 2002 there are no other machine-independent notes
13041 defined for NetBSD core files. If the note type is less
13042 than the start of the machine-dependent note types, we don't
13045 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
13047 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13051 switch (elf_header
.e_machine
)
13053 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13054 and PT_GETFPREGS == mach+2. */
13059 case EM_SPARC32PLUS
:
13063 case NT_NETBSDCORE_FIRSTMACH
+ 0:
13064 return _("PT_GETREGS (reg structure)");
13065 case NT_NETBSDCORE_FIRSTMACH
+ 2:
13066 return _("PT_GETFPREGS (fpreg structure)");
13072 /* On all other arch's, PT_GETREGS == mach+1 and
13073 PT_GETFPREGS == mach+3. */
13077 case NT_NETBSDCORE_FIRSTMACH
+ 1:
13078 return _("PT_GETREGS (reg structure)");
13079 case NT_NETBSDCORE_FIRSTMACH
+ 3:
13080 return _("PT_GETFPREGS (fpreg structure)");
13086 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13087 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13091 static const char *
13092 get_stapsdt_note_type (unsigned e_type
)
13094 static char buff
[64];
13099 return _("NT_STAPSDT (SystemTap probe descriptors)");
13105 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13110 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13112 int addr_size
= is_32bit_elf
? 4 : 8;
13113 char *data
= pnote
->descdata
;
13114 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13115 bfd_vma pc
, base_addr
, semaphore
;
13116 char *provider
, *probe
, *arg_fmt
;
13118 pc
= byte_get ((unsigned char *) data
, addr_size
);
13120 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13122 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13126 data
+= strlen (data
) + 1;
13128 data
+= strlen (data
) + 1;
13130 data
+= strlen (data
) + 1;
13132 printf (_(" Provider: %s\n"), provider
);
13133 printf (_(" Name: %s\n"), probe
);
13134 printf (_(" Location: "));
13135 print_vma (pc
, FULL_HEX
);
13136 printf (_(", Base: "));
13137 print_vma (base_addr
, FULL_HEX
);
13138 printf (_(", Semaphore: "));
13139 print_vma (semaphore
, FULL_HEX
);
13141 printf (_(" Arguments: %s\n"), arg_fmt
);
13143 return data
== data_end
;
13146 static const char *
13147 get_ia64_vms_note_type (unsigned e_type
)
13149 static char buff
[64];
13154 return _("NT_VMS_MHD (module header)");
13156 return _("NT_VMS_LNM (language name)");
13158 return _("NT_VMS_SRC (source files)");
13160 return "NT_VMS_TITLE";
13162 return _("NT_VMS_EIDC (consistency check)");
13163 case NT_VMS_FPMODE
:
13164 return _("NT_VMS_FPMODE (FP mode)");
13165 case NT_VMS_LINKTIME
:
13166 return "NT_VMS_LINKTIME";
13167 case NT_VMS_IMGNAM
:
13168 return _("NT_VMS_IMGNAM (image name)");
13170 return _("NT_VMS_IMGID (image id)");
13171 case NT_VMS_LINKID
:
13172 return _("NT_VMS_LINKID (link id)");
13173 case NT_VMS_IMGBID
:
13174 return _("NT_VMS_IMGBID (build id)");
13175 case NT_VMS_GSTNAM
:
13176 return _("NT_VMS_GSTNAM (sym table name)");
13177 case NT_VMS_ORIG_DYN
:
13178 return "NT_VMS_ORIG_DYN";
13179 case NT_VMS_PATCHTIME
:
13180 return "NT_VMS_PATCHTIME";
13182 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13188 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13190 switch (pnote
->type
)
13193 if (pnote
->descsz
> 36)
13195 size_t l
= strlen (pnote
->descdata
+ 34);
13196 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13197 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13198 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13199 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13202 printf (_(" Invalid size\n"));
13205 printf (_(" Language: %s\n"), pnote
->descdata
);
13208 case NT_VMS_FPMODE
:
13209 printf (_(" Floating Point mode: "));
13210 printf ("0x%016" BFD_VMA_FMT
"x\n",
13211 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13213 case NT_VMS_LINKTIME
:
13214 printf (_(" Link time: "));
13216 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13219 case NT_VMS_PATCHTIME
:
13220 printf (_(" Patch time: "));
13222 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13225 case NT_VMS_ORIG_DYN
:
13226 printf (_(" Major id: %u, minor id: %u\n"),
13227 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13228 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13229 printf (_(" Last modified : "));
13231 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13232 printf (_("\n Link flags : "));
13233 printf ("0x%016" BFD_VMA_FMT
"x\n",
13234 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13235 printf (_(" Header flags: 0x%08x\n"),
13236 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13237 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13240 case NT_VMS_IMGNAM
:
13241 printf (_(" Image name: %s\n"), pnote
->descdata
);
13243 case NT_VMS_GSTNAM
:
13244 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13247 printf (_(" Image id: %s\n"), pnote
->descdata
);
13249 case NT_VMS_LINKID
:
13250 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13258 /* Note that by the ELF standard, the name field is already null byte
13259 terminated, and namesz includes the terminating null byte.
13260 I.E. the value of namesz for the name "FSF" is 4.
13262 If the value of namesz is zero, there is no name present. */
13264 process_note (Elf_Internal_Note
* pnote
)
13266 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13269 if (pnote
->namesz
== 0)
13270 /* If there is no note name, then use the default set of
13271 note type strings. */
13272 nt
= get_note_type (pnote
->type
);
13274 else if (const_strneq (pnote
->namedata
, "GNU"))
13275 /* GNU-specific object file notes. */
13276 nt
= get_gnu_elf_note_type (pnote
->type
);
13278 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13279 /* NetBSD-specific core file notes. */
13280 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13282 else if (strneq (pnote
->namedata
, "SPU/", 4))
13284 /* SPU-specific core file notes. */
13285 nt
= pnote
->namedata
+ 4;
13289 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13290 /* VMS/ia64-specific file notes. */
13291 nt
= get_ia64_vms_note_type (pnote
->type
);
13293 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13294 nt
= get_stapsdt_note_type (pnote
->type
);
13297 /* Don't recognize this note name; just use the default set of
13298 note type strings. */
13299 nt
= get_note_type (pnote
->type
);
13301 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13303 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13304 return print_ia64_vms_note (pnote
);
13305 else if (const_strneq (pnote
->namedata
, "GNU"))
13306 return print_gnu_note (pnote
);
13307 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13308 return print_stapsdt_note (pnote
);
13309 else if (const_strneq (pnote
->namedata
, "CORE"))
13310 return print_core_note (pnote
);
13317 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13319 Elf_External_Note
* pnotes
;
13320 Elf_External_Note
* external
;
13326 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13328 if (pnotes
== NULL
)
13333 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13334 (unsigned long) offset
, (unsigned long) length
);
13335 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13337 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13339 Elf_External_Note
* next
;
13340 Elf_Internal_Note inote
;
13341 char * temp
= NULL
;
13343 if (!is_ia64_vms ())
13345 inote
.type
= BYTE_GET (external
->type
);
13346 inote
.namesz
= BYTE_GET (external
->namesz
);
13347 inote
.namedata
= external
->name
;
13348 inote
.descsz
= BYTE_GET (external
->descsz
);
13349 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13350 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13352 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13356 Elf64_External_VMS_Note
*vms_external
;
13358 vms_external
= (Elf64_External_VMS_Note
*)external
;
13359 inote
.type
= BYTE_GET (vms_external
->type
);
13360 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13361 inote
.namedata
= vms_external
->name
;
13362 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13363 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13364 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13366 next
= (Elf_External_Note
*)
13367 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13370 if ( ((char *) next
> ((char *) pnotes
) + length
)
13371 || ((char *) next
< (char *) pnotes
))
13373 warn (_("corrupt note found at offset %lx into core notes\n"),
13374 (unsigned long) ((char *) external
- (char *) pnotes
));
13375 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13376 inote
.type
, inote
.namesz
, inote
.descsz
);
13382 /* Prevent out-of-bounds indexing. */
13383 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13384 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13386 warn (_("corrupt note found at offset %lx into core notes\n"),
13387 (unsigned long) ((char *) external
- (char *) pnotes
));
13388 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13389 inote
.type
, inote
.namesz
, inote
.descsz
);
13393 /* Verify that name is null terminated. It appears that at least
13394 one version of Linux (RedHat 6.0) generates corefiles that don't
13395 comply with the ELF spec by failing to include the null byte in
13397 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13399 temp
= (char *) malloc (inote
.namesz
+ 1);
13403 error (_("Out of memory\n"));
13408 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13409 temp
[inote
.namesz
] = 0;
13411 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13412 inote
.namedata
= temp
;
13415 res
&= process_note (& inote
);
13430 process_corefile_note_segments (FILE * file
)
13432 Elf_Internal_Phdr
* segment
;
13436 if (! get_program_headers (file
))
13439 for (i
= 0, segment
= program_headers
;
13440 i
< elf_header
.e_phnum
;
13443 if (segment
->p_type
== PT_NOTE
)
13444 res
&= process_corefile_note_segment (file
,
13445 (bfd_vma
) segment
->p_offset
,
13446 (bfd_vma
) segment
->p_filesz
);
13453 process_note_sections (FILE * file
)
13455 Elf_Internal_Shdr
* section
;
13459 for (i
= 0, section
= section_headers
;
13460 i
< elf_header
.e_shnum
&& section
!= NULL
;
13462 if (section
->sh_type
== SHT_NOTE
)
13463 res
&= process_corefile_note_segment (file
,
13464 (bfd_vma
) section
->sh_offset
,
13465 (bfd_vma
) section
->sh_size
);
13471 process_notes (FILE * file
)
13473 /* If we have not been asked to display the notes then do nothing. */
13477 if (elf_header
.e_type
!= ET_CORE
)
13478 return process_note_sections (file
);
13480 /* No program headers means no NOTE segment. */
13481 if (elf_header
.e_phnum
> 0)
13482 return process_corefile_note_segments (file
);
13484 printf (_("No note segments present in the core file.\n"));
13489 process_arch_specific (FILE * file
)
13494 switch (elf_header
.e_machine
)
13497 return process_arm_specific (file
);
13499 case EM_MIPS_RS3_LE
:
13500 return process_mips_specific (file
);
13503 return process_power_specific (file
);
13506 case EM_SPARC32PLUS
:
13508 return process_sparc_specific (file
);
13511 return process_tic6x_specific (file
);
13520 get_file_header (FILE * file
)
13522 /* Read in the identity array. */
13523 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13526 /* Determine how to read the rest of the header. */
13527 switch (elf_header
.e_ident
[EI_DATA
])
13529 default: /* fall through */
13530 case ELFDATANONE
: /* fall through */
13532 byte_get
= byte_get_little_endian
;
13533 byte_put
= byte_put_little_endian
;
13536 byte_get
= byte_get_big_endian
;
13537 byte_put
= byte_put_big_endian
;
13541 /* For now we only support 32 bit and 64 bit ELF files. */
13542 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13544 /* Read in the rest of the header. */
13547 Elf32_External_Ehdr ehdr32
;
13549 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13552 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13553 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13554 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13555 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13556 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13557 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13558 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13559 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13560 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13561 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13562 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13563 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13564 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13568 Elf64_External_Ehdr ehdr64
;
13570 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13571 we will not be able to cope with the 64bit data found in
13572 64 ELF files. Detect this now and abort before we start
13573 overwriting things. */
13574 if (sizeof (bfd_vma
) < 8)
13576 error (_("This instance of readelf has been built without support for a\n\
13577 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13581 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13584 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13585 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13586 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13587 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13588 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13589 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13590 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13591 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13592 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13593 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13594 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13595 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13596 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13599 if (elf_header
.e_shoff
)
13601 /* There may be some extensions in the first section header. Don't
13602 bomb if we can't read it. */
13604 get_32bit_section_headers (file
, 1);
13606 get_64bit_section_headers (file
, 1);
13612 /* Process one ELF object file according to the command line options.
13613 This file may actually be stored in an archive. The file is
13614 positioned at the start of the ELF object. */
13617 process_object (char * file_name
, FILE * file
)
13621 if (! get_file_header (file
))
13623 error (_("%s: Failed to read file header\n"), file_name
);
13627 /* Initialise per file variables. */
13628 for (i
= ARRAY_SIZE (version_info
); i
--;)
13629 version_info
[i
] = 0;
13631 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13632 dynamic_info
[i
] = 0;
13633 dynamic_info_DT_GNU_HASH
= 0;
13635 /* Process the file. */
13637 printf (_("\nFile: %s\n"), file_name
);
13639 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13640 Note we do this even if cmdline_dump_sects is empty because we
13641 must make sure that the dump_sets array is zeroed out before each
13642 object file is processed. */
13643 if (num_dump_sects
> num_cmdline_dump_sects
)
13644 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13646 if (num_cmdline_dump_sects
> 0)
13648 if (num_dump_sects
== 0)
13649 /* A sneaky way of allocating the dump_sects array. */
13650 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13652 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13653 memcpy (dump_sects
, cmdline_dump_sects
,
13654 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13657 if (! process_file_header ())
13660 if (! process_section_headers (file
))
13662 /* Without loaded section headers we cannot process lots of
13664 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13666 if (! do_using_dynamic
)
13667 do_syms
= do_dyn_syms
= do_reloc
= 0;
13670 if (! process_section_groups (file
))
13672 /* Without loaded section groups we cannot process unwind. */
13676 if (process_program_headers (file
))
13677 process_dynamic_section (file
);
13679 process_relocs (file
);
13681 process_unwind (file
);
13683 process_symbol_table (file
);
13685 process_syminfo (file
);
13687 process_version_sections (file
);
13689 process_section_contents (file
);
13691 process_notes (file
);
13693 process_gnu_liblist (file
);
13695 process_arch_specific (file
);
13697 if (program_headers
)
13699 free (program_headers
);
13700 program_headers
= NULL
;
13703 if (section_headers
)
13705 free (section_headers
);
13706 section_headers
= NULL
;
13711 free (string_table
);
13712 string_table
= NULL
;
13713 string_table_length
= 0;
13716 if (dynamic_strings
)
13718 free (dynamic_strings
);
13719 dynamic_strings
= NULL
;
13720 dynamic_strings_length
= 0;
13723 if (dynamic_symbols
)
13725 free (dynamic_symbols
);
13726 dynamic_symbols
= NULL
;
13727 num_dynamic_syms
= 0;
13730 if (dynamic_syminfo
)
13732 free (dynamic_syminfo
);
13733 dynamic_syminfo
= NULL
;
13736 if (dynamic_section
)
13738 free (dynamic_section
);
13739 dynamic_section
= NULL
;
13742 if (section_headers_groups
)
13744 free (section_headers_groups
);
13745 section_headers_groups
= NULL
;
13748 if (section_groups
)
13750 struct group_list
* g
;
13751 struct group_list
* next
;
13753 for (i
= 0; i
< group_count
; i
++)
13755 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13762 free (section_groups
);
13763 section_groups
= NULL
;
13766 free_debug_memory ();
13771 /* Process an ELF archive.
13772 On entry the file is positioned just after the ARMAG string. */
13775 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13777 struct archive_info arch
;
13778 struct archive_info nested_arch
;
13784 /* The ARCH structure is used to hold information about this archive. */
13785 arch
.file_name
= NULL
;
13787 arch
.index_array
= NULL
;
13788 arch
.sym_table
= NULL
;
13789 arch
.longnames
= NULL
;
13791 /* The NESTED_ARCH structure is used as a single-item cache of information
13792 about a nested archive (when members of a thin archive reside within
13793 another regular archive file). */
13794 nested_arch
.file_name
= NULL
;
13795 nested_arch
.file
= NULL
;
13796 nested_arch
.index_array
= NULL
;
13797 nested_arch
.sym_table
= NULL
;
13798 nested_arch
.longnames
= NULL
;
13800 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13806 if (do_archive_index
)
13808 if (arch
.sym_table
== NULL
)
13809 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13813 unsigned long current_pos
;
13815 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13816 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13817 current_pos
= ftell (file
);
13819 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13821 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13823 char * member_name
;
13825 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13827 if (member_name
!= NULL
)
13829 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13831 if (qualified_name
!= NULL
)
13833 printf (_("Contents of binary %s at offset "), qualified_name
);
13834 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13836 free (qualified_name
);
13841 if (l
>= arch
.sym_size
)
13843 error (_("%s: end of the symbol table reached before the end of the index\n"),
13847 printf ("\t%s\n", arch
.sym_table
+ l
);
13848 l
+= strlen (arch
.sym_table
+ l
) + 1;
13851 if (arch
.uses_64bit_indicies
)
13856 if (l
< arch
.sym_size
)
13857 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13858 file_name
, arch
.sym_size
- l
);
13860 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13862 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13868 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13869 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13870 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13871 && !do_section_groups
&& !do_dyn_syms
)
13873 ret
= 0; /* Archive index only. */
13884 char * qualified_name
;
13886 /* Read the next archive header. */
13887 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13889 error (_("%s: failed to seek to next archive header\n"), file_name
);
13892 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13893 if (got
!= sizeof arch
.arhdr
)
13897 error (_("%s: failed to read archive header\n"), file_name
);
13901 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13903 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13908 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13910 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13911 if (archive_file_size
& 01)
13912 ++archive_file_size
;
13914 name
= get_archive_member_name (&arch
, &nested_arch
);
13917 error (_("%s: bad archive file name\n"), file_name
);
13921 namelen
= strlen (name
);
13923 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13924 if (qualified_name
== NULL
)
13926 error (_("%s: bad archive file name\n"), file_name
);
13931 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13933 /* This is a proxy for an external member of a thin archive. */
13934 FILE * member_file
;
13935 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13936 if (member_file_name
== NULL
)
13942 member_file
= fopen (member_file_name
, "rb");
13943 if (member_file
== NULL
)
13945 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13946 free (member_file_name
);
13951 archive_file_offset
= arch
.nested_member_origin
;
13953 ret
|= process_object (qualified_name
, member_file
);
13955 fclose (member_file
);
13956 free (member_file_name
);
13958 else if (is_thin_archive
)
13960 /* This is a proxy for a member of a nested archive. */
13961 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13963 /* The nested archive file will have been opened and setup by
13964 get_archive_member_name. */
13965 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13967 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13972 ret
|= process_object (qualified_name
, nested_arch
.file
);
13976 archive_file_offset
= arch
.next_arhdr_offset
;
13977 arch
.next_arhdr_offset
+= archive_file_size
;
13979 ret
|= process_object (qualified_name
, file
);
13982 if (dump_sects
!= NULL
)
13986 num_dump_sects
= 0;
13989 free (qualified_name
);
13993 if (nested_arch
.file
!= NULL
)
13994 fclose (nested_arch
.file
);
13995 release_archive (&nested_arch
);
13996 release_archive (&arch
);
14002 process_file (char * file_name
)
14005 struct stat statbuf
;
14006 char armag
[SARMAG
];
14009 if (stat (file_name
, &statbuf
) < 0)
14011 if (errno
== ENOENT
)
14012 error (_("'%s': No such file\n"), file_name
);
14014 error (_("Could not locate '%s'. System error message: %s\n"),
14015 file_name
, strerror (errno
));
14019 if (! S_ISREG (statbuf
.st_mode
))
14021 error (_("'%s' is not an ordinary file\n"), file_name
);
14025 file
= fopen (file_name
, "rb");
14028 error (_("Input file '%s' is not readable.\n"), file_name
);
14032 if (fread (armag
, SARMAG
, 1, file
) != 1)
14034 error (_("%s: Failed to read file's magic number\n"), file_name
);
14039 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
14040 ret
= process_archive (file_name
, file
, FALSE
);
14041 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
14042 ret
= process_archive (file_name
, file
, TRUE
);
14045 if (do_archive_index
)
14046 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14050 archive_file_size
= archive_file_offset
= 0;
14051 ret
= process_object (file_name
, file
);
14059 #ifdef SUPPORT_DISASSEMBLY
14060 /* Needed by the i386 disassembler. For extra credit, someone could
14061 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14065 print_address (unsigned int addr
, FILE * outfile
)
14067 fprintf (outfile
,"0x%8.8x", addr
);
14070 /* Needed by the i386 disassembler. */
14072 db_task_printsym (unsigned int addr
)
14074 print_address (addr
, stderr
);
14079 main (int argc
, char ** argv
)
14083 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14084 setlocale (LC_MESSAGES
, "");
14086 #if defined (HAVE_SETLOCALE)
14087 setlocale (LC_CTYPE
, "");
14089 bindtextdomain (PACKAGE
, LOCALEDIR
);
14090 textdomain (PACKAGE
);
14092 expandargv (&argc
, &argv
);
14094 parse_args (argc
, argv
);
14096 if (num_dump_sects
> 0)
14098 /* Make a copy of the dump_sects array. */
14099 cmdline_dump_sects
= (dump_type
*)
14100 malloc (num_dump_sects
* sizeof (* dump_sects
));
14101 if (cmdline_dump_sects
== NULL
)
14102 error (_("Out of memory allocating dump request table.\n"));
14105 memcpy (cmdline_dump_sects
, dump_sects
,
14106 num_dump_sects
* sizeof (* dump_sects
));
14107 num_cmdline_dump_sects
= num_dump_sects
;
14111 if (optind
< (argc
- 1))
14115 while (optind
< argc
)
14116 err
|= process_file (argv
[optind
++]);
14118 if (dump_sects
!= NULL
)
14120 if (cmdline_dump_sects
!= NULL
)
14121 free (cmdline_dump_sects
);