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
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/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/or32.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/x86-64.h"
152 #include "elf/xc16x.h"
153 #include "elf/xgate.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
158 #include "libiberty.h"
159 #include "safe-ctype.h"
160 #include "filenames.h"
162 char * program_name
= "readelf";
163 static long archive_file_offset
;
164 static unsigned long archive_file_size
;
165 static unsigned long dynamic_addr
;
166 static bfd_size_type dynamic_size
;
167 static unsigned int dynamic_nent
;
168 static char * dynamic_strings
;
169 static unsigned long dynamic_strings_length
;
170 static char * string_table
;
171 static unsigned long string_table_length
;
172 static unsigned long num_dynamic_syms
;
173 static Elf_Internal_Sym
* dynamic_symbols
;
174 static Elf_Internal_Syminfo
* dynamic_syminfo
;
175 static unsigned long dynamic_syminfo_offset
;
176 static unsigned int dynamic_syminfo_nent
;
177 static char program_interpreter
[PATH_MAX
];
178 static bfd_vma dynamic_info
[DT_ENCODING
];
179 static bfd_vma dynamic_info_DT_GNU_HASH
;
180 static bfd_vma version_info
[16];
181 static Elf_Internal_Ehdr elf_header
;
182 static Elf_Internal_Shdr
* section_headers
;
183 static Elf_Internal_Phdr
* program_headers
;
184 static Elf_Internal_Dyn
* dynamic_section
;
185 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
186 static int show_name
;
187 static int do_dynamic
;
189 static int do_dyn_syms
;
191 static int do_sections
;
192 static int do_section_groups
;
193 static int do_section_details
;
194 static int do_segments
;
195 static int do_unwind
;
196 static int do_using_dynamic
;
197 static int do_header
;
199 static int do_version
;
200 static int do_histogram
;
201 static int do_debugging
;
204 static int do_archive_index
;
205 static int is_32bit_elf
;
209 struct group_list
* next
;
210 unsigned int section_index
;
215 struct group_list
* root
;
216 unsigned int group_index
;
219 static size_t group_count
;
220 static struct group
* section_groups
;
221 static struct group
** section_headers_groups
;
224 /* Flag bits indicating particular types of dump. */
225 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
226 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
227 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
228 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
229 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
231 typedef unsigned char dump_type
;
233 /* A linked list of the section names for which dumps were requested. */
234 struct dump_list_entry
238 struct dump_list_entry
* next
;
240 static struct dump_list_entry
* dump_sects_byname
;
242 /* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244 static dump_type
* cmdline_dump_sects
= NULL
;
245 static unsigned int num_cmdline_dump_sects
= 0;
247 /* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252 static dump_type
* dump_sects
= NULL
;
253 static unsigned int num_dump_sects
= 0;
256 /* How to print a vma value. */
257 typedef enum print_mode
271 #define SECTION_NAME(X) \
272 ((X) == NULL ? _("<none>") \
273 : string_table == NULL ? _("<no-name>") \
274 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
275 : string_table + (X)->sh_name))
277 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
279 #define GET_ELF_SYMBOLS(file, section, sym_count) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
281 : get_64bit_elf_symbols (file, section, sym_count))
283 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
284 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
285 already been called and verified that the string exists. */
286 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
288 #define REMOVE_ARCH_BITS(ADDR) \
291 if (elf_header.e_machine == EM_ARM) \
296 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
297 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
298 using malloc and fill that. In either case return the pointer to the start of
299 the retrieved data or NULL if something went wrong. If something does go wrong
300 emit an error message using REASON as part of the context. */
303 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
308 if (size
== 0 || nmemb
== 0)
311 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
313 error (_("Unable to seek to 0x%lx for %s\n"),
314 (unsigned long) archive_file_offset
+ offset
, reason
);
321 /* Check for overflow. */
322 if (nmemb
< (~(size_t) 0 - 1) / size
)
323 /* + 1 so that we can '\0' terminate invalid string table sections. */
324 mvar
= malloc (size
* nmemb
+ 1);
328 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
329 (unsigned long)(size
* nmemb
), reason
);
333 ((char *) mvar
)[size
* nmemb
] = '\0';
336 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
338 error (_("Unable to read in 0x%lx bytes of %s\n"),
339 (unsigned long)(size
* nmemb
), reason
);
348 /* Print a VMA value. */
351 print_vma (bfd_vma vma
, print_mode mode
)
364 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
371 return printf ("%5" BFD_VMA_FMT
"d", vma
);
379 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
382 return printf ("%" BFD_VMA_FMT
"d", vma
);
385 return printf ("%" BFD_VMA_FMT
"u", vma
);
390 /* Display a symbol on stdout. Handles the display of control characters and
391 multibye characters (assuming the host environment supports them).
393 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
395 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
396 padding as necessary.
398 Returns the number of emitted characters. */
401 print_symbol (int width
, const char *symbol
)
403 bfd_boolean extra_padding
= FALSE
;
405 #ifdef HAVE_MBSTATE_T
412 /* Keep the width positive. This also helps. */
414 extra_padding
= TRUE
;
418 /* Set the remaining width to a very large value.
419 This simplifies the code below. */
420 width_remaining
= INT_MAX
;
422 width_remaining
= width
;
424 #ifdef HAVE_MBSTATE_T
425 /* Initialise the multibyte conversion state. */
426 memset (& state
, 0, sizeof (state
));
429 while (width_remaining
)
432 const char c
= *symbol
++;
437 /* Do not print control characters directly as they can affect terminal
438 settings. Such characters usually appear in the names generated
439 by the assembler for local labels. */
442 if (width_remaining
< 2)
445 printf ("^%c", c
+ 0x40);
446 width_remaining
-= 2;
449 else if (ISPRINT (c
))
457 #ifdef HAVE_MBSTATE_T
460 /* Let printf do the hard work of displaying multibyte characters. */
461 printf ("%.1s", symbol
- 1);
465 #ifdef HAVE_MBSTATE_T
466 /* Try to find out how many bytes made up the character that was
467 just printed. Advance the symbol pointer past the bytes that
469 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
473 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
478 if (extra_padding
&& num_printed
< width
)
480 /* Fill in the remaining spaces. */
481 printf ("%-*s", width
- num_printed
, " ");
488 /* Return a pointer to section NAME, or NULL if no such section exists. */
490 static Elf_Internal_Shdr
*
491 find_section (const char * name
)
495 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
496 if (streq (SECTION_NAME (section_headers
+ i
), name
))
497 return section_headers
+ i
;
502 /* Return a pointer to a section containing ADDR, or NULL if no such
505 static Elf_Internal_Shdr
*
506 find_section_by_address (bfd_vma addr
)
510 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
512 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
513 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
520 /* Return a pointer to section NAME, or NULL if no such section exists,
521 restricted to the list of sections given in SET. */
523 static Elf_Internal_Shdr
*
524 find_section_in_set (const char * name
, unsigned int * set
)
530 while ((i
= *set
++) > 0)
531 if (streq (SECTION_NAME (section_headers
+ i
), name
))
532 return section_headers
+ i
;
535 return find_section (name
);
538 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
542 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
544 return read_leb128 (data
, length_return
, 0);
547 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
548 This OS has so many departures from the ELF standard that we test it at
554 return elf_header
.e_machine
== EM_IA_64
555 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
558 /* Guess the relocation size commonly used by the specific machines. */
561 guess_is_rela (unsigned int e_machine
)
565 /* Targets that use REL relocations. */
582 /* Targets that use RELA relocations. */
586 case EM_ADAPTEVA_EPIPHANY
:
588 case EM_ALTERA_NIOS2
:
607 case EM_LATTICEMICO32
:
615 case EM_CYGNUS_MN10200
:
617 case EM_CYGNUS_MN10300
:
648 case EM_MICROBLAZE_OLD
:
669 warn (_("Don't know about relocations on this machine architecture\n"));
675 slurp_rela_relocs (FILE * file
,
676 unsigned long rel_offset
,
677 unsigned long rel_size
,
678 Elf_Internal_Rela
** relasp
,
679 unsigned long * nrelasp
)
681 Elf_Internal_Rela
* relas
;
682 unsigned long nrelas
;
687 Elf32_External_Rela
* erelas
;
689 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
690 rel_size
, _("32-bit relocation data"));
694 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
696 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
697 sizeof (Elf_Internal_Rela
));
702 error (_("out of memory parsing relocs\n"));
706 for (i
= 0; i
< nrelas
; i
++)
708 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
709 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
710 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
717 Elf64_External_Rela
* erelas
;
719 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
720 rel_size
, _("64-bit relocation data"));
724 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
726 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
727 sizeof (Elf_Internal_Rela
));
732 error (_("out of memory parsing relocs\n"));
736 for (i
= 0; i
< nrelas
; i
++)
738 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
739 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
740 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
742 /* The #ifdef BFD64 below is to prevent a compile time
743 warning. We know that if we do not have a 64 bit data
744 type that we will never execute this code anyway. */
746 if (elf_header
.e_machine
== EM_MIPS
747 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
749 /* In little-endian objects, r_info isn't really a
750 64-bit little-endian value: it has a 32-bit
751 little-endian symbol index followed by four
752 individual byte fields. Reorder INFO
754 bfd_vma inf
= relas
[i
].r_info
;
755 inf
= (((inf
& 0xffffffff) << 32)
756 | ((inf
>> 56) & 0xff)
757 | ((inf
>> 40) & 0xff00)
758 | ((inf
>> 24) & 0xff0000)
759 | ((inf
>> 8) & 0xff000000));
760 relas
[i
].r_info
= inf
;
773 slurp_rel_relocs (FILE * file
,
774 unsigned long rel_offset
,
775 unsigned long rel_size
,
776 Elf_Internal_Rela
** relsp
,
777 unsigned long * nrelsp
)
779 Elf_Internal_Rela
* rels
;
785 Elf32_External_Rel
* erels
;
787 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
788 rel_size
, _("32-bit relocation data"));
792 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
794 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
799 error (_("out of memory parsing relocs\n"));
803 for (i
= 0; i
< nrels
; i
++)
805 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
806 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
807 rels
[i
].r_addend
= 0;
814 Elf64_External_Rel
* erels
;
816 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
817 rel_size
, _("64-bit relocation data"));
821 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
823 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
828 error (_("out of memory parsing relocs\n"));
832 for (i
= 0; i
< nrels
; i
++)
834 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
835 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
836 rels
[i
].r_addend
= 0;
838 /* The #ifdef BFD64 below is to prevent a compile time
839 warning. We know that if we do not have a 64 bit data
840 type that we will never execute this code anyway. */
842 if (elf_header
.e_machine
== EM_MIPS
843 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
845 /* In little-endian objects, r_info isn't really a
846 64-bit little-endian value: it has a 32-bit
847 little-endian symbol index followed by four
848 individual byte fields. Reorder INFO
850 bfd_vma inf
= rels
[i
].r_info
;
851 inf
= (((inf
& 0xffffffff) << 32)
852 | ((inf
>> 56) & 0xff)
853 | ((inf
>> 40) & 0xff00)
854 | ((inf
>> 24) & 0xff0000)
855 | ((inf
>> 8) & 0xff000000));
856 rels
[i
].r_info
= inf
;
868 /* Returns the reloc type extracted from the reloc info field. */
871 get_reloc_type (bfd_vma reloc_info
)
874 return ELF32_R_TYPE (reloc_info
);
876 switch (elf_header
.e_machine
)
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info
);
883 return ELF64_R_TYPE_ID (reloc_info
);
886 return ELF64_R_TYPE (reloc_info
);
890 /* Return the symbol index extracted from the reloc info field. */
893 get_reloc_symindex (bfd_vma reloc_info
)
895 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
898 /* Display the contents of the relocation data found at the specified
902 dump_relocations (FILE * file
,
903 unsigned long rel_offset
,
904 unsigned long rel_size
,
905 Elf_Internal_Sym
* symtab
,
908 unsigned long strtablen
,
912 Elf_Internal_Rela
* rels
;
914 if (is_rela
== UNKNOWN
)
915 is_rela
= guess_is_rela (elf_header
.e_machine
);
919 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
924 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
963 for (i
= 0; i
< rel_size
; i
++)
968 bfd_vma symtab_index
;
971 offset
= rels
[i
].r_offset
;
972 inf
= rels
[i
].r_info
;
974 type
= get_reloc_type (inf
);
975 symtab_index
= get_reloc_symindex (inf
);
979 printf ("%8.8lx %8.8lx ",
980 (unsigned long) offset
& 0xffffffff,
981 (unsigned long) inf
& 0xffffffff);
985 #if BFD_HOST_64BIT_LONG
987 ? "%16.16lx %16.16lx "
988 : "%12.12lx %12.12lx ",
990 #elif BFD_HOST_64BIT_LONG_LONG
993 ? "%16.16llx %16.16llx "
994 : "%12.12llx %12.12llx ",
998 ? "%16.16I64x %16.16I64x "
999 : "%12.12I64x %12.12I64x ",
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset
),
1007 _bfd_int64_low (offset
),
1008 _bfd_int64_high (inf
),
1009 _bfd_int64_low (inf
));
1013 switch (elf_header
.e_machine
)
1020 rtype
= elf_aarch64_reloc_type (type
);
1024 case EM_CYGNUS_M32R
:
1025 rtype
= elf_m32r_reloc_type (type
);
1030 rtype
= elf_i386_reloc_type (type
);
1035 rtype
= elf_m68hc11_reloc_type (type
);
1039 rtype
= elf_m68k_reloc_type (type
);
1043 rtype
= elf_i960_reloc_type (type
);
1048 rtype
= elf_avr_reloc_type (type
);
1051 case EM_OLD_SPARCV9
:
1052 case EM_SPARC32PLUS
:
1055 rtype
= elf_sparc_reloc_type (type
);
1059 rtype
= elf_spu_reloc_type (type
);
1063 rtype
= v800_reloc_type (type
);
1066 case EM_CYGNUS_V850
:
1067 rtype
= v850_reloc_type (type
);
1071 case EM_CYGNUS_D10V
:
1072 rtype
= elf_d10v_reloc_type (type
);
1076 case EM_CYGNUS_D30V
:
1077 rtype
= elf_d30v_reloc_type (type
);
1081 rtype
= elf_dlx_reloc_type (type
);
1085 rtype
= elf_sh_reloc_type (type
);
1089 case EM_CYGNUS_MN10300
:
1090 rtype
= elf_mn10300_reloc_type (type
);
1094 case EM_CYGNUS_MN10200
:
1095 rtype
= elf_mn10200_reloc_type (type
);
1099 case EM_CYGNUS_FR30
:
1100 rtype
= elf_fr30_reloc_type (type
);
1104 rtype
= elf_frv_reloc_type (type
);
1108 rtype
= elf_mcore_reloc_type (type
);
1112 rtype
= elf_mmix_reloc_type (type
);
1116 rtype
= elf_moxie_reloc_type (type
);
1121 rtype
= elf_msp430_reloc_type (type
);
1125 rtype
= elf_ppc_reloc_type (type
);
1129 rtype
= elf_ppc64_reloc_type (type
);
1133 case EM_MIPS_RS3_LE
:
1134 rtype
= elf_mips_reloc_type (type
);
1138 rtype
= elf_alpha_reloc_type (type
);
1142 rtype
= elf_arm_reloc_type (type
);
1146 rtype
= elf_arc_reloc_type (type
);
1150 rtype
= elf_hppa_reloc_type (type
);
1156 rtype
= elf_h8_reloc_type (type
);
1161 rtype
= elf_or32_reloc_type (type
);
1166 rtype
= elf_pj_reloc_type (type
);
1169 rtype
= elf_ia64_reloc_type (type
);
1173 rtype
= elf_cris_reloc_type (type
);
1177 rtype
= elf_i860_reloc_type (type
);
1183 rtype
= elf_x86_64_reloc_type (type
);
1187 rtype
= i370_reloc_type (type
);
1192 rtype
= elf_s390_reloc_type (type
);
1196 rtype
= elf_score_reloc_type (type
);
1200 rtype
= elf_xstormy16_reloc_type (type
);
1204 rtype
= elf_crx_reloc_type (type
);
1208 rtype
= elf_vax_reloc_type (type
);
1211 case EM_ADAPTEVA_EPIPHANY
:
1212 rtype
= elf_epiphany_reloc_type (type
);
1217 rtype
= elf_ip2k_reloc_type (type
);
1221 rtype
= elf_iq2000_reloc_type (type
);
1226 rtype
= elf_xtensa_reloc_type (type
);
1229 case EM_LATTICEMICO32
:
1230 rtype
= elf_lm32_reloc_type (type
);
1235 rtype
= elf_m32c_reloc_type (type
);
1239 rtype
= elf_mt_reloc_type (type
);
1243 rtype
= elf_bfin_reloc_type (type
);
1247 rtype
= elf_mep_reloc_type (type
);
1251 rtype
= elf_cr16_reloc_type (type
);
1255 case EM_MICROBLAZE_OLD
:
1256 rtype
= elf_microblaze_reloc_type (type
);
1260 rtype
= elf_rl78_reloc_type (type
);
1264 rtype
= elf_rx_reloc_type (type
);
1269 rtype
= elf_xc16x_reloc_type (type
);
1273 rtype
= elf_tic6x_reloc_type (type
);
1277 rtype
= elf_tilegx_reloc_type (type
);
1281 rtype
= elf_tilepro_reloc_type (type
);
1285 rtype
= elf_xgate_reloc_type (type
);
1290 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1292 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1294 if (elf_header
.e_machine
== EM_ALPHA
1296 && streq (rtype
, "R_ALPHA_LITUSE")
1299 switch (rels
[i
].r_addend
)
1301 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1302 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1308 default: rtype
= NULL
;
1311 printf (" (%s)", rtype
);
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels
[i
].r_addend
);
1319 else if (symtab_index
)
1321 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1325 Elf_Internal_Sym
* psym
;
1327 psym
= symtab
+ symtab_index
;
1331 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1335 unsigned int width
= is_32bit_elf
? 8 : 14;
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1348 || psym
->st_name
== 0
1349 || psym
->st_name
>= strtablen
)
1352 name
= strtab
+ psym
->st_name
;
1354 len
= print_symbol (width
, name
);
1355 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1359 print_vma (psym
->st_value
, LONG_HEX
);
1361 printf (is_32bit_elf
? " " : " ");
1364 if (psym
->st_name
== 0)
1366 const char * sec_name
= "<null>";
1369 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1371 if (psym
->st_shndx
< elf_header
.e_shnum
)
1373 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1374 else if (psym
->st_shndx
== SHN_ABS
)
1376 else if (psym
->st_shndx
== SHN_COMMON
)
1377 sec_name
= "COMMON";
1378 else if ((elf_header
.e_machine
== EM_MIPS
1379 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1380 || (elf_header
.e_machine
== EM_TI_C6000
1381 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1382 sec_name
= "SCOMMON";
1383 else if (elf_header
.e_machine
== EM_MIPS
1384 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1385 sec_name
= "SUNDEF";
1386 else if ((elf_header
.e_machine
== EM_X86_64
1387 || elf_header
.e_machine
== EM_L1OM
1388 || elf_header
.e_machine
== EM_K1OM
)
1389 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1390 sec_name
= "LARGE_COMMON";
1391 else if (elf_header
.e_machine
== EM_IA_64
1392 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1393 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1394 sec_name
= "ANSI_COM";
1395 else if (is_ia64_vms ()
1396 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1397 sec_name
= "VMS_SYMVEC";
1400 sprintf (name_buf
, "<section 0x%x>",
1401 (unsigned int) psym
->st_shndx
);
1402 sec_name
= name_buf
;
1405 print_symbol (22, sec_name
);
1407 else if (strtab
== NULL
)
1408 printf (_("<string table index: %3ld>"), psym
->st_name
);
1409 else if (psym
->st_name
>= strtablen
)
1410 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1412 print_symbol (22, strtab
+ psym
->st_name
);
1416 bfd_signed_vma off
= rels
[i
].r_addend
;
1419 printf (" - %" BFD_VMA_FMT
"x", - off
);
1421 printf (" + %" BFD_VMA_FMT
"x", off
);
1427 bfd_signed_vma off
= rels
[i
].r_addend
;
1429 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1431 printf ("-%" BFD_VMA_FMT
"x", - off
);
1433 printf ("%" BFD_VMA_FMT
"x", off
);
1436 if (elf_header
.e_machine
== EM_SPARCV9
1438 && streq (rtype
, "R_SPARC_OLO10"))
1439 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1444 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1446 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1447 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1448 const char * rtype2
= elf_mips_reloc_type (type2
);
1449 const char * rtype3
= elf_mips_reloc_type (type3
);
1451 printf (" Type2: ");
1454 printf (_("unrecognized: %-7lx"),
1455 (unsigned long) type2
& 0xffffffff);
1457 printf ("%-17.17s", rtype2
);
1459 printf ("\n Type3: ");
1462 printf (_("unrecognized: %-7lx"),
1463 (unsigned long) type3
& 0xffffffff);
1465 printf ("%-17.17s", rtype3
);
1476 get_mips_dynamic_type (unsigned long type
)
1480 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1481 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1482 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1483 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1484 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1485 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1486 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1487 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1488 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1489 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1490 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1491 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1492 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1493 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1494 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1495 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1496 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1497 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1498 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1499 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1500 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1501 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1502 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1503 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1504 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1505 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1506 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1507 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1508 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1509 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1510 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1511 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1512 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1513 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1514 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1515 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1516 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1517 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1518 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1519 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1520 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1521 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1522 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1523 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1524 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1531 get_sparc64_dynamic_type (unsigned long type
)
1535 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1542 get_ppc_dynamic_type (unsigned long type
)
1546 case DT_PPC_GOT
: return "PPC_GOT";
1547 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1554 get_ppc64_dynamic_type (unsigned long type
)
1558 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1559 case DT_PPC64_OPD
: return "PPC64_OPD";
1560 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1561 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1568 get_parisc_dynamic_type (unsigned long type
)
1572 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1573 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1574 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1575 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1576 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1577 case DT_HP_PREINIT
: return "HP_PREINIT";
1578 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1579 case DT_HP_NEEDED
: return "HP_NEEDED";
1580 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1581 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1582 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1583 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1584 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1585 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1586 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1587 case DT_HP_FILTERED
: return "HP_FILTERED";
1588 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1589 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1590 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1591 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1592 case DT_PLT
: return "PLT";
1593 case DT_PLT_SIZE
: return "PLT_SIZE";
1594 case DT_DLT
: return "DLT";
1595 case DT_DLT_SIZE
: return "DLT_SIZE";
1602 get_ia64_dynamic_type (unsigned long type
)
1606 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1607 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1608 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1609 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1610 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1611 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1612 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1613 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1614 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1615 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1616 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1617 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1618 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1619 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1620 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1621 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1622 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1623 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1624 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1625 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1626 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1627 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1628 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1629 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1630 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1631 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1632 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1633 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1634 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1635 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1636 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1643 get_alpha_dynamic_type (unsigned long type
)
1647 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1654 get_score_dynamic_type (unsigned long type
)
1658 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1659 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1660 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1661 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1662 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1663 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1670 get_tic6x_dynamic_type (unsigned long type
)
1674 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1675 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1676 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1677 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1678 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1679 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1686 get_dynamic_type (unsigned long type
)
1688 static char buff
[64];
1692 case DT_NULL
: return "NULL";
1693 case DT_NEEDED
: return "NEEDED";
1694 case DT_PLTRELSZ
: return "PLTRELSZ";
1695 case DT_PLTGOT
: return "PLTGOT";
1696 case DT_HASH
: return "HASH";
1697 case DT_STRTAB
: return "STRTAB";
1698 case DT_SYMTAB
: return "SYMTAB";
1699 case DT_RELA
: return "RELA";
1700 case DT_RELASZ
: return "RELASZ";
1701 case DT_RELAENT
: return "RELAENT";
1702 case DT_STRSZ
: return "STRSZ";
1703 case DT_SYMENT
: return "SYMENT";
1704 case DT_INIT
: return "INIT";
1705 case DT_FINI
: return "FINI";
1706 case DT_SONAME
: return "SONAME";
1707 case DT_RPATH
: return "RPATH";
1708 case DT_SYMBOLIC
: return "SYMBOLIC";
1709 case DT_REL
: return "REL";
1710 case DT_RELSZ
: return "RELSZ";
1711 case DT_RELENT
: return "RELENT";
1712 case DT_PLTREL
: return "PLTREL";
1713 case DT_DEBUG
: return "DEBUG";
1714 case DT_TEXTREL
: return "TEXTREL";
1715 case DT_JMPREL
: return "JMPREL";
1716 case DT_BIND_NOW
: return "BIND_NOW";
1717 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1718 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1719 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1720 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1721 case DT_RUNPATH
: return "RUNPATH";
1722 case DT_FLAGS
: return "FLAGS";
1724 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1725 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1727 case DT_CHECKSUM
: return "CHECKSUM";
1728 case DT_PLTPADSZ
: return "PLTPADSZ";
1729 case DT_MOVEENT
: return "MOVEENT";
1730 case DT_MOVESZ
: return "MOVESZ";
1731 case DT_FEATURE
: return "FEATURE";
1732 case DT_POSFLAG_1
: return "POSFLAG_1";
1733 case DT_SYMINSZ
: return "SYMINSZ";
1734 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1736 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1737 case DT_CONFIG
: return "CONFIG";
1738 case DT_DEPAUDIT
: return "DEPAUDIT";
1739 case DT_AUDIT
: return "AUDIT";
1740 case DT_PLTPAD
: return "PLTPAD";
1741 case DT_MOVETAB
: return "MOVETAB";
1742 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1744 case DT_VERSYM
: return "VERSYM";
1746 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1747 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1748 case DT_RELACOUNT
: return "RELACOUNT";
1749 case DT_RELCOUNT
: return "RELCOUNT";
1750 case DT_FLAGS_1
: return "FLAGS_1";
1751 case DT_VERDEF
: return "VERDEF";
1752 case DT_VERDEFNUM
: return "VERDEFNUM";
1753 case DT_VERNEED
: return "VERNEED";
1754 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1756 case DT_AUXILIARY
: return "AUXILIARY";
1757 case DT_USED
: return "USED";
1758 case DT_FILTER
: return "FILTER";
1760 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1761 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1762 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1763 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1764 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1765 case DT_GNU_HASH
: return "GNU_HASH";
1768 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1770 const char * result
;
1772 switch (elf_header
.e_machine
)
1775 case EM_MIPS_RS3_LE
:
1776 result
= get_mips_dynamic_type (type
);
1779 result
= get_sparc64_dynamic_type (type
);
1782 result
= get_ppc_dynamic_type (type
);
1785 result
= get_ppc64_dynamic_type (type
);
1788 result
= get_ia64_dynamic_type (type
);
1791 result
= get_alpha_dynamic_type (type
);
1794 result
= get_score_dynamic_type (type
);
1797 result
= get_tic6x_dynamic_type (type
);
1807 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1809 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1810 || (elf_header
.e_machine
== EM_PARISC
1811 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1813 const char * result
;
1815 switch (elf_header
.e_machine
)
1818 result
= get_parisc_dynamic_type (type
);
1821 result
= get_ia64_dynamic_type (type
);
1831 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1835 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1842 get_file_type (unsigned e_type
)
1844 static char buff
[32];
1848 case ET_NONE
: return _("NONE (None)");
1849 case ET_REL
: return _("REL (Relocatable file)");
1850 case ET_EXEC
: return _("EXEC (Executable file)");
1851 case ET_DYN
: return _("DYN (Shared object file)");
1852 case ET_CORE
: return _("CORE (Core file)");
1855 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1856 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1857 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1858 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1860 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1866 get_machine_name (unsigned e_machine
)
1868 static char buff
[64]; /* XXX */
1872 case EM_NONE
: return _("None");
1873 case EM_AARCH64
: return "AArch64";
1874 case EM_M32
: return "WE32100";
1875 case EM_SPARC
: return "Sparc";
1876 case EM_SPU
: return "SPU";
1877 case EM_386
: return "Intel 80386";
1878 case EM_68K
: return "MC68000";
1879 case EM_88K
: return "MC88000";
1880 case EM_486
: return "Intel 80486";
1881 case EM_860
: return "Intel 80860";
1882 case EM_MIPS
: return "MIPS R3000";
1883 case EM_S370
: return "IBM System/370";
1884 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1885 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1886 case EM_PARISC
: return "HPPA";
1887 case EM_PPC_OLD
: return "Power PC (old)";
1888 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1889 case EM_960
: return "Intel 90860";
1890 case EM_PPC
: return "PowerPC";
1891 case EM_PPC64
: return "PowerPC64";
1892 case EM_FR20
: return "Fujitsu FR20";
1893 case EM_RH32
: return "TRW RH32";
1894 case EM_MCORE
: return "MCORE";
1895 case EM_ARM
: return "ARM";
1896 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1897 case EM_SH
: return "Renesas / SuperH SH";
1898 case EM_SPARCV9
: return "Sparc v9";
1899 case EM_TRICORE
: return "Siemens Tricore";
1900 case EM_ARC
: return "ARC";
1901 case EM_H8_300
: return "Renesas H8/300";
1902 case EM_H8_300H
: return "Renesas H8/300H";
1903 case EM_H8S
: return "Renesas H8S";
1904 case EM_H8_500
: return "Renesas H8/500";
1905 case EM_IA_64
: return "Intel IA-64";
1906 case EM_MIPS_X
: return "Stanford MIPS-X";
1907 case EM_COLDFIRE
: return "Motorola Coldfire";
1908 case EM_ALPHA
: return "Alpha";
1909 case EM_CYGNUS_D10V
:
1910 case EM_D10V
: return "d10v";
1911 case EM_CYGNUS_D30V
:
1912 case EM_D30V
: return "d30v";
1913 case EM_CYGNUS_M32R
:
1914 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1915 case EM_CYGNUS_V850
:
1916 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
1917 case EM_V850
: return "Renesas V850";
1918 case EM_CYGNUS_MN10300
:
1919 case EM_MN10300
: return "mn10300";
1920 case EM_CYGNUS_MN10200
:
1921 case EM_MN10200
: return "mn10200";
1922 case EM_MOXIE
: return "Moxie";
1923 case EM_CYGNUS_FR30
:
1924 case EM_FR30
: return "Fujitsu FR30";
1925 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1927 case EM_PJ
: return "picoJava";
1928 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1929 case EM_PCP
: return "Siemens PCP";
1930 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1931 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1932 case EM_STARCORE
: return "Motorola Star*Core processor";
1933 case EM_ME16
: return "Toyota ME16 processor";
1934 case EM_ST100
: return "STMicroelectronics ST100 processor";
1935 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1936 case EM_PDSP
: return "Sony DSP processor";
1937 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1938 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1939 case EM_FX66
: return "Siemens FX66 microcontroller";
1940 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1941 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1942 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1943 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
1944 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1945 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1946 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1947 case EM_SVX
: return "Silicon Graphics SVx";
1948 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1949 case EM_VAX
: return "Digital VAX";
1951 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1952 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1953 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1954 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1955 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1956 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1957 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1958 case EM_PRISM
: return "Vitesse Prism";
1959 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1960 case EM_L1OM
: return "Intel L1OM";
1961 case EM_K1OM
: return "Intel K1OM";
1963 case EM_S390
: return "IBM S/390";
1964 case EM_SCORE
: return "SUNPLUS S+Core";
1965 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
1967 case EM_OR32
: return "OpenRISC";
1968 case EM_ARC_A5
: return "ARC International ARCompact processor";
1969 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1970 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
1971 case EM_DLX
: return "OpenDLX";
1973 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1974 case EM_IQ2000
: return "Vitesse IQ2000";
1976 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1977 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1978 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1979 case EM_NS32K
: return "National Semiconductor 32000 series";
1980 case EM_TPC
: return "Tenor Network TPC processor";
1981 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1982 case EM_MAX
: return "MAX Processor";
1983 case EM_CR
: return "National Semiconductor CompactRISC";
1984 case EM_F2MC16
: return "Fujitsu F2MC16";
1985 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1986 case EM_LATTICEMICO32
: return "Lattice Mico32";
1988 case EM_M32C
: return "Renesas M32c";
1989 case EM_MT
: return "Morpho Techologies MT processor";
1990 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1991 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1992 case EM_SEP
: return "Sharp embedded microprocessor";
1993 case EM_ARCA
: return "Arca RISC microprocessor";
1994 case EM_UNICORE
: return "Unicore";
1995 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1996 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1997 case EM_NIOS32
: return "Altera Nios";
1998 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2000 case EM_XC16X
: return "Infineon Technologies xc16x";
2001 case EM_M16C
: return "Renesas M16C series microprocessors";
2002 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2003 case EM_CE
: return "Freescale Communication Engine RISC core";
2004 case EM_TSK3000
: return "Altium TSK3000 core";
2005 case EM_RS08
: return "Freescale RS08 embedded processor";
2006 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2007 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2008 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2009 case EM_SE_C17
: return "Seiko Epson C17 family";
2010 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2011 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2012 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2013 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2014 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2015 case EM_R32C
: return "Renesas R32C series microprocessors";
2016 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2017 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2018 case EM_8051
: return "Intel 8051 and variants";
2019 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2020 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2021 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2022 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2023 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2024 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2025 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2026 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2029 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2030 case EM_RL78
: return "Renesas RL78";
2031 case EM_RX
: return "Renesas RX";
2032 case EM_METAG
: return "Imagination Technologies META processor architecture";
2033 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2034 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2035 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2036 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2037 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2038 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2039 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2040 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2041 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2042 case EM_CUDA
: return "NVIDIA CUDA architecture";
2043 case EM_XGATE
: return "Motorola XGATE embedded processor";
2045 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2051 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2056 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2057 e_flags
&= ~ EF_ARM_EABIMASK
;
2059 /* Handle "generic" ARM flags. */
2060 if (e_flags
& EF_ARM_RELEXEC
)
2062 strcat (buf
, ", relocatable executable");
2063 e_flags
&= ~ EF_ARM_RELEXEC
;
2066 if (e_flags
& EF_ARM_HASENTRY
)
2068 strcat (buf
, ", has entry point");
2069 e_flags
&= ~ EF_ARM_HASENTRY
;
2072 /* Now handle EABI specific flags. */
2076 strcat (buf
, ", <unrecognized EABI>");
2081 case EF_ARM_EABI_VER1
:
2082 strcat (buf
, ", Version1 EABI");
2087 /* Process flags one bit at a time. */
2088 flag
= e_flags
& - e_flags
;
2093 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2094 strcat (buf
, ", sorted symbol tables");
2104 case EF_ARM_EABI_VER2
:
2105 strcat (buf
, ", Version2 EABI");
2110 /* Process flags one bit at a time. */
2111 flag
= e_flags
& - e_flags
;
2116 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2117 strcat (buf
, ", sorted symbol tables");
2120 case EF_ARM_DYNSYMSUSESEGIDX
:
2121 strcat (buf
, ", dynamic symbols use segment index");
2124 case EF_ARM_MAPSYMSFIRST
:
2125 strcat (buf
, ", mapping symbols precede others");
2135 case EF_ARM_EABI_VER3
:
2136 strcat (buf
, ", Version3 EABI");
2139 case EF_ARM_EABI_VER4
:
2140 strcat (buf
, ", Version4 EABI");
2145 /* Process flags one bit at a time. */
2146 flag
= e_flags
& - e_flags
;
2152 strcat (buf
, ", BE8");
2156 strcat (buf
, ", LE8");
2167 case EF_ARM_EABI_VER5
:
2168 strcat (buf
, ", Version5 EABI");
2173 /* Process flags one bit at a time. */
2174 flag
= e_flags
& - e_flags
;
2180 strcat (buf
, ", BE8");
2184 strcat (buf
, ", LE8");
2187 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2188 strcat (buf
, ", soft-float ABI");
2191 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2192 strcat (buf
, ", hard-float ABI");
2202 case EF_ARM_EABI_UNKNOWN
:
2203 strcat (buf
, ", GNU EABI");
2208 /* Process flags one bit at a time. */
2209 flag
= e_flags
& - e_flags
;
2214 case EF_ARM_INTERWORK
:
2215 strcat (buf
, ", interworking enabled");
2218 case EF_ARM_APCS_26
:
2219 strcat (buf
, ", uses APCS/26");
2222 case EF_ARM_APCS_FLOAT
:
2223 strcat (buf
, ", uses APCS/float");
2227 strcat (buf
, ", position independent");
2231 strcat (buf
, ", 8 bit structure alignment");
2234 case EF_ARM_NEW_ABI
:
2235 strcat (buf
, ", uses new ABI");
2238 case EF_ARM_OLD_ABI
:
2239 strcat (buf
, ", uses old ABI");
2242 case EF_ARM_SOFT_FLOAT
:
2243 strcat (buf
, ", software FP");
2246 case EF_ARM_VFP_FLOAT
:
2247 strcat (buf
, ", VFP");
2250 case EF_ARM_MAVERICK_FLOAT
:
2251 strcat (buf
, ", Maverick FP");
2262 strcat (buf
,_(", <unknown>"));
2266 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2268 static char buf
[1024];
2280 decode_ARM_machine_flags (e_flags
, buf
);
2284 if (e_flags
& EF_BFIN_PIC
)
2285 strcat (buf
, ", PIC");
2287 if (e_flags
& EF_BFIN_FDPIC
)
2288 strcat (buf
, ", FDPIC");
2290 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2291 strcat (buf
, ", code in L1");
2293 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2294 strcat (buf
, ", data in L1");
2299 switch (e_flags
& EF_FRV_CPU_MASK
)
2301 case EF_FRV_CPU_GENERIC
:
2305 strcat (buf
, ", fr???");
2308 case EF_FRV_CPU_FR300
:
2309 strcat (buf
, ", fr300");
2312 case EF_FRV_CPU_FR400
:
2313 strcat (buf
, ", fr400");
2315 case EF_FRV_CPU_FR405
:
2316 strcat (buf
, ", fr405");
2319 case EF_FRV_CPU_FR450
:
2320 strcat (buf
, ", fr450");
2323 case EF_FRV_CPU_FR500
:
2324 strcat (buf
, ", fr500");
2326 case EF_FRV_CPU_FR550
:
2327 strcat (buf
, ", fr550");
2330 case EF_FRV_CPU_SIMPLE
:
2331 strcat (buf
, ", simple");
2333 case EF_FRV_CPU_TOMCAT
:
2334 strcat (buf
, ", tomcat");
2340 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2341 strcat (buf
, ", m68000");
2342 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2343 strcat (buf
, ", cpu32");
2344 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2345 strcat (buf
, ", fido_a");
2348 char const * isa
= _("unknown");
2349 char const * mac
= _("unknown mac");
2350 char const * additional
= NULL
;
2352 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2354 case EF_M68K_CF_ISA_A_NODIV
:
2356 additional
= ", nodiv";
2358 case EF_M68K_CF_ISA_A
:
2361 case EF_M68K_CF_ISA_A_PLUS
:
2364 case EF_M68K_CF_ISA_B_NOUSP
:
2366 additional
= ", nousp";
2368 case EF_M68K_CF_ISA_B
:
2371 case EF_M68K_CF_ISA_C
:
2374 case EF_M68K_CF_ISA_C_NODIV
:
2376 additional
= ", nodiv";
2379 strcat (buf
, ", cf, isa ");
2382 strcat (buf
, additional
);
2383 if (e_flags
& EF_M68K_CF_FLOAT
)
2384 strcat (buf
, ", float");
2385 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2390 case EF_M68K_CF_MAC
:
2393 case EF_M68K_CF_EMAC
:
2396 case EF_M68K_CF_EMAC_B
:
2409 if (e_flags
& EF_PPC_EMB
)
2410 strcat (buf
, ", emb");
2412 if (e_flags
& EF_PPC_RELOCATABLE
)
2413 strcat (buf
, _(", relocatable"));
2415 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2416 strcat (buf
, _(", relocatable-lib"));
2420 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
2421 strcat (buf
, ", RH850 ABI");
2423 if (e_flags
& EF_V800_850E3
)
2424 strcat (buf
, ", V3 architecture");
2426 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
2427 strcat (buf
, ", FPU not used");
2429 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
2430 strcat (buf
, ", regmode: COMMON");
2432 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
2433 strcat (buf
, ", r4 not used");
2435 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
2436 strcat (buf
, ", r30 not used");
2438 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
2439 strcat (buf
, ", r5 not used");
2441 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
2442 strcat (buf
, ", r2 not used");
2444 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
2446 switch (e_flags
& - e_flags
)
2448 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
2449 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
2450 case EF_RH850_SIMD
: strcat (buf
, ", SIMD"); break;
2451 case EF_RH850_CACHE
: strcat (buf
, ", CACHE"); break;
2452 case EF_RH850_MMU
: strcat (buf
, ", MMU"); break;
2453 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
2454 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
2455 case EF_RH850_DATA_ALIGN8
: strcat (buf
, ", 8-byte alignment"); break;
2456 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
2457 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
2458 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
2459 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
2460 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
2461 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
2462 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
2463 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
2470 case EM_CYGNUS_V850
:
2471 switch (e_flags
& EF_V850_ARCH
)
2473 case E_V850E2V3_ARCH
:
2474 strcat (buf
, ", v850e2v3");
2477 strcat (buf
, ", v850e2");
2480 strcat (buf
, ", v850e1");
2483 strcat (buf
, ", v850e");
2486 strcat (buf
, ", v850");
2489 strcat (buf
, _(", unknown v850 architecture variant"));
2495 case EM_CYGNUS_M32R
:
2496 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2497 strcat (buf
, ", m32r");
2501 case EM_MIPS_RS3_LE
:
2502 if (e_flags
& EF_MIPS_NOREORDER
)
2503 strcat (buf
, ", noreorder");
2505 if (e_flags
& EF_MIPS_PIC
)
2506 strcat (buf
, ", pic");
2508 if (e_flags
& EF_MIPS_CPIC
)
2509 strcat (buf
, ", cpic");
2511 if (e_flags
& EF_MIPS_UCODE
)
2512 strcat (buf
, ", ugen_reserved");
2514 if (e_flags
& EF_MIPS_ABI2
)
2515 strcat (buf
, ", abi2");
2517 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2518 strcat (buf
, ", odk first");
2520 if (e_flags
& EF_MIPS_32BITMODE
)
2521 strcat (buf
, ", 32bitmode");
2523 switch ((e_flags
& EF_MIPS_MACH
))
2525 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2526 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2527 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2528 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2529 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2530 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2531 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2532 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2533 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2534 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2535 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2536 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2537 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
2538 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2539 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2540 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2542 /* We simply ignore the field in this case to avoid confusion:
2543 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2546 default: strcat (buf
, _(", unknown CPU")); break;
2549 switch ((e_flags
& EF_MIPS_ABI
))
2551 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2552 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2553 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2554 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2556 /* We simply ignore the field in this case to avoid confusion:
2557 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2558 This means it is likely to be an o32 file, but not for
2561 default: strcat (buf
, _(", unknown ABI")); break;
2564 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2565 strcat (buf
, ", mdmx");
2567 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2568 strcat (buf
, ", mips16");
2570 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
2571 strcat (buf
, ", micromips");
2573 switch ((e_flags
& EF_MIPS_ARCH
))
2575 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2576 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2577 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2578 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2579 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2580 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2581 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2582 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2583 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2584 default: strcat (buf
, _(", unknown ISA")); break;
2587 if (e_flags
& EF_SH_PIC
)
2588 strcat (buf
, ", pic");
2590 if (e_flags
& EF_SH_FDPIC
)
2591 strcat (buf
, ", fdpic");
2595 switch ((e_flags
& EF_SH_MACH_MASK
))
2597 case EF_SH1
: strcat (buf
, ", sh1"); break;
2598 case EF_SH2
: strcat (buf
, ", sh2"); break;
2599 case EF_SH3
: strcat (buf
, ", sh3"); break;
2600 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2601 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2602 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2603 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2604 case EF_SH4
: strcat (buf
, ", sh4"); break;
2605 case EF_SH5
: strcat (buf
, ", sh5"); break;
2606 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2607 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2608 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2609 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2610 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2611 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2612 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2613 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2614 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2615 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2616 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2617 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2618 default: strcat (buf
, _(", unknown ISA")); break;
2624 if (e_flags
& EF_SPARC_32PLUS
)
2625 strcat (buf
, ", v8+");
2627 if (e_flags
& EF_SPARC_SUN_US1
)
2628 strcat (buf
, ", ultrasparcI");
2630 if (e_flags
& EF_SPARC_SUN_US3
)
2631 strcat (buf
, ", ultrasparcIII");
2633 if (e_flags
& EF_SPARC_HAL_R1
)
2634 strcat (buf
, ", halr1");
2636 if (e_flags
& EF_SPARC_LEDATA
)
2637 strcat (buf
, ", ledata");
2639 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2640 strcat (buf
, ", tso");
2642 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2643 strcat (buf
, ", pso");
2645 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2646 strcat (buf
, ", rmo");
2650 switch (e_flags
& EF_PARISC_ARCH
)
2652 case EFA_PARISC_1_0
:
2653 strcpy (buf
, ", PA-RISC 1.0");
2655 case EFA_PARISC_1_1
:
2656 strcpy (buf
, ", PA-RISC 1.1");
2658 case EFA_PARISC_2_0
:
2659 strcpy (buf
, ", PA-RISC 2.0");
2664 if (e_flags
& EF_PARISC_TRAPNIL
)
2665 strcat (buf
, ", trapnil");
2666 if (e_flags
& EF_PARISC_EXT
)
2667 strcat (buf
, ", ext");
2668 if (e_flags
& EF_PARISC_LSB
)
2669 strcat (buf
, ", lsb");
2670 if (e_flags
& EF_PARISC_WIDE
)
2671 strcat (buf
, ", wide");
2672 if (e_flags
& EF_PARISC_NO_KABP
)
2673 strcat (buf
, ", no kabp");
2674 if (e_flags
& EF_PARISC_LAZYSWAP
)
2675 strcat (buf
, ", lazyswap");
2680 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2681 strcat (buf
, ", new calling convention");
2683 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2684 strcat (buf
, ", gnu calling convention");
2688 if ((e_flags
& EF_IA_64_ABI64
))
2689 strcat (buf
, ", 64-bit");
2691 strcat (buf
, ", 32-bit");
2692 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2693 strcat (buf
, ", reduced fp model");
2694 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2695 strcat (buf
, ", no function descriptors, constant gp");
2696 else if ((e_flags
& EF_IA_64_CONS_GP
))
2697 strcat (buf
, ", constant gp");
2698 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2699 strcat (buf
, ", absolute");
2700 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2702 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2703 strcat (buf
, ", vms_linkages");
2704 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2706 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2708 case EF_IA_64_VMS_COMCOD_WARNING
:
2709 strcat (buf
, ", warning");
2711 case EF_IA_64_VMS_COMCOD_ERROR
:
2712 strcat (buf
, ", error");
2714 case EF_IA_64_VMS_COMCOD_ABORT
:
2715 strcat (buf
, ", abort");
2724 if ((e_flags
& EF_VAX_NONPIC
))
2725 strcat (buf
, ", non-PIC");
2726 if ((e_flags
& EF_VAX_DFLOAT
))
2727 strcat (buf
, ", D-Float");
2728 if ((e_flags
& EF_VAX_GFLOAT
))
2729 strcat (buf
, ", G-Float");
2733 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2734 strcat (buf
, ", 64-bit doubles");
2735 if (e_flags
& E_FLAG_RX_DSP
)
2736 strcat (buf
, ", dsp");
2737 if (e_flags
& E_FLAG_RX_PID
)
2738 strcat (buf
, ", pid");
2739 if (e_flags
& E_FLAG_RX_ABI
)
2740 strcat (buf
, ", RX ABI");
2744 if (e_flags
& EF_S390_HIGH_GPRS
)
2745 strcat (buf
, ", highgprs");
2749 if ((e_flags
& EF_C6000_REL
))
2750 strcat (buf
, ", relocatable module");
2759 get_osabi_name (unsigned int osabi
)
2761 static char buff
[32];
2765 case ELFOSABI_NONE
: return "UNIX - System V";
2766 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2767 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2768 case ELFOSABI_GNU
: return "UNIX - GNU";
2769 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2770 case ELFOSABI_AIX
: return "UNIX - AIX";
2771 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2772 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2773 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2774 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2775 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2776 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2777 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2778 case ELFOSABI_AROS
: return "AROS";
2779 case ELFOSABI_FENIXOS
: return "FenixOS";
2782 switch (elf_header
.e_machine
)
2787 case ELFOSABI_ARM
: return "ARM";
2797 case ELFOSABI_STANDALONE
: return _("Standalone App");
2806 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2807 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2816 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2822 get_aarch64_segment_type (unsigned long type
)
2826 case PT_AARCH64_ARCHEXT
:
2827 return "AARCH64_ARCHEXT";
2836 get_arm_segment_type (unsigned long type
)
2850 get_mips_segment_type (unsigned long type
)
2854 case PT_MIPS_REGINFO
:
2856 case PT_MIPS_RTPROC
:
2858 case PT_MIPS_OPTIONS
:
2868 get_parisc_segment_type (unsigned long type
)
2872 case PT_HP_TLS
: return "HP_TLS";
2873 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2874 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2875 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2876 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2877 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2878 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2879 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2880 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2881 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2882 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2883 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2884 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2885 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2886 case PT_HP_STACK
: return "HP_STACK";
2887 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2888 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2889 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2890 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2899 get_ia64_segment_type (unsigned long type
)
2903 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2904 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2905 case PT_HP_TLS
: return "HP_TLS";
2906 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2907 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2908 case PT_IA_64_HP_STACK
: return "HP_STACK";
2917 get_tic6x_segment_type (unsigned long type
)
2921 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2930 get_segment_type (unsigned long p_type
)
2932 static char buff
[32];
2936 case PT_NULL
: return "NULL";
2937 case PT_LOAD
: return "LOAD";
2938 case PT_DYNAMIC
: return "DYNAMIC";
2939 case PT_INTERP
: return "INTERP";
2940 case PT_NOTE
: return "NOTE";
2941 case PT_SHLIB
: return "SHLIB";
2942 case PT_PHDR
: return "PHDR";
2943 case PT_TLS
: return "TLS";
2945 case PT_GNU_EH_FRAME
:
2946 return "GNU_EH_FRAME";
2947 case PT_GNU_STACK
: return "GNU_STACK";
2948 case PT_GNU_RELRO
: return "GNU_RELRO";
2951 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2953 const char * result
;
2955 switch (elf_header
.e_machine
)
2958 result
= get_aarch64_segment_type (p_type
);
2961 result
= get_arm_segment_type (p_type
);
2964 case EM_MIPS_RS3_LE
:
2965 result
= get_mips_segment_type (p_type
);
2968 result
= get_parisc_segment_type (p_type
);
2971 result
= get_ia64_segment_type (p_type
);
2974 result
= get_tic6x_segment_type (p_type
);
2984 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2986 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2988 const char * result
;
2990 switch (elf_header
.e_machine
)
2993 result
= get_parisc_segment_type (p_type
);
2996 result
= get_ia64_segment_type (p_type
);
3006 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3009 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3016 get_mips_section_type_name (unsigned int sh_type
)
3020 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3021 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3022 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3023 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3024 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3025 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3026 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3027 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3028 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3029 case SHT_MIPS_RELD
: return "MIPS_RELD";
3030 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3031 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3032 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3033 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3034 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3035 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3036 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3037 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3038 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3039 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3040 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3041 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3042 case SHT_MIPS_LINE
: return "MIPS_LINE";
3043 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3044 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3045 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3046 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3047 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3048 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3049 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3050 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3051 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3052 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3053 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3054 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3055 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3056 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3057 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3058 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3066 get_parisc_section_type_name (unsigned int sh_type
)
3070 case SHT_PARISC_EXT
: return "PARISC_EXT";
3071 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3072 case SHT_PARISC_DOC
: return "PARISC_DOC";
3073 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3074 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3075 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3076 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3084 get_ia64_section_type_name (unsigned int sh_type
)
3086 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3087 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3088 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3092 case SHT_IA_64_EXT
: return "IA_64_EXT";
3093 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3094 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3095 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3096 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3097 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3098 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3099 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3100 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3101 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3109 get_x86_64_section_type_name (unsigned int sh_type
)
3113 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3121 get_aarch64_section_type_name (unsigned int sh_type
)
3125 case SHT_AARCH64_ATTRIBUTES
:
3126 return "AARCH64_ATTRIBUTES";
3134 get_arm_section_type_name (unsigned int sh_type
)
3138 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3139 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3140 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3141 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3142 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3150 get_tic6x_section_type_name (unsigned int sh_type
)
3154 case SHT_C6000_UNWIND
:
3155 return "C6000_UNWIND";
3156 case SHT_C6000_PREEMPTMAP
:
3157 return "C6000_PREEMPTMAP";
3158 case SHT_C6000_ATTRIBUTES
:
3159 return "C6000_ATTRIBUTES";
3164 case SHT_TI_HANDLER
:
3165 return "TI_HANDLER";
3166 case SHT_TI_INITINFO
:
3167 return "TI_INITINFO";
3168 case SHT_TI_PHATTRS
:
3169 return "TI_PHATTRS";
3177 get_section_type_name (unsigned int sh_type
)
3179 static char buff
[32];
3183 case SHT_NULL
: return "NULL";
3184 case SHT_PROGBITS
: return "PROGBITS";
3185 case SHT_SYMTAB
: return "SYMTAB";
3186 case SHT_STRTAB
: return "STRTAB";
3187 case SHT_RELA
: return "RELA";
3188 case SHT_HASH
: return "HASH";
3189 case SHT_DYNAMIC
: return "DYNAMIC";
3190 case SHT_NOTE
: return "NOTE";
3191 case SHT_NOBITS
: return "NOBITS";
3192 case SHT_REL
: return "REL";
3193 case SHT_SHLIB
: return "SHLIB";
3194 case SHT_DYNSYM
: return "DYNSYM";
3195 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3196 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3197 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3198 case SHT_GNU_HASH
: return "GNU_HASH";
3199 case SHT_GROUP
: return "GROUP";
3200 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3201 case SHT_GNU_verdef
: return "VERDEF";
3202 case SHT_GNU_verneed
: return "VERNEED";
3203 case SHT_GNU_versym
: return "VERSYM";
3204 case 0x6ffffff0: return "VERSYM";
3205 case 0x6ffffffc: return "VERDEF";
3206 case 0x7ffffffd: return "AUXILIARY";
3207 case 0x7fffffff: return "FILTER";
3208 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3211 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3213 const char * result
;
3215 switch (elf_header
.e_machine
)
3218 case EM_MIPS_RS3_LE
:
3219 result
= get_mips_section_type_name (sh_type
);
3222 result
= get_parisc_section_type_name (sh_type
);
3225 result
= get_ia64_section_type_name (sh_type
);
3230 result
= get_x86_64_section_type_name (sh_type
);
3233 result
= get_aarch64_section_type_name (sh_type
);
3236 result
= get_arm_section_type_name (sh_type
);
3239 result
= get_tic6x_section_type_name (sh_type
);
3249 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3251 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3253 const char * result
;
3255 switch (elf_header
.e_machine
)
3258 result
= get_ia64_section_type_name (sh_type
);
3268 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3270 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3271 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3273 /* This message is probably going to be displayed in a 15
3274 character wide field, so put the hex value first. */
3275 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3281 #define OPTION_DEBUG_DUMP 512
3282 #define OPTION_DYN_SYMS 513
3283 #define OPTION_DWARF_DEPTH 514
3284 #define OPTION_DWARF_START 515
3285 #define OPTION_DWARF_CHECK 516
3287 static struct option options
[] =
3289 {"all", no_argument
, 0, 'a'},
3290 {"file-header", no_argument
, 0, 'h'},
3291 {"program-headers", no_argument
, 0, 'l'},
3292 {"headers", no_argument
, 0, 'e'},
3293 {"histogram", no_argument
, 0, 'I'},
3294 {"segments", no_argument
, 0, 'l'},
3295 {"sections", no_argument
, 0, 'S'},
3296 {"section-headers", no_argument
, 0, 'S'},
3297 {"section-groups", no_argument
, 0, 'g'},
3298 {"section-details", no_argument
, 0, 't'},
3299 {"full-section-name",no_argument
, 0, 'N'},
3300 {"symbols", no_argument
, 0, 's'},
3301 {"syms", no_argument
, 0, 's'},
3302 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3303 {"relocs", no_argument
, 0, 'r'},
3304 {"notes", no_argument
, 0, 'n'},
3305 {"dynamic", no_argument
, 0, 'd'},
3306 {"arch-specific", no_argument
, 0, 'A'},
3307 {"version-info", no_argument
, 0, 'V'},
3308 {"use-dynamic", no_argument
, 0, 'D'},
3309 {"unwind", no_argument
, 0, 'u'},
3310 {"archive-index", no_argument
, 0, 'c'},
3311 {"hex-dump", required_argument
, 0, 'x'},
3312 {"relocated-dump", required_argument
, 0, 'R'},
3313 {"string-dump", required_argument
, 0, 'p'},
3314 #ifdef SUPPORT_DISASSEMBLY
3315 {"instruction-dump", required_argument
, 0, 'i'},
3317 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3319 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
3320 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
3321 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
3323 {"version", no_argument
, 0, 'v'},
3324 {"wide", no_argument
, 0, 'W'},
3325 {"help", no_argument
, 0, 'H'},
3326 {0, no_argument
, 0, 0}
3330 usage (FILE * stream
)
3332 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3333 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3334 fprintf (stream
, _(" Options are:\n\
3335 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3336 -h --file-header Display the ELF file header\n\
3337 -l --program-headers Display the program headers\n\
3338 --segments An alias for --program-headers\n\
3339 -S --section-headers Display the sections' header\n\
3340 --sections An alias for --section-headers\n\
3341 -g --section-groups Display the section groups\n\
3342 -t --section-details Display the section details\n\
3343 -e --headers Equivalent to: -h -l -S\n\
3344 -s --syms Display the symbol table\n\
3345 --symbols An alias for --syms\n\
3346 --dyn-syms Display the dynamic symbol table\n\
3347 -n --notes Display the core notes (if present)\n\
3348 -r --relocs Display the relocations (if present)\n\
3349 -u --unwind Display the unwind info (if present)\n\
3350 -d --dynamic Display the dynamic section (if present)\n\
3351 -V --version-info Display the version sections (if present)\n\
3352 -A --arch-specific Display architecture specific information (if any)\n\
3353 -c --archive-index Display the symbol/file index in an archive\n\
3354 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3355 -x --hex-dump=<number|name>\n\
3356 Dump the contents of section <number|name> as bytes\n\
3357 -p --string-dump=<number|name>\n\
3358 Dump the contents of section <number|name> as strings\n\
3359 -R --relocated-dump=<number|name>\n\
3360 Dump the contents of section <number|name> as relocated bytes\n\
3361 -w[lLiaprmfFsoRt] or\n\
3362 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3363 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3364 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3366 Display the contents of DWARF2 debug sections\n"));
3367 fprintf (stream
, _("\
3368 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3369 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3371 #ifdef SUPPORT_DISASSEMBLY
3372 fprintf (stream
, _("\
3373 -i --instruction-dump=<number|name>\n\
3374 Disassemble the contents of section <number|name>\n"));
3376 fprintf (stream
, _("\
3377 -I --histogram Display histogram of bucket list lengths\n\
3378 -W --wide Allow output width to exceed 80 characters\n\
3379 @<file> Read options from <file>\n\
3380 -H --help Display this information\n\
3381 -v --version Display the version number of readelf\n"));
3383 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3384 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3386 exit (stream
== stdout
? 0 : 1);
3389 /* Record the fact that the user wants the contents of section number
3390 SECTION to be displayed using the method(s) encoded as flags bits
3391 in TYPE. Note, TYPE can be zero if we are creating the array for
3395 request_dump_bynumber (unsigned int section
, dump_type type
)
3397 if (section
>= num_dump_sects
)
3399 dump_type
* new_dump_sects
;
3401 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3402 sizeof (* dump_sects
));
3404 if (new_dump_sects
== NULL
)
3405 error (_("Out of memory allocating dump request table.\n"));
3408 /* Copy current flag settings. */
3409 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3413 dump_sects
= new_dump_sects
;
3414 num_dump_sects
= section
+ 1;
3419 dump_sects
[section
] |= type
;
3424 /* Request a dump by section name. */
3427 request_dump_byname (const char * section
, dump_type type
)
3429 struct dump_list_entry
* new_request
;
3431 new_request
= (struct dump_list_entry
*)
3432 malloc (sizeof (struct dump_list_entry
));
3434 error (_("Out of memory allocating dump request table.\n"));
3436 new_request
->name
= strdup (section
);
3437 if (!new_request
->name
)
3438 error (_("Out of memory allocating dump request table.\n"));
3440 new_request
->type
= type
;
3442 new_request
->next
= dump_sects_byname
;
3443 dump_sects_byname
= new_request
;
3447 request_dump (dump_type type
)
3453 section
= strtoul (optarg
, & cp
, 0);
3455 if (! *cp
&& section
>= 0)
3456 request_dump_bynumber (section
, type
);
3458 request_dump_byname (optarg
, type
);
3463 parse_args (int argc
, char ** argv
)
3470 while ((c
= getopt_long
3471 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3489 do_section_groups
++;
3497 do_section_groups
++;
3502 do_section_details
++;
3546 request_dump (HEX_DUMP
);
3549 request_dump (STRING_DUMP
);
3552 request_dump (RELOC_DUMP
);
3559 dwarf_select_sections_all ();
3564 dwarf_select_sections_by_letters (optarg
);
3567 case OPTION_DEBUG_DUMP
:
3574 dwarf_select_sections_by_names (optarg
);
3577 case OPTION_DWARF_DEPTH
:
3581 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
3584 case OPTION_DWARF_START
:
3588 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
3591 case OPTION_DWARF_CHECK
:
3594 case OPTION_DYN_SYMS
:
3597 #ifdef SUPPORT_DISASSEMBLY
3599 request_dump (DISASS_DUMP
);
3603 print_version (program_name
);
3612 /* xgettext:c-format */
3613 error (_("Invalid option '-%c'\n"), c
);
3620 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3621 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3622 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3623 && !do_section_groups
&& !do_archive_index
3628 warn (_("Nothing to do.\n"));
3634 get_elf_class (unsigned int elf_class
)
3636 static char buff
[32];
3640 case ELFCLASSNONE
: return _("none");
3641 case ELFCLASS32
: return "ELF32";
3642 case ELFCLASS64
: return "ELF64";
3644 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3650 get_data_encoding (unsigned int encoding
)
3652 static char buff
[32];
3656 case ELFDATANONE
: return _("none");
3657 case ELFDATA2LSB
: return _("2's complement, little endian");
3658 case ELFDATA2MSB
: return _("2's complement, big endian");
3660 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3665 /* Decode the data held in 'elf_header'. */
3668 process_file_header (void)
3670 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3671 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3672 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3673 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3676 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3680 init_dwarf_regnames (elf_header
.e_machine
);
3686 printf (_("ELF Header:\n"));
3687 printf (_(" Magic: "));
3688 for (i
= 0; i
< EI_NIDENT
; i
++)
3689 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3691 printf (_(" Class: %s\n"),
3692 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3693 printf (_(" Data: %s\n"),
3694 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3695 printf (_(" Version: %d %s\n"),
3696 elf_header
.e_ident
[EI_VERSION
],
3697 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3699 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3700 ? _("<unknown: %lx>")
3702 printf (_(" OS/ABI: %s\n"),
3703 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3704 printf (_(" ABI Version: %d\n"),
3705 elf_header
.e_ident
[EI_ABIVERSION
]);
3706 printf (_(" Type: %s\n"),
3707 get_file_type (elf_header
.e_type
));
3708 printf (_(" Machine: %s\n"),
3709 get_machine_name (elf_header
.e_machine
));
3710 printf (_(" Version: 0x%lx\n"),
3711 (unsigned long) elf_header
.e_version
);
3713 printf (_(" Entry point address: "));
3714 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3715 printf (_("\n Start of program headers: "));
3716 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3717 printf (_(" (bytes into file)\n Start of section headers: "));
3718 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3719 printf (_(" (bytes into file)\n"));
3721 printf (_(" Flags: 0x%lx%s\n"),
3722 (unsigned long) elf_header
.e_flags
,
3723 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3724 printf (_(" Size of this header: %ld (bytes)\n"),
3725 (long) elf_header
.e_ehsize
);
3726 printf (_(" Size of program headers: %ld (bytes)\n"),
3727 (long) elf_header
.e_phentsize
);
3728 printf (_(" Number of program headers: %ld"),
3729 (long) elf_header
.e_phnum
);
3730 if (section_headers
!= NULL
3731 && elf_header
.e_phnum
== PN_XNUM
3732 && section_headers
[0].sh_info
!= 0)
3733 printf (" (%ld)", (long) section_headers
[0].sh_info
);
3734 putc ('\n', stdout
);
3735 printf (_(" Size of section headers: %ld (bytes)\n"),
3736 (long) elf_header
.e_shentsize
);
3737 printf (_(" Number of section headers: %ld"),
3738 (long) elf_header
.e_shnum
);
3739 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3740 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3741 putc ('\n', stdout
);
3742 printf (_(" Section header string table index: %ld"),
3743 (long) elf_header
.e_shstrndx
);
3744 if (section_headers
!= NULL
3745 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3746 printf (" (%u)", section_headers
[0].sh_link
);
3747 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3748 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3749 printf (_(" <corrupt: out of range>"));
3750 putc ('\n', stdout
);
3753 if (section_headers
!= NULL
)
3755 if (elf_header
.e_phnum
== PN_XNUM
3756 && section_headers
[0].sh_info
!= 0)
3757 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3758 if (elf_header
.e_shnum
== SHN_UNDEF
)
3759 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3760 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3761 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3762 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3763 elf_header
.e_shstrndx
= SHN_UNDEF
;
3764 free (section_headers
);
3765 section_headers
= NULL
;
3773 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3775 Elf32_External_Phdr
* phdrs
;
3776 Elf32_External_Phdr
* external
;
3777 Elf_Internal_Phdr
* internal
;
3780 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3781 elf_header
.e_phentsize
,
3783 _("program headers"));
3787 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3788 i
< elf_header
.e_phnum
;
3789 i
++, internal
++, external
++)
3791 internal
->p_type
= BYTE_GET (external
->p_type
);
3792 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3793 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3794 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3795 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3796 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3797 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3798 internal
->p_align
= BYTE_GET (external
->p_align
);
3807 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3809 Elf64_External_Phdr
* phdrs
;
3810 Elf64_External_Phdr
* external
;
3811 Elf_Internal_Phdr
* internal
;
3814 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3815 elf_header
.e_phentsize
,
3817 _("program headers"));
3821 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3822 i
< elf_header
.e_phnum
;
3823 i
++, internal
++, external
++)
3825 internal
->p_type
= BYTE_GET (external
->p_type
);
3826 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3827 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3828 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3829 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3830 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3831 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3832 internal
->p_align
= BYTE_GET (external
->p_align
);
3840 /* Returns 1 if the program headers were read into `program_headers'. */
3843 get_program_headers (FILE * file
)
3845 Elf_Internal_Phdr
* phdrs
;
3847 /* Check cache of prior read. */
3848 if (program_headers
!= NULL
)
3851 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3852 sizeof (Elf_Internal_Phdr
));
3856 error (_("Out of memory\n"));
3861 ? get_32bit_program_headers (file
, phdrs
)
3862 : get_64bit_program_headers (file
, phdrs
))
3864 program_headers
= phdrs
;
3872 /* Returns 1 if the program headers were loaded. */
3875 process_program_headers (FILE * file
)
3877 Elf_Internal_Phdr
* segment
;
3880 if (elf_header
.e_phnum
== 0)
3882 /* PR binutils/12467. */
3883 if (elf_header
.e_phoff
!= 0)
3884 warn (_("possibly corrupt ELF header - it has a non-zero program"
3885 " header offset, but no program headers"));
3886 else if (do_segments
)
3887 printf (_("\nThere are no program headers in this file.\n"));
3891 if (do_segments
&& !do_header
)
3893 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3894 printf (_("Entry point "));
3895 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3896 printf (_("\nThere are %d program headers, starting at offset "),
3897 elf_header
.e_phnum
);
3898 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3902 if (! get_program_headers (file
))
3907 if (elf_header
.e_phnum
> 1)
3908 printf (_("\nProgram Headers:\n"));
3910 printf (_("\nProgram Headers:\n"));
3914 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3917 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3921 (_(" Type Offset VirtAddr PhysAddr\n"));
3923 (_(" FileSiz MemSiz Flags Align\n"));
3930 for (i
= 0, segment
= program_headers
;
3931 i
< elf_header
.e_phnum
;
3936 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3940 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3941 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3942 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3943 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3944 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3946 (segment
->p_flags
& PF_R
? 'R' : ' '),
3947 (segment
->p_flags
& PF_W
? 'W' : ' '),
3948 (segment
->p_flags
& PF_X
? 'E' : ' '));
3949 printf ("%#lx", (unsigned long) segment
->p_align
);
3953 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3954 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3957 print_vma (segment
->p_offset
, FULL_HEX
);
3961 print_vma (segment
->p_vaddr
, FULL_HEX
);
3963 print_vma (segment
->p_paddr
, FULL_HEX
);
3966 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3967 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3970 print_vma (segment
->p_filesz
, FULL_HEX
);
3974 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3975 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3978 print_vma (segment
->p_memsz
, FULL_HEX
);
3982 (segment
->p_flags
& PF_R
? 'R' : ' '),
3983 (segment
->p_flags
& PF_W
? 'W' : ' '),
3984 (segment
->p_flags
& PF_X
? 'E' : ' '));
3986 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3987 printf ("%#lx", (unsigned long) segment
->p_align
);
3990 print_vma (segment
->p_align
, PREFIX_HEX
);
3995 print_vma (segment
->p_offset
, FULL_HEX
);
3997 print_vma (segment
->p_vaddr
, FULL_HEX
);
3999 print_vma (segment
->p_paddr
, FULL_HEX
);
4001 print_vma (segment
->p_filesz
, FULL_HEX
);
4003 print_vma (segment
->p_memsz
, FULL_HEX
);
4005 (segment
->p_flags
& PF_R
? 'R' : ' '),
4006 (segment
->p_flags
& PF_W
? 'W' : ' '),
4007 (segment
->p_flags
& PF_X
? 'E' : ' '));
4008 print_vma (segment
->p_align
, HEX
);
4012 switch (segment
->p_type
)
4016 error (_("more than one dynamic segment\n"));
4018 /* By default, assume that the .dynamic section is the first
4019 section in the DYNAMIC segment. */
4020 dynamic_addr
= segment
->p_offset
;
4021 dynamic_size
= segment
->p_filesz
;
4023 /* Try to locate the .dynamic section. If there is
4024 a section header table, we can easily locate it. */
4025 if (section_headers
!= NULL
)
4027 Elf_Internal_Shdr
* sec
;
4029 sec
= find_section (".dynamic");
4030 if (sec
== NULL
|| sec
->sh_size
== 0)
4032 /* A corresponding .dynamic section is expected, but on
4033 IA-64/OpenVMS it is OK for it to be missing. */
4034 if (!is_ia64_vms ())
4035 error (_("no .dynamic section in the dynamic segment\n"));
4039 if (sec
->sh_type
== SHT_NOBITS
)
4045 dynamic_addr
= sec
->sh_offset
;
4046 dynamic_size
= sec
->sh_size
;
4048 if (dynamic_addr
< segment
->p_offset
4049 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4050 warn (_("the .dynamic section is not contained"
4051 " within the dynamic segment\n"));
4052 else if (dynamic_addr
> segment
->p_offset
)
4053 warn (_("the .dynamic section is not the first section"
4054 " in the dynamic segment.\n"));
4059 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4061 error (_("Unable to find program interpreter name\n"));
4065 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
4067 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4068 error (_("Internal error: failed to create format string to display program interpreter\n"));
4070 program_interpreter
[0] = 0;
4071 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4072 error (_("Unable to read program interpreter name\n"));
4075 printf (_("\n [Requesting program interpreter: %s]"),
4076 program_interpreter
);
4082 putc ('\n', stdout
);
4085 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4087 printf (_("\n Section to Segment mapping:\n"));
4088 printf (_(" Segment Sections...\n"));
4090 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4093 Elf_Internal_Shdr
* section
;
4095 segment
= program_headers
+ i
;
4096 section
= section_headers
+ 1;
4098 printf (" %2.2d ", i
);
4100 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4102 if (!ELF_TBSS_SPECIAL (section
, segment
)
4103 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4104 printf ("%s ", SECTION_NAME (section
));
4115 /* Find the file offset corresponding to VMA by using the program headers. */
4118 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4120 Elf_Internal_Phdr
* seg
;
4122 if (! get_program_headers (file
))
4124 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4128 for (seg
= program_headers
;
4129 seg
< program_headers
+ elf_header
.e_phnum
;
4132 if (seg
->p_type
!= PT_LOAD
)
4135 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4136 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4137 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4140 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4141 (unsigned long) vma
);
4147 get_32bit_section_headers (FILE * file
, unsigned int num
)
4149 Elf32_External_Shdr
* shdrs
;
4150 Elf_Internal_Shdr
* internal
;
4153 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4154 elf_header
.e_shentsize
, num
,
4155 _("section headers"));
4159 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4160 sizeof (Elf_Internal_Shdr
));
4162 if (section_headers
== NULL
)
4164 error (_("Out of memory\n"));
4168 for (i
= 0, internal
= section_headers
;
4172 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4173 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4174 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4175 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4176 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4177 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4178 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4179 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4180 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4181 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4190 get_64bit_section_headers (FILE * file
, unsigned int num
)
4192 Elf64_External_Shdr
* shdrs
;
4193 Elf_Internal_Shdr
* internal
;
4196 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4197 elf_header
.e_shentsize
, num
,
4198 _("section headers"));
4202 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4203 sizeof (Elf_Internal_Shdr
));
4205 if (section_headers
== NULL
)
4207 error (_("Out of memory\n"));
4211 for (i
= 0, internal
= section_headers
;
4215 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4216 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4217 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4218 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4219 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4220 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4221 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4222 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4223 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4224 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4232 static Elf_Internal_Sym
*
4233 get_32bit_elf_symbols (FILE * file
,
4234 Elf_Internal_Shdr
* section
,
4235 unsigned long * num_syms_return
)
4237 unsigned long number
= 0;
4238 Elf32_External_Sym
* esyms
= NULL
;
4239 Elf_External_Sym_Shndx
* shndx
= NULL
;
4240 Elf_Internal_Sym
* isyms
= NULL
;
4241 Elf_Internal_Sym
* psym
;
4244 /* Run some sanity checks first. */
4245 if (section
->sh_entsize
== 0)
4247 error (_("sh_entsize is zero\n"));
4251 number
= section
->sh_size
/ section
->sh_entsize
;
4253 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
4255 error (_("Invalid sh_entsize\n"));
4259 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4260 section
->sh_size
, _("symbols"));
4265 if (symtab_shndx_hdr
!= NULL
4266 && (symtab_shndx_hdr
->sh_link
4267 == (unsigned long) (section
- section_headers
)))
4269 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4270 symtab_shndx_hdr
->sh_offset
,
4271 1, symtab_shndx_hdr
->sh_size
,
4272 _("symbol table section indicies"));
4277 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4281 error (_("Out of memory\n"));
4285 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4287 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4288 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4289 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4290 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4291 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4293 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4294 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4295 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4296 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4297 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4306 if (num_syms_return
!= NULL
)
4307 * num_syms_return
= isyms
== NULL
? 0 : number
;
4312 static Elf_Internal_Sym
*
4313 get_64bit_elf_symbols (FILE * file
,
4314 Elf_Internal_Shdr
* section
,
4315 unsigned long * num_syms_return
)
4317 unsigned long number
= 0;
4318 Elf64_External_Sym
* esyms
= NULL
;
4319 Elf_External_Sym_Shndx
* shndx
= NULL
;
4320 Elf_Internal_Sym
* isyms
= NULL
;
4321 Elf_Internal_Sym
* psym
;
4324 /* Run some sanity checks first. */
4325 if (section
->sh_entsize
== 0)
4327 error (_("sh_entsize is zero\n"));
4331 number
= section
->sh_size
/ section
->sh_entsize
;
4333 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
4335 error (_("Invalid sh_entsize\n"));
4339 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4340 section
->sh_size
, _("symbols"));
4344 if (symtab_shndx_hdr
!= NULL
4345 && (symtab_shndx_hdr
->sh_link
4346 == (unsigned long) (section
- section_headers
)))
4348 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4349 symtab_shndx_hdr
->sh_offset
,
4350 1, symtab_shndx_hdr
->sh_size
,
4351 _("symbol table section indicies"));
4356 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4360 error (_("Out of memory\n"));
4364 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
4366 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4367 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4368 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4369 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4371 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4373 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4374 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4375 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4377 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4378 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4387 if (num_syms_return
!= NULL
)
4388 * num_syms_return
= isyms
== NULL
? 0 : number
;
4394 get_elf_section_flags (bfd_vma sh_flags
)
4396 static char buff
[1024];
4398 int field_size
= is_32bit_elf
? 8 : 16;
4400 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4401 bfd_vma os_flags
= 0;
4402 bfd_vma proc_flags
= 0;
4403 bfd_vma unknown_flags
= 0;
4411 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4412 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4413 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4414 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4415 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4416 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4417 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4418 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4419 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4420 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4421 /* IA-64 specific. */
4422 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4423 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4424 /* IA-64 OpenVMS specific. */
4425 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4426 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4427 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4428 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4429 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4430 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4432 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4433 /* SPARC specific. */
4434 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4437 if (do_section_details
)
4439 sprintf (buff
, "[%*.*lx]: ",
4440 field_size
, field_size
, (unsigned long) sh_flags
);
4441 p
+= field_size
+ 4;
4448 flag
= sh_flags
& - sh_flags
;
4451 if (do_section_details
)
4455 case SHF_WRITE
: sindex
= 0; break;
4456 case SHF_ALLOC
: sindex
= 1; break;
4457 case SHF_EXECINSTR
: sindex
= 2; break;
4458 case SHF_MERGE
: sindex
= 3; break;
4459 case SHF_STRINGS
: sindex
= 4; break;
4460 case SHF_INFO_LINK
: sindex
= 5; break;
4461 case SHF_LINK_ORDER
: sindex
= 6; break;
4462 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4463 case SHF_GROUP
: sindex
= 8; break;
4464 case SHF_TLS
: sindex
= 9; break;
4465 case SHF_EXCLUDE
: sindex
= 18; break;
4469 switch (elf_header
.e_machine
)
4472 if (flag
== SHF_IA_64_SHORT
)
4474 else if (flag
== SHF_IA_64_NORECOV
)
4477 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4480 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4481 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4482 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4483 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4484 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4485 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4496 case EM_OLD_SPARCV9
:
4497 case EM_SPARC32PLUS
:
4500 if (flag
== SHF_ORDERED
)
4510 if (p
!= buff
+ field_size
+ 4)
4512 if (size
< (10 + 2))
4519 size
-= flags
[sindex
].len
;
4520 p
= stpcpy (p
, flags
[sindex
].str
);
4522 else if (flag
& SHF_MASKOS
)
4524 else if (flag
& SHF_MASKPROC
)
4527 unknown_flags
|= flag
;
4533 case SHF_WRITE
: *p
= 'W'; break;
4534 case SHF_ALLOC
: *p
= 'A'; break;
4535 case SHF_EXECINSTR
: *p
= 'X'; break;
4536 case SHF_MERGE
: *p
= 'M'; break;
4537 case SHF_STRINGS
: *p
= 'S'; break;
4538 case SHF_INFO_LINK
: *p
= 'I'; break;
4539 case SHF_LINK_ORDER
: *p
= 'L'; break;
4540 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4541 case SHF_GROUP
: *p
= 'G'; break;
4542 case SHF_TLS
: *p
= 'T'; break;
4543 case SHF_EXCLUDE
: *p
= 'E'; break;
4546 if ((elf_header
.e_machine
== EM_X86_64
4547 || elf_header
.e_machine
== EM_L1OM
4548 || elf_header
.e_machine
== EM_K1OM
)
4549 && flag
== SHF_X86_64_LARGE
)
4551 else if (flag
& SHF_MASKOS
)
4554 sh_flags
&= ~ SHF_MASKOS
;
4556 else if (flag
& SHF_MASKPROC
)
4559 sh_flags
&= ~ SHF_MASKPROC
;
4569 if (do_section_details
)
4573 size
-= 5 + field_size
;
4574 if (p
!= buff
+ field_size
+ 4)
4582 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4583 (unsigned long) os_flags
);
4584 p
+= 5 + field_size
;
4588 size
-= 7 + field_size
;
4589 if (p
!= buff
+ field_size
+ 4)
4597 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4598 (unsigned long) proc_flags
);
4599 p
+= 7 + field_size
;
4603 size
-= 10 + field_size
;
4604 if (p
!= buff
+ field_size
+ 4)
4612 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4613 (unsigned long) unknown_flags
);
4614 p
+= 10 + field_size
;
4623 process_section_headers (FILE * file
)
4625 Elf_Internal_Shdr
* section
;
4628 section_headers
= NULL
;
4630 if (elf_header
.e_shnum
== 0)
4632 /* PR binutils/12467. */
4633 if (elf_header
.e_shoff
!= 0)
4634 warn (_("possibly corrupt ELF file header - it has a non-zero"
4635 " section header offset, but no section headers\n"));
4636 else if (do_sections
)
4637 printf (_("\nThere are no sections in this file.\n"));
4642 if (do_sections
&& !do_header
)
4643 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4644 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4648 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4651 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4654 /* Read in the string table, so that we have names to display. */
4655 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4656 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4658 section
= section_headers
+ elf_header
.e_shstrndx
;
4660 if (section
->sh_size
!= 0)
4662 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4663 1, section
->sh_size
,
4666 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4670 /* Scan the sections for the dynamic symbol table
4671 and dynamic string table and debug sections. */
4672 dynamic_symbols
= NULL
;
4673 dynamic_strings
= NULL
;
4674 dynamic_syminfo
= NULL
;
4675 symtab_shndx_hdr
= NULL
;
4677 eh_addr_size
= is_32bit_elf
? 4 : 8;
4678 switch (elf_header
.e_machine
)
4681 case EM_MIPS_RS3_LE
:
4682 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4683 FDE addresses. However, the ABI also has a semi-official ILP32
4684 variant for which the normal FDE address size rules apply.
4686 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4687 section, where XX is the size of longs in bits. Unfortunately,
4688 earlier compilers provided no way of distinguishing ILP32 objects
4689 from LP64 objects, so if there's any doubt, we should assume that
4690 the official LP64 form is being used. */
4691 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4692 && find_section (".gcc_compiled_long32") == NULL
)
4698 switch (elf_header
.e_flags
& EF_H8_MACH
)
4700 case E_H8_MACH_H8300
:
4701 case E_H8_MACH_H8300HN
:
4702 case E_H8_MACH_H8300SN
:
4703 case E_H8_MACH_H8300SXN
:
4706 case E_H8_MACH_H8300H
:
4707 case E_H8_MACH_H8300S
:
4708 case E_H8_MACH_H8300SX
:
4716 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4718 case EF_M32C_CPU_M16C
:
4725 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4728 size_t expected_entsize \
4729 = is_32bit_elf ? size32 : size64; \
4730 if (section->sh_entsize != expected_entsize) \
4731 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4732 i, (unsigned long int) section->sh_entsize, \
4733 (unsigned long int) expected_entsize); \
4734 section->sh_entsize = expected_entsize; \
4737 #define CHECK_ENTSIZE(section, i, type) \
4738 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4739 sizeof (Elf64_External_##type))
4741 for (i
= 0, section
= section_headers
;
4742 i
< elf_header
.e_shnum
;
4745 char * name
= SECTION_NAME (section
);
4747 if (section
->sh_type
== SHT_DYNSYM
)
4749 if (dynamic_symbols
!= NULL
)
4751 error (_("File contains multiple dynamic symbol tables\n"));
4755 CHECK_ENTSIZE (section
, i
, Sym
);
4756 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
4758 else if (section
->sh_type
== SHT_STRTAB
4759 && streq (name
, ".dynstr"))
4761 if (dynamic_strings
!= NULL
)
4763 error (_("File contains multiple dynamic string tables\n"));
4767 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4768 1, section
->sh_size
,
4769 _("dynamic strings"));
4770 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
4772 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4774 if (symtab_shndx_hdr
!= NULL
)
4776 error (_("File contains multiple symtab shndx tables\n"));
4779 symtab_shndx_hdr
= section
;
4781 else if (section
->sh_type
== SHT_SYMTAB
)
4782 CHECK_ENTSIZE (section
, i
, Sym
);
4783 else if (section
->sh_type
== SHT_GROUP
)
4784 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4785 else if (section
->sh_type
== SHT_REL
)
4786 CHECK_ENTSIZE (section
, i
, Rel
);
4787 else if (section
->sh_type
== SHT_RELA
)
4788 CHECK_ENTSIZE (section
, i
, Rela
);
4789 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4790 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4791 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4792 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
4793 || do_debug_addr
|| do_debug_cu_index
)
4794 && (const_strneq (name
, ".debug_")
4795 || const_strneq (name
, ".zdebug_")))
4798 name
+= sizeof (".zdebug_") - 1;
4800 name
+= sizeof (".debug_") - 1;
4803 || (do_debug_info
&& const_strneq (name
, "info"))
4804 || (do_debug_info
&& const_strneq (name
, "types"))
4805 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
4806 || (do_debug_lines
&& const_strneq (name
, "line"))
4807 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
4808 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
4809 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
4810 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
4811 || (do_debug_frames
&& const_strneq (name
, "frame"))
4812 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
4813 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
4814 || (do_debug_str
&& const_strneq (name
, "str"))
4815 || (do_debug_loc
&& const_strneq (name
, "loc"))
4816 || (do_debug_addr
&& const_strneq (name
, "addr"))
4817 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
4818 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
4820 request_dump_bynumber (i
, DEBUG_DUMP
);
4822 /* Linkonce section to be combined with .debug_info at link time. */
4823 else if ((do_debugging
|| do_debug_info
)
4824 && const_strneq (name
, ".gnu.linkonce.wi."))
4825 request_dump_bynumber (i
, DEBUG_DUMP
);
4826 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4827 request_dump_bynumber (i
, DEBUG_DUMP
);
4828 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
4829 request_dump_bynumber (i
, DEBUG_DUMP
);
4830 /* Trace sections for Itanium VMS. */
4831 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4832 || do_trace_aranges
)
4833 && const_strneq (name
, ".trace_"))
4835 name
+= sizeof (".trace_") - 1;
4838 || (do_trace_info
&& streq (name
, "info"))
4839 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4840 || (do_trace_aranges
&& streq (name
, "aranges"))
4842 request_dump_bynumber (i
, DEBUG_DUMP
);
4850 if (elf_header
.e_shnum
> 1)
4851 printf (_("\nSection Headers:\n"));
4853 printf (_("\nSection Header:\n"));
4857 if (do_section_details
)
4859 printf (_(" [Nr] Name\n"));
4860 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4864 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4868 if (do_section_details
)
4870 printf (_(" [Nr] Name\n"));
4871 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4875 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4879 if (do_section_details
)
4881 printf (_(" [Nr] Name\n"));
4882 printf (_(" Type Address Offset Link\n"));
4883 printf (_(" Size EntSize Info Align\n"));
4887 printf (_(" [Nr] Name Type Address Offset\n"));
4888 printf (_(" Size EntSize Flags Link Info Align\n"));
4892 if (do_section_details
)
4893 printf (_(" Flags\n"));
4895 for (i
= 0, section
= section_headers
;
4896 i
< elf_header
.e_shnum
;
4899 printf (" [%2u] ", i
);
4900 if (do_section_details
)
4902 print_symbol (INT_MAX
, SECTION_NAME (section
));
4907 print_symbol (-17, SECTION_NAME (section
));
4910 printf (do_wide
? " %-15s " : " %-15.15s ",
4911 get_section_type_name (section
->sh_type
));
4915 const char * link_too_big
= NULL
;
4917 print_vma (section
->sh_addr
, LONG_HEX
);
4919 printf ( " %6.6lx %6.6lx %2.2lx",
4920 (unsigned long) section
->sh_offset
,
4921 (unsigned long) section
->sh_size
,
4922 (unsigned long) section
->sh_entsize
);
4924 if (do_section_details
)
4925 fputs (" ", stdout
);
4927 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4929 if (section
->sh_link
>= elf_header
.e_shnum
)
4932 /* The sh_link value is out of range. Normally this indicates
4933 an error but it can have special values in Solaris binaries. */
4934 switch (elf_header
.e_machine
)
4941 case EM_OLD_SPARCV9
:
4942 case EM_SPARC32PLUS
:
4945 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4946 link_too_big
= "BEFORE";
4947 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4948 link_too_big
= "AFTER";
4955 if (do_section_details
)
4957 if (link_too_big
!= NULL
&& * link_too_big
)
4958 printf ("<%s> ", link_too_big
);
4960 printf ("%2u ", section
->sh_link
);
4961 printf ("%3u %2lu\n", section
->sh_info
,
4962 (unsigned long) section
->sh_addralign
);
4965 printf ("%2u %3u %2lu\n",
4968 (unsigned long) section
->sh_addralign
);
4970 if (link_too_big
&& ! * link_too_big
)
4971 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4972 i
, section
->sh_link
);
4976 print_vma (section
->sh_addr
, LONG_HEX
);
4978 if ((long) section
->sh_offset
== section
->sh_offset
)
4979 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4983 print_vma (section
->sh_offset
, LONG_HEX
);
4986 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4987 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4991 print_vma (section
->sh_size
, LONG_HEX
);
4994 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4995 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4999 print_vma (section
->sh_entsize
, LONG_HEX
);
5002 if (do_section_details
)
5003 fputs (" ", stdout
);
5005 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5007 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5009 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5010 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5013 print_vma (section
->sh_addralign
, DEC
);
5017 else if (do_section_details
)
5019 printf (" %-15.15s ",
5020 get_section_type_name (section
->sh_type
));
5021 print_vma (section
->sh_addr
, LONG_HEX
);
5022 if ((long) section
->sh_offset
== section
->sh_offset
)
5023 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5027 print_vma (section
->sh_offset
, LONG_HEX
);
5029 printf (" %u\n ", section
->sh_link
);
5030 print_vma (section
->sh_size
, LONG_HEX
);
5032 print_vma (section
->sh_entsize
, LONG_HEX
);
5034 printf (" %-16u %lu\n",
5036 (unsigned long) section
->sh_addralign
);
5041 print_vma (section
->sh_addr
, LONG_HEX
);
5042 if ((long) section
->sh_offset
== section
->sh_offset
)
5043 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5047 print_vma (section
->sh_offset
, LONG_HEX
);
5050 print_vma (section
->sh_size
, LONG_HEX
);
5052 print_vma (section
->sh_entsize
, LONG_HEX
);
5054 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5056 printf (" %2u %3u %lu\n",
5059 (unsigned long) section
->sh_addralign
);
5062 if (do_section_details
)
5063 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5066 if (!do_section_details
)
5068 if (elf_header
.e_machine
== EM_X86_64
5069 || elf_header
.e_machine
== EM_L1OM
5070 || elf_header
.e_machine
== EM_K1OM
)
5071 printf (_("Key to Flags:\n\
5072 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5073 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5074 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5076 printf (_("Key to Flags:\n\
5077 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5078 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5079 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5086 get_group_flags (unsigned int flags
)
5088 static char buff
[32];
5098 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
5105 process_section_groups (FILE * file
)
5107 Elf_Internal_Shdr
* section
;
5109 struct group
* group
;
5110 Elf_Internal_Shdr
* symtab_sec
;
5111 Elf_Internal_Shdr
* strtab_sec
;
5112 Elf_Internal_Sym
* symtab
;
5113 unsigned long num_syms
;
5117 /* Don't process section groups unless needed. */
5118 if (!do_unwind
&& !do_section_groups
)
5121 if (elf_header
.e_shnum
== 0)
5123 if (do_section_groups
)
5124 printf (_("\nThere are no sections to group in this file.\n"));
5129 if (section_headers
== NULL
)
5131 error (_("Section headers are not available!\n"));
5132 /* PR 13622: This can happen with a corrupt ELF header. */
5136 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
5137 sizeof (struct group
*));
5139 if (section_headers_groups
== NULL
)
5141 error (_("Out of memory\n"));
5145 /* Scan the sections for the group section. */
5147 for (i
= 0, section
= section_headers
;
5148 i
< elf_header
.e_shnum
;
5150 if (section
->sh_type
== SHT_GROUP
)
5153 if (group_count
== 0)
5155 if (do_section_groups
)
5156 printf (_("\nThere are no section groups in this file.\n"));
5161 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
5163 if (section_groups
== NULL
)
5165 error (_("Out of memory\n"));
5175 for (i
= 0, section
= section_headers
, group
= section_groups
;
5176 i
< elf_header
.e_shnum
;
5179 if (section
->sh_type
== SHT_GROUP
)
5181 char * name
= SECTION_NAME (section
);
5183 unsigned char * start
;
5184 unsigned char * indices
;
5185 unsigned int entry
, j
, size
;
5186 Elf_Internal_Shdr
* sec
;
5187 Elf_Internal_Sym
* sym
;
5189 /* Get the symbol table. */
5190 if (section
->sh_link
>= elf_header
.e_shnum
5191 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
5194 error (_("Bad sh_link in group section `%s'\n"), name
);
5198 if (symtab_sec
!= sec
)
5203 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
5208 error (_("Corrupt header in group section `%s'\n"), name
);
5212 if (section
->sh_info
>= num_syms
)
5214 error (_("Bad sh_info in group section `%s'\n"), name
);
5218 sym
= symtab
+ section
->sh_info
;
5220 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
5222 if (sym
->st_shndx
== 0
5223 || sym
->st_shndx
>= elf_header
.e_shnum
)
5225 error (_("Bad sh_info in group section `%s'\n"), name
);
5229 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
5238 /* Get the string table. */
5239 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
5248 != (sec
= section_headers
+ symtab_sec
->sh_link
))
5253 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
5254 1, strtab_sec
->sh_size
,
5256 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
5258 group_name
= sym
->st_name
< strtab_size
5259 ? strtab
+ sym
->st_name
: _("<corrupt>");
5262 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
5263 1, section
->sh_size
,
5269 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
5270 entry
= byte_get (indices
, 4);
5273 if (do_section_groups
)
5275 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5276 get_group_flags (entry
), i
, name
, group_name
, size
);
5278 printf (_(" [Index] Name\n"));
5281 group
->group_index
= i
;
5283 for (j
= 0; j
< size
; j
++)
5285 struct group_list
* g
;
5287 entry
= byte_get (indices
, 4);
5290 if (entry
>= elf_header
.e_shnum
)
5292 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5293 entry
, i
, elf_header
.e_shnum
- 1);
5297 if (section_headers_groups
[entry
] != NULL
)
5301 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5303 section_headers_groups
[entry
]->group_index
);
5308 /* Intel C/C++ compiler may put section 0 in a
5309 section group. We just warn it the first time
5310 and ignore it afterwards. */
5311 static int warned
= 0;
5314 error (_("section 0 in group section [%5u]\n"),
5315 section_headers_groups
[entry
]->group_index
);
5321 section_headers_groups
[entry
] = group
;
5323 if (do_section_groups
)
5325 sec
= section_headers
+ entry
;
5326 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5329 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5330 g
->section_index
= entry
;
5331 g
->next
= group
->root
;
5349 /* Data used to display dynamic fixups. */
5351 struct ia64_vms_dynfixup
5353 bfd_vma needed_ident
; /* Library ident number. */
5354 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5355 bfd_vma fixup_needed
; /* Index of the library. */
5356 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5357 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5360 /* Data used to display dynamic relocations. */
5362 struct ia64_vms_dynimgrela
5364 bfd_vma img_rela_cnt
; /* Number of relocations. */
5365 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5368 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5372 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5373 const char *strtab
, unsigned int strtab_sz
)
5375 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5377 const char *lib_name
;
5379 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5380 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5381 _("dynamic section image fixups"));
5385 if (fixup
->needed
< strtab_sz
)
5386 lib_name
= strtab
+ fixup
->needed
;
5389 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5390 (unsigned long) fixup
->needed
);
5393 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5394 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5396 (_("Seg Offset Type SymVec DataType\n"));
5398 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5403 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5404 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5405 type
= BYTE_GET (imfs
[i
].type
);
5406 rtype
= elf_ia64_reloc_type (type
);
5408 printf (" 0x%08x ", type
);
5410 printf (" %-32s ", rtype
);
5411 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5412 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5418 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5421 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5423 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5426 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5427 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5428 _("dynamic section image relocations"));
5432 printf (_("\nImage relocs\n"));
5434 (_("Seg Offset Type Addend Seg Sym Off\n"));
5436 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5441 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5442 printf ("%08" BFD_VMA_FMT
"x ",
5443 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5444 type
= BYTE_GET (imrs
[i
].type
);
5445 rtype
= elf_ia64_reloc_type (type
);
5447 printf ("0x%08x ", type
);
5449 printf ("%-31s ", rtype
);
5450 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5451 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5452 printf ("%08" BFD_VMA_FMT
"x\n",
5453 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5459 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5462 process_ia64_vms_dynamic_relocs (FILE *file
)
5464 struct ia64_vms_dynfixup fixup
;
5465 struct ia64_vms_dynimgrela imgrela
;
5466 Elf_Internal_Dyn
*entry
;
5468 bfd_vma strtab_off
= 0;
5469 bfd_vma strtab_sz
= 0;
5470 char *strtab
= NULL
;
5472 memset (&fixup
, 0, sizeof (fixup
));
5473 memset (&imgrela
, 0, sizeof (imgrela
));
5475 /* Note: the order of the entries is specified by the OpenVMS specs. */
5476 for (entry
= dynamic_section
;
5477 entry
< dynamic_section
+ dynamic_nent
;
5480 switch (entry
->d_tag
)
5482 case DT_IA_64_VMS_STRTAB_OFFSET
:
5483 strtab_off
= entry
->d_un
.d_val
;
5486 strtab_sz
= entry
->d_un
.d_val
;
5488 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5489 1, strtab_sz
, _("dynamic string section"));
5492 case DT_IA_64_VMS_NEEDED_IDENT
:
5493 fixup
.needed_ident
= entry
->d_un
.d_val
;
5496 fixup
.needed
= entry
->d_un
.d_val
;
5498 case DT_IA_64_VMS_FIXUP_NEEDED
:
5499 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5501 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5502 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5504 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5505 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5507 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5510 case DT_IA_64_VMS_IMG_RELA_CNT
:
5511 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5513 case DT_IA_64_VMS_IMG_RELA_OFF
:
5514 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5516 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5536 } dynamic_relocations
[] =
5538 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5539 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5540 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5543 /* Process the reloc section. */
5546 process_relocs (FILE * file
)
5548 unsigned long rel_size
;
5549 unsigned long rel_offset
;
5555 if (do_using_dynamic
)
5559 int has_dynamic_reloc
;
5562 has_dynamic_reloc
= 0;
5564 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5566 is_rela
= dynamic_relocations
[i
].rela
;
5567 name
= dynamic_relocations
[i
].name
;
5568 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5569 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5571 has_dynamic_reloc
|= rel_size
;
5573 if (is_rela
== UNKNOWN
)
5575 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5576 switch (dynamic_info
[DT_PLTREL
])
5590 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5591 name
, rel_offset
, rel_size
);
5593 dump_relocations (file
,
5594 offset_from_vma (file
, rel_offset
, rel_size
),
5596 dynamic_symbols
, num_dynamic_syms
,
5597 dynamic_strings
, dynamic_strings_length
, is_rela
);
5602 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5604 if (! has_dynamic_reloc
)
5605 printf (_("\nThere are no dynamic relocations in this file.\n"));
5609 Elf_Internal_Shdr
* section
;
5613 for (i
= 0, section
= section_headers
;
5614 i
< elf_header
.e_shnum
;
5617 if ( section
->sh_type
!= SHT_RELA
5618 && section
->sh_type
!= SHT_REL
)
5621 rel_offset
= section
->sh_offset
;
5622 rel_size
= section
->sh_size
;
5626 Elf_Internal_Shdr
* strsec
;
5629 printf (_("\nRelocation section "));
5631 if (string_table
== NULL
)
5632 printf ("%d", section
->sh_name
);
5634 printf ("'%s'", SECTION_NAME (section
));
5636 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5637 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5639 is_rela
= section
->sh_type
== SHT_RELA
;
5641 if (section
->sh_link
!= 0
5642 && section
->sh_link
< elf_header
.e_shnum
)
5644 Elf_Internal_Shdr
* symsec
;
5645 Elf_Internal_Sym
* symtab
;
5646 unsigned long nsyms
;
5647 unsigned long strtablen
= 0;
5648 char * strtab
= NULL
;
5650 symsec
= section_headers
+ section
->sh_link
;
5651 if (symsec
->sh_type
!= SHT_SYMTAB
5652 && symsec
->sh_type
!= SHT_DYNSYM
)
5655 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
5660 if (symsec
->sh_link
!= 0
5661 && symsec
->sh_link
< elf_header
.e_shnum
)
5663 strsec
= section_headers
+ symsec
->sh_link
;
5665 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5668 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5671 dump_relocations (file
, rel_offset
, rel_size
,
5672 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5678 dump_relocations (file
, rel_offset
, rel_size
,
5679 NULL
, 0, NULL
, 0, is_rela
);
5686 printf (_("\nThere are no relocations in this file.\n"));
5692 /* Process the unwind section. */
5694 #include "unwind-ia64.h"
5696 /* An absolute address consists of a section and an offset. If the
5697 section is NULL, the offset itself is the address, otherwise, the
5698 address equals to LOAD_ADDRESS(section) + offset. */
5702 unsigned short section
;
5706 #define ABSADDR(a) \
5708 ? section_headers [(a).section].sh_addr + (a).offset \
5711 struct ia64_unw_table_entry
5713 struct absaddr start
;
5715 struct absaddr info
;
5718 struct ia64_unw_aux_info
5721 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5722 unsigned long table_len
; /* Length of unwind table. */
5723 unsigned char * info
; /* Unwind info. */
5724 unsigned long info_size
; /* Size of unwind info. */
5725 bfd_vma info_addr
; /* starting address of unwind info. */
5726 bfd_vma seg_base
; /* Starting address of segment. */
5727 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5728 unsigned long nsyms
; /* Number of symbols. */
5729 char * strtab
; /* The string table. */
5730 unsigned long strtab_size
; /* Size of string table. */
5734 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5735 unsigned long nsyms
,
5736 const char * strtab
,
5737 unsigned long strtab_size
,
5738 struct absaddr addr
,
5739 const char ** symname
,
5742 bfd_vma dist
= 0x100000;
5743 Elf_Internal_Sym
* sym
;
5744 Elf_Internal_Sym
* best
= NULL
;
5747 REMOVE_ARCH_BITS (addr
.offset
);
5749 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5751 bfd_vma value
= sym
->st_value
;
5753 REMOVE_ARCH_BITS (value
);
5755 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5756 && sym
->st_name
!= 0
5757 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5758 && addr
.offset
>= value
5759 && addr
.offset
- value
< dist
)
5762 dist
= addr
.offset
- value
;
5770 *symname
= (best
->st_name
>= strtab_size
5771 ? _("<corrupt>") : strtab
+ best
->st_name
);
5777 *offset
= addr
.offset
;
5781 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5783 struct ia64_unw_table_entry
* tp
;
5786 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5790 const unsigned char * dp
;
5791 const unsigned char * head
;
5792 const char * procname
;
5794 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5795 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5797 fputs ("\n<", stdout
);
5801 fputs (procname
, stdout
);
5804 printf ("+%lx", (unsigned long) offset
);
5807 fputs (">: [", stdout
);
5808 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5809 fputc ('-', stdout
);
5810 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5811 printf ("], info at +0x%lx\n",
5812 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5814 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5815 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5817 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5818 (unsigned) UNW_VER (stamp
),
5819 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5820 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5821 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5822 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5824 if (UNW_VER (stamp
) != 1)
5826 printf (_("\tUnknown version.\n"));
5831 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5832 dp
= unw_decode (dp
, in_body
, & in_body
);
5837 slurp_ia64_unwind_table (FILE * file
,
5838 struct ia64_unw_aux_info
* aux
,
5839 Elf_Internal_Shdr
* sec
)
5841 unsigned long size
, nrelas
, i
;
5842 Elf_Internal_Phdr
* seg
;
5843 struct ia64_unw_table_entry
* tep
;
5844 Elf_Internal_Shdr
* relsec
;
5845 Elf_Internal_Rela
* rela
;
5846 Elf_Internal_Rela
* rp
;
5847 unsigned char * table
;
5849 Elf_Internal_Sym
* sym
;
5850 const char * relname
;
5852 /* First, find the starting address of the segment that includes
5855 if (elf_header
.e_phnum
)
5857 if (! get_program_headers (file
))
5860 for (seg
= program_headers
;
5861 seg
< program_headers
+ elf_header
.e_phnum
;
5864 if (seg
->p_type
!= PT_LOAD
)
5867 if (sec
->sh_addr
>= seg
->p_vaddr
5868 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5870 aux
->seg_base
= seg
->p_vaddr
;
5876 /* Second, build the unwind table from the contents of the unwind section: */
5877 size
= sec
->sh_size
;
5878 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5883 aux
->table
= (struct ia64_unw_table_entry
*)
5884 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5886 for (tp
= table
; tp
< table
+ size
; ++tep
)
5888 tep
->start
.section
= SHN_UNDEF
;
5889 tep
->end
.section
= SHN_UNDEF
;
5890 tep
->info
.section
= SHN_UNDEF
;
5891 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5892 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5893 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5894 tep
->start
.offset
+= aux
->seg_base
;
5895 tep
->end
.offset
+= aux
->seg_base
;
5896 tep
->info
.offset
+= aux
->seg_base
;
5900 /* Third, apply any relocations to the unwind table: */
5901 for (relsec
= section_headers
;
5902 relsec
< section_headers
+ elf_header
.e_shnum
;
5905 if (relsec
->sh_type
!= SHT_RELA
5906 || relsec
->sh_info
>= elf_header
.e_shnum
5907 || section_headers
+ relsec
->sh_info
!= sec
)
5910 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5914 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5916 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5917 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5919 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5921 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5925 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5927 switch (rp
->r_offset
/eh_addr_size
% 3)
5930 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5931 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5934 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5935 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5938 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5939 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5949 aux
->table_len
= size
/ (3 * eh_addr_size
);
5954 ia64_process_unwind (FILE * file
)
5956 Elf_Internal_Shdr
* sec
;
5957 Elf_Internal_Shdr
* unwsec
= NULL
;
5958 Elf_Internal_Shdr
* strsec
;
5959 unsigned long i
, unwcount
= 0, unwstart
= 0;
5960 struct ia64_unw_aux_info aux
;
5962 memset (& aux
, 0, sizeof (aux
));
5964 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5966 if (sec
->sh_type
== SHT_SYMTAB
5967 && sec
->sh_link
< elf_header
.e_shnum
)
5969 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
5971 strsec
= section_headers
+ sec
->sh_link
;
5972 assert (aux
.strtab
== NULL
);
5973 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5976 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5978 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5983 printf (_("\nThere are no unwind sections in this file.\n"));
5985 while (unwcount
-- > 0)
5990 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5991 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5992 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5999 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
6001 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
6003 /* We need to find which section group it is in. */
6004 struct group_list
* g
= section_headers_groups
[i
]->root
;
6006 for (; g
!= NULL
; g
= g
->next
)
6008 sec
= section_headers
+ g
->section_index
;
6010 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
6015 i
= elf_header
.e_shnum
;
6017 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
6019 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6020 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
6021 suffix
= SECTION_NAME (unwsec
) + len
;
6022 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6024 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
6025 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6030 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6031 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6032 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
6033 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
6035 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
6036 suffix
= SECTION_NAME (unwsec
) + len
;
6037 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
6039 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
6040 && streq (SECTION_NAME (sec
) + len2
, suffix
))
6044 if (i
== elf_header
.e_shnum
)
6046 printf (_("\nCould not find unwind info section for "));
6048 if (string_table
== NULL
)
6049 printf ("%d", unwsec
->sh_name
);
6051 printf (_("'%s'"), SECTION_NAME (unwsec
));
6055 aux
.info_addr
= sec
->sh_addr
;
6056 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
6059 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
6061 printf (_("\nUnwind section "));
6063 if (string_table
== NULL
)
6064 printf ("%d", unwsec
->sh_name
);
6066 printf (_("'%s'"), SECTION_NAME (unwsec
));
6068 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6069 (unsigned long) unwsec
->sh_offset
,
6070 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
6072 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
6074 if (aux
.table_len
> 0)
6075 dump_ia64_unwind (& aux
);
6078 free ((char *) aux
.table
);
6080 free ((char *) aux
.info
);
6089 free ((char *) aux
.strtab
);
6092 struct hppa_unw_table_entry
6094 struct absaddr start
;
6096 unsigned int Cannot_unwind
:1; /* 0 */
6097 unsigned int Millicode
:1; /* 1 */
6098 unsigned int Millicode_save_sr0
:1; /* 2 */
6099 unsigned int Region_description
:2; /* 3..4 */
6100 unsigned int reserved1
:1; /* 5 */
6101 unsigned int Entry_SR
:1; /* 6 */
6102 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
6103 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
6104 unsigned int Args_stored
:1; /* 16 */
6105 unsigned int Variable_Frame
:1; /* 17 */
6106 unsigned int Separate_Package_Body
:1; /* 18 */
6107 unsigned int Frame_Extension_Millicode
:1; /* 19 */
6108 unsigned int Stack_Overflow_Check
:1; /* 20 */
6109 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
6110 unsigned int Ada_Region
:1; /* 22 */
6111 unsigned int cxx_info
:1; /* 23 */
6112 unsigned int cxx_try_catch
:1; /* 24 */
6113 unsigned int sched_entry_seq
:1; /* 25 */
6114 unsigned int reserved2
:1; /* 26 */
6115 unsigned int Save_SP
:1; /* 27 */
6116 unsigned int Save_RP
:1; /* 28 */
6117 unsigned int Save_MRP_in_frame
:1; /* 29 */
6118 unsigned int extn_ptr_defined
:1; /* 30 */
6119 unsigned int Cleanup_defined
:1; /* 31 */
6121 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
6122 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
6123 unsigned int Large_frame
:1; /* 2 */
6124 unsigned int Pseudo_SP_Set
:1; /* 3 */
6125 unsigned int reserved4
:1; /* 4 */
6126 unsigned int Total_frame_size
:27; /* 5..31 */
6129 struct hppa_unw_aux_info
6131 struct hppa_unw_table_entry
*table
; /* Unwind table. */
6132 unsigned long table_len
; /* Length of unwind table. */
6133 bfd_vma seg_base
; /* Starting address of segment. */
6134 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6135 unsigned long nsyms
; /* Number of symbols. */
6136 char * strtab
; /* The string table. */
6137 unsigned long strtab_size
; /* Size of string table. */
6141 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
6143 struct hppa_unw_table_entry
* tp
;
6145 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6148 const char * procname
;
6150 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6151 aux
->strtab_size
, tp
->start
, &procname
,
6154 fputs ("\n<", stdout
);
6158 fputs (procname
, stdout
);
6161 printf ("+%lx", (unsigned long) offset
);
6164 fputs (">: [", stdout
);
6165 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6166 fputc ('-', stdout
);
6167 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6170 #define PF(_m) if (tp->_m) printf (#_m " ");
6171 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6174 PF(Millicode_save_sr0
);
6175 /* PV(Region_description); */
6181 PF(Separate_Package_Body
);
6182 PF(Frame_Extension_Millicode
);
6183 PF(Stack_Overflow_Check
);
6184 PF(Two_Instruction_SP_Increment
);
6188 PF(sched_entry_seq
);
6191 PF(Save_MRP_in_frame
);
6192 PF(extn_ptr_defined
);
6193 PF(Cleanup_defined
);
6194 PF(MPE_XL_interrupt_marker
);
6195 PF(HP_UX_interrupt_marker
);
6198 PV(Total_frame_size
);
6207 slurp_hppa_unwind_table (FILE * file
,
6208 struct hppa_unw_aux_info
* aux
,
6209 Elf_Internal_Shdr
* sec
)
6211 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
6212 Elf_Internal_Phdr
* seg
;
6213 struct hppa_unw_table_entry
* tep
;
6214 Elf_Internal_Shdr
* relsec
;
6215 Elf_Internal_Rela
* rela
;
6216 Elf_Internal_Rela
* rp
;
6217 unsigned char * table
;
6219 Elf_Internal_Sym
* sym
;
6220 const char * relname
;
6222 /* First, find the starting address of the segment that includes
6225 if (elf_header
.e_phnum
)
6227 if (! get_program_headers (file
))
6230 for (seg
= program_headers
;
6231 seg
< program_headers
+ elf_header
.e_phnum
;
6234 if (seg
->p_type
!= PT_LOAD
)
6237 if (sec
->sh_addr
>= seg
->p_vaddr
6238 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6240 aux
->seg_base
= seg
->p_vaddr
;
6246 /* Second, build the unwind table from the contents of the unwind
6248 size
= sec
->sh_size
;
6249 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6255 nentries
= size
/ unw_ent_size
;
6256 size
= unw_ent_size
* nentries
;
6258 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
6259 xcmalloc (nentries
, sizeof (aux
->table
[0]));
6261 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
6263 unsigned int tmp1
, tmp2
;
6265 tep
->start
.section
= SHN_UNDEF
;
6266 tep
->end
.section
= SHN_UNDEF
;
6268 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
6269 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
6270 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
6271 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
6273 tep
->start
.offset
+= aux
->seg_base
;
6274 tep
->end
.offset
+= aux
->seg_base
;
6276 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6277 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6278 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6279 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6280 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6281 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6282 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6283 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6284 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6285 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6286 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6287 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6288 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6289 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6290 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6291 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6292 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6293 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6294 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6295 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6296 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6297 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6298 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6299 tep
->Cleanup_defined
= tmp1
& 0x1;
6301 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6302 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6303 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6304 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6305 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6306 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6310 /* Third, apply any relocations to the unwind table. */
6311 for (relsec
= section_headers
;
6312 relsec
< section_headers
+ elf_header
.e_shnum
;
6315 if (relsec
->sh_type
!= SHT_RELA
6316 || relsec
->sh_info
>= elf_header
.e_shnum
6317 || section_headers
+ relsec
->sh_info
!= sec
)
6320 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6324 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6326 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6327 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6329 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6330 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6332 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6336 i
= rp
->r_offset
/ unw_ent_size
;
6338 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6341 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6342 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6345 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6346 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6356 aux
->table_len
= nentries
;
6362 hppa_process_unwind (FILE * file
)
6364 struct hppa_unw_aux_info aux
;
6365 Elf_Internal_Shdr
* unwsec
= NULL
;
6366 Elf_Internal_Shdr
* strsec
;
6367 Elf_Internal_Shdr
* sec
;
6370 if (string_table
== NULL
)
6373 memset (& aux
, 0, sizeof (aux
));
6375 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6377 if (sec
->sh_type
== SHT_SYMTAB
6378 && sec
->sh_link
< elf_header
.e_shnum
)
6380 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6382 strsec
= section_headers
+ sec
->sh_link
;
6383 assert (aux
.strtab
== NULL
);
6384 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6387 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6389 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6394 printf (_("\nThere are no unwind sections in this file.\n"));
6396 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6398 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6400 printf (_("\nUnwind section "));
6401 printf (_("'%s'"), SECTION_NAME (sec
));
6403 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6404 (unsigned long) sec
->sh_offset
,
6405 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6407 slurp_hppa_unwind_table (file
, &aux
, sec
);
6408 if (aux
.table_len
> 0)
6409 dump_hppa_unwind (&aux
);
6412 free ((char *) aux
.table
);
6420 free ((char *) aux
.strtab
);
6425 unsigned char * data
; /* The unwind data. */
6426 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
6427 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
6428 unsigned long nrelas
; /* The number of relocations. */
6429 unsigned int rel_type
; /* REL or RELA ? */
6430 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
6433 struct arm_unw_aux_info
6435 FILE * file
; /* The file containing the unwind sections. */
6436 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
6437 unsigned long nsyms
; /* Number of symbols. */
6438 char * strtab
; /* The file's string table. */
6439 unsigned long strtab_size
; /* Size of string table. */
6443 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6444 bfd_vma fn
, struct absaddr addr
)
6446 const char *procname
;
6449 if (addr
.section
== SHN_UNDEF
)
6452 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6453 aux
->strtab_size
, addr
, &procname
,
6456 print_vma (fn
, PREFIX_HEX
);
6460 fputs (" <", stdout
);
6461 fputs (procname
, stdout
);
6464 printf ("+0x%lx", (unsigned long) sym_offset
);
6465 fputc ('>', stdout
);
6472 arm_free_section (struct arm_section
*arm_sec
)
6474 if (arm_sec
->data
!= NULL
)
6475 free (arm_sec
->data
);
6477 if (arm_sec
->rela
!= NULL
)
6478 free (arm_sec
->rela
);
6481 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6482 cached section and install SEC instead.
6483 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6484 and return its valued in * WORDP, relocating if necessary.
6485 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6486 relocation's offset in ADDR.
6487 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6488 into the string table of the symbol associated with the reloc. If no
6489 reloc was applied store -1 there.
6490 5) Return TRUE upon success, FALSE otherwise. */
6493 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
6494 struct arm_section
* arm_sec
,
6495 Elf_Internal_Shdr
* sec
,
6496 bfd_vma word_offset
,
6497 unsigned int * wordp
,
6498 struct absaddr
* addr
,
6501 Elf_Internal_Rela
*rp
;
6502 Elf_Internal_Sym
*sym
;
6503 const char * relname
;
6505 bfd_boolean wrapped
;
6507 addr
->section
= SHN_UNDEF
;
6510 if (sym_name
!= NULL
)
6511 *sym_name
= (bfd_vma
) -1;
6513 /* If necessary, update the section cache. */
6514 if (sec
!= arm_sec
->sec
)
6516 Elf_Internal_Shdr
*relsec
;
6518 arm_free_section (arm_sec
);
6521 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6522 sec
->sh_size
, _("unwind data"));
6523 arm_sec
->rela
= NULL
;
6524 arm_sec
->nrelas
= 0;
6526 for (relsec
= section_headers
;
6527 relsec
< section_headers
+ elf_header
.e_shnum
;
6530 if (relsec
->sh_info
>= elf_header
.e_shnum
6531 || section_headers
+ relsec
->sh_info
!= sec
)
6534 arm_sec
->rel_type
= relsec
->sh_type
;
6535 if (relsec
->sh_type
== SHT_REL
)
6537 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6539 & arm_sec
->rela
, & arm_sec
->nrelas
))
6543 else if (relsec
->sh_type
== SHT_RELA
)
6545 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6547 & arm_sec
->rela
, & arm_sec
->nrelas
))
6552 warn (_("unexpected relocation type (%d) for section %d"),
6553 relsec
->sh_type
, relsec
->sh_info
);
6556 arm_sec
->next_rela
= arm_sec
->rela
;
6559 /* If there is no unwind data we can do nothing. */
6560 if (arm_sec
->data
== NULL
)
6563 /* Get the word at the required offset. */
6564 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6566 /* Look through the relocs to find the one that applies to the provided offset. */
6568 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6570 bfd_vma prelval
, offset
;
6572 if (rp
->r_offset
> word_offset
&& !wrapped
)
6577 if (rp
->r_offset
> word_offset
)
6580 if (rp
->r_offset
& 3)
6582 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6583 (unsigned long) rp
->r_offset
);
6587 if (rp
->r_offset
< word_offset
)
6590 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6592 if (arm_sec
->rel_type
== SHT_REL
)
6594 offset
= word
& 0x7fffffff;
6595 if (offset
& 0x40000000)
6596 offset
|= ~ (bfd_vma
) 0x7fffffff;
6598 else if (arm_sec
->rel_type
== SHT_RELA
)
6599 offset
= rp
->r_addend
;
6603 offset
+= sym
->st_value
;
6604 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6606 /* Check that we are processing the expected reloc type. */
6607 if (elf_header
.e_machine
== EM_ARM
)
6609 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6611 if (streq (relname
, "R_ARM_NONE"))
6614 if (! streq (relname
, "R_ARM_PREL31"))
6616 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6620 else if (elf_header
.e_machine
== EM_TI_C6000
)
6622 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6624 if (streq (relname
, "R_C6000_NONE"))
6627 if (! streq (relname
, "R_C6000_PREL31"))
6629 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6636 /* This function currently only supports ARM and TI unwinders. */
6639 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6640 addr
->section
= sym
->st_shndx
;
6641 addr
->offset
= offset
;
6643 * sym_name
= sym
->st_name
;
6648 arm_sec
->next_rela
= rp
;
6653 static const char *tic6x_unwind_regnames
[16] =
6655 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6656 "A14", "A13", "A12", "A11", "A10",
6657 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6661 decode_tic6x_unwind_regmask (unsigned int mask
)
6665 for (i
= 12; mask
; mask
>>= 1, i
--)
6669 fputs (tic6x_unwind_regnames
[i
], stdout
);
6671 fputs (", ", stdout
);
6677 if (remaining == 0 && more_words) \
6680 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6681 data_offset, & word, & addr, NULL)) \
6687 #define GET_OP(OP) \
6692 (OP) = word >> 24; \
6697 printf (_("[Truncated opcode]\n")); \
6700 printf ("0x%02x ", OP)
6703 decode_arm_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6704 unsigned int word
, unsigned int remaining
,
6705 unsigned int more_words
,
6706 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6707 struct arm_section
*data_arm_sec
)
6709 struct absaddr addr
;
6711 /* Decode the unwinding instructions. */
6714 unsigned int op
, op2
;
6723 printf (" 0x%02x ", op
);
6725 if ((op
& 0xc0) == 0x00)
6727 int offset
= ((op
& 0x3f) << 2) + 4;
6729 printf (" vsp = vsp + %d", offset
);
6731 else if ((op
& 0xc0) == 0x40)
6733 int offset
= ((op
& 0x3f) << 2) + 4;
6735 printf (" vsp = vsp - %d", offset
);
6737 else if ((op
& 0xf0) == 0x80)
6740 if (op
== 0x80 && op2
== 0)
6741 printf (_("Refuse to unwind"));
6744 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6749 for (i
= 0; i
< 12; i
++)
6750 if (mask
& (1 << i
))
6756 printf ("r%d", 4 + i
);
6761 else if ((op
& 0xf0) == 0x90)
6763 if (op
== 0x9d || op
== 0x9f)
6764 printf (_(" [Reserved]"));
6766 printf (" vsp = r%d", op
& 0x0f);
6768 else if ((op
& 0xf0) == 0xa0)
6770 int end
= 4 + (op
& 0x07);
6775 for (i
= 4; i
<= end
; i
++)
6791 else if (op
== 0xb0)
6792 printf (_(" finish"));
6793 else if (op
== 0xb1)
6796 if (op2
== 0 || (op2
& 0xf0) != 0)
6797 printf (_("[Spare]"));
6800 unsigned int mask
= op2
& 0x0f;
6805 for (i
= 0; i
< 12; i
++)
6806 if (mask
& (1 << i
))
6817 else if (op
== 0xb2)
6819 unsigned char buf
[9];
6820 unsigned int i
, len
;
6821 unsigned long offset
;
6823 for (i
= 0; i
< sizeof (buf
); i
++)
6826 if ((buf
[i
] & 0x80) == 0)
6829 assert (i
< sizeof (buf
));
6830 offset
= read_uleb128 (buf
, &len
);
6831 assert (len
== i
+ 1);
6832 offset
= offset
* 4 + 0x204;
6833 printf ("vsp = vsp + %ld", offset
);
6835 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
6837 unsigned int first
, last
;
6844 printf ("pop {D%d", first
);
6846 printf ("-D%d", first
+ last
);
6849 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
6851 unsigned int count
= op
& 0x07;
6855 printf ("-D%d", 8 + count
);
6858 else if (op
>= 0xc0 && op
<= 0xc5)
6860 unsigned int count
= op
& 0x07;
6862 printf (" pop {wR10");
6864 printf ("-wR%d", 10 + count
);
6867 else if (op
== 0xc6)
6869 unsigned int first
, last
;
6874 printf ("pop {wR%d", first
);
6876 printf ("-wR%d", first
+ last
);
6879 else if (op
== 0xc7)
6882 if (op2
== 0 || (op2
& 0xf0) != 0)
6883 printf (_("[Spare]"));
6886 unsigned int mask
= op2
& 0x0f;
6891 for (i
= 0; i
< 4; i
++)
6892 if (mask
& (1 << i
))
6898 printf ("wCGR%d", i
);
6904 printf (_(" [unsupported opcode]"));
6910 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
*aux
,
6911 unsigned int word
, unsigned int remaining
,
6912 unsigned int more_words
,
6913 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6914 struct arm_section
*data_arm_sec
)
6916 struct absaddr addr
;
6918 /* Decode the unwinding instructions. */
6921 unsigned int op
, op2
;
6930 printf (" 0x%02x ", op
);
6932 if ((op
& 0xc0) == 0x00)
6934 int offset
= ((op
& 0x3f) << 3) + 8;
6935 printf (" sp = sp + %d", offset
);
6937 else if ((op
& 0xc0) == 0x80)
6940 if (op
== 0x80 && op2
== 0)
6941 printf (_("Refuse to unwind"));
6944 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
6946 printf ("pop compact {");
6950 decode_tic6x_unwind_regmask (mask
);
6954 else if ((op
& 0xf0) == 0xc0)
6962 unsigned int offset
;
6966 /* Scan entire instruction first so that GET_OP output is not
6967 interleaved with disassembly. */
6969 for (i
= 0; nregs
< (op
& 0xf); i
++)
6975 regpos
[nregs
].offset
= i
* 2;
6976 regpos
[nregs
].reg
= reg
;
6983 regpos
[nregs
].offset
= i
* 2 + 1;
6984 regpos
[nregs
].reg
= reg
;
6989 printf (_("pop frame {"));
6991 for (i
= i
* 2; i
> 0; i
--)
6993 if (regpos
[reg
].offset
== i
- 1)
6995 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
7002 fputs (name
, stdout
);
7009 else if (op
== 0xd0)
7010 printf (" MOV FP, SP");
7011 else if (op
== 0xd1)
7012 printf (" __c6xabi_pop_rts");
7013 else if (op
== 0xd2)
7015 unsigned char buf
[9];
7016 unsigned int i
, len
;
7017 unsigned long offset
;
7019 for (i
= 0; i
< sizeof (buf
); i
++)
7022 if ((buf
[i
] & 0x80) == 0)
7025 assert (i
< sizeof (buf
));
7026 offset
= read_uleb128 (buf
, &len
);
7027 assert (len
== i
+ 1);
7028 offset
= offset
* 8 + 0x408;
7029 printf (_("sp = sp + %ld"), offset
);
7031 else if ((op
& 0xf0) == 0xe0)
7033 if ((op
& 0x0f) == 7)
7036 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
7040 printf (_(" [unsupported opcode]"));
7047 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
7051 offset
= word
& 0x7fffffff;
7052 if (offset
& 0x40000000)
7053 offset
|= ~ (bfd_vma
) 0x7fffffff;
7055 if (elf_header
.e_machine
== EM_TI_C6000
)
7058 return offset
+ where
;
7062 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
7064 unsigned int remaining
,
7065 bfd_vma data_offset
,
7066 Elf_Internal_Shdr
* data_sec
,
7067 struct arm_section
* data_arm_sec
)
7070 unsigned int more_words
= 0;
7071 struct absaddr addr
;
7072 bfd_vma sym_name
= (bfd_vma
) -1;
7076 /* Fetch the first word.
7077 Note - when decoding an object file the address extracted
7078 here will always be 0. So we also pass in the sym_name
7079 parameter so that we can find the symbol associated with
7080 the personality routine. */
7081 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
7082 & word
, & addr
, & sym_name
))
7088 if ((word
& 0x80000000) == 0)
7090 /* Expand prel31 for personality routine. */
7092 const char *procname
;
7094 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
7095 printf (_(" Personality routine: "));
7097 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
7098 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
7100 procname
= aux
->strtab
+ sym_name
;
7101 print_vma (fn
, PREFIX_HEX
);
7104 fputs (" <", stdout
);
7105 fputs (procname
, stdout
);
7106 fputc ('>', stdout
);
7110 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
7111 fputc ('\n', stdout
);
7113 /* The GCC personality routines use the standard compact
7114 encoding, starting with one byte giving the number of
7116 if (procname
!= NULL
7117 && (const_strneq (procname
, "__gcc_personality_v0")
7118 || const_strneq (procname
, "__gxx_personality_v0")
7119 || const_strneq (procname
, "__gcj_personality_v0")
7120 || const_strneq (procname
, "__gnu_objc_personality_v0")))
7127 printf (_(" [Truncated data]\n"));
7130 more_words
= word
>> 24;
7140 /* ARM EHABI Section 6.3:
7142 An exception-handling table entry for the compact model looks like:
7146 1 0 index Data for personalityRoutine[index] */
7148 if (elf_header
.e_machine
== EM_ARM
7149 && (word
& 0x70000000))
7150 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
7152 per_index
= (word
>> 24) & 0x7f;
7153 printf (_(" Compact model index: %d\n"), per_index
);
7160 else if (per_index
< 3)
7162 more_words
= (word
>> 16) & 0xff;
7168 switch (elf_header
.e_machine
)
7173 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
7174 data_offset
, data_sec
, data_arm_sec
);
7178 warn (_("Unknown ARM compact model index encountered\n"));
7179 printf (_(" [reserved]\n"));
7186 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
7187 data_offset
, data_sec
, data_arm_sec
);
7189 else if (per_index
< 5)
7191 if (((word
>> 17) & 0x7f) == 0x7f)
7192 printf (_(" Restore stack from frame pointer\n"));
7194 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
7195 printf (_(" Registers restored: "));
7197 printf (" (compact) ");
7198 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
7200 printf (_(" Return register: %s\n"),
7201 tic6x_unwind_regnames
[word
& 0xf]);
7204 printf (_(" [reserved (%d)]\n"), per_index
);
7208 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7209 elf_header
.e_machine
);
7212 /* Decode the descriptors. Not implemented. */
7216 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
7218 struct arm_section exidx_arm_sec
, extab_arm_sec
;
7219 unsigned int i
, exidx_len
;
7221 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
7222 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
7223 exidx_len
= exidx_sec
->sh_size
/ 8;
7225 for (i
= 0; i
< exidx_len
; i
++)
7227 unsigned int exidx_fn
, exidx_entry
;
7228 struct absaddr fn_addr
, entry_addr
;
7231 fputc ('\n', stdout
);
7233 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7234 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
7235 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
7236 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
7238 arm_free_section (& exidx_arm_sec
);
7239 arm_free_section (& extab_arm_sec
);
7243 /* ARM EHABI, Section 5:
7244 An index table entry consists of 2 words.
7245 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7246 if (exidx_fn
& 0x80000000)
7247 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
7249 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
7251 arm_print_vma_and_name (aux
, fn
, fn_addr
);
7252 fputs (": ", stdout
);
7254 if (exidx_entry
== 1)
7256 print_vma (exidx_entry
, PREFIX_HEX
);
7257 fputs (" [cantunwind]\n", stdout
);
7259 else if (exidx_entry
& 0x80000000)
7261 print_vma (exidx_entry
, PREFIX_HEX
);
7262 fputc ('\n', stdout
);
7263 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
7267 bfd_vma table
, table_offset
= 0;
7268 Elf_Internal_Shdr
*table_sec
;
7270 fputs ("@", stdout
);
7271 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
7272 print_vma (table
, PREFIX_HEX
);
7275 /* Locate the matching .ARM.extab. */
7276 if (entry_addr
.section
!= SHN_UNDEF
7277 && entry_addr
.section
< elf_header
.e_shnum
)
7279 table_sec
= section_headers
+ entry_addr
.section
;
7280 table_offset
= entry_addr
.offset
;
7284 table_sec
= find_section_by_address (table
);
7285 if (table_sec
!= NULL
)
7286 table_offset
= table
- table_sec
->sh_addr
;
7288 if (table_sec
== NULL
)
7290 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7291 (unsigned long) table
);
7294 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
7301 arm_free_section (&exidx_arm_sec
);
7302 arm_free_section (&extab_arm_sec
);
7305 /* Used for both ARM and C6X unwinding tables. */
7308 arm_process_unwind (FILE *file
)
7310 struct arm_unw_aux_info aux
;
7311 Elf_Internal_Shdr
*unwsec
= NULL
;
7312 Elf_Internal_Shdr
*strsec
;
7313 Elf_Internal_Shdr
*sec
;
7315 unsigned int sec_type
;
7317 switch (elf_header
.e_machine
)
7320 sec_type
= SHT_ARM_EXIDX
;
7324 sec_type
= SHT_C6000_UNWIND
;
7328 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7329 elf_header
.e_machine
);
7333 if (string_table
== NULL
)
7336 memset (& aux
, 0, sizeof (aux
));
7339 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7341 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
7343 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7345 strsec
= section_headers
+ sec
->sh_link
;
7346 assert (aux
.strtab
== NULL
);
7347 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
7348 1, strsec
->sh_size
, _("string table"));
7349 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7351 else if (sec
->sh_type
== sec_type
)
7356 printf (_("\nThere are no unwind sections in this file.\n"));
7358 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7360 if (sec
->sh_type
== sec_type
)
7362 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7364 (unsigned long) sec
->sh_offset
,
7365 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
7367 dump_arm_unwind (&aux
, sec
);
7374 free ((char *) aux
.strtab
);
7378 process_unwind (FILE * file
)
7380 struct unwind_handler
7383 void (* handler
)(FILE *);
7386 { EM_ARM
, arm_process_unwind
},
7387 { EM_IA_64
, ia64_process_unwind
},
7388 { EM_PARISC
, hppa_process_unwind
},
7389 { EM_TI_C6000
, arm_process_unwind
},
7397 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
7398 if (elf_header
.e_machine
== handlers
[i
].machtype
)
7399 return handlers
[i
].handler (file
);
7401 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7402 get_machine_name (elf_header
.e_machine
));
7406 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
7408 switch (entry
->d_tag
)
7411 if (entry
->d_un
.d_val
== 0)
7415 static const char * opts
[] =
7417 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7418 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7419 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7420 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7426 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
7427 if (entry
->d_un
.d_val
& (1 << cnt
))
7429 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
7435 case DT_MIPS_IVERSION
:
7436 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7437 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7439 printf (_("<corrupt: %" BFD_VMA_FMT
"d>"), entry
->d_un
.d_ptr
);
7442 case DT_MIPS_TIME_STAMP
:
7447 time_t atime
= entry
->d_un
.d_val
;
7448 tmp
= gmtime (&atime
);
7449 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
7450 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7451 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7452 printf (_("Time Stamp: %s"), timebuf
);
7456 case DT_MIPS_RLD_VERSION
:
7457 case DT_MIPS_LOCAL_GOTNO
:
7458 case DT_MIPS_CONFLICTNO
:
7459 case DT_MIPS_LIBLISTNO
:
7460 case DT_MIPS_SYMTABNO
:
7461 case DT_MIPS_UNREFEXTNO
:
7462 case DT_MIPS_HIPAGENO
:
7463 case DT_MIPS_DELTA_CLASS_NO
:
7464 case DT_MIPS_DELTA_INSTANCE_NO
:
7465 case DT_MIPS_DELTA_RELOC_NO
:
7466 case DT_MIPS_DELTA_SYM_NO
:
7467 case DT_MIPS_DELTA_CLASSSYM_NO
:
7468 case DT_MIPS_COMPACT_SIZE
:
7469 print_vma (entry
->d_un
.d_ptr
, DEC
);
7473 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7479 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
7481 switch (entry
->d_tag
)
7483 case DT_HP_DLD_FLAGS
:
7492 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
7493 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
7494 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
7495 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
7496 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
7497 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
7498 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
7499 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
7500 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
7501 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
7502 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
7503 { DT_HP_GST
, "HP_GST" },
7504 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
7505 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
7506 { DT_HP_NODELETE
, "HP_NODELETE" },
7507 { DT_HP_GROUP
, "HP_GROUP" },
7508 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
7512 bfd_vma val
= entry
->d_un
.d_val
;
7514 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
7515 if (val
& flags
[cnt
].bit
)
7519 fputs (flags
[cnt
].str
, stdout
);
7521 val
^= flags
[cnt
].bit
;
7524 if (val
!= 0 || first
)
7528 print_vma (val
, HEX
);
7534 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7542 /* VMS vs Unix time offset and factor. */
7544 #define VMS_EPOCH_OFFSET 35067168000000000LL
7545 #define VMS_GRANULARITY_FACTOR 10000000
7547 /* Display a VMS time in a human readable format. */
7550 print_vms_time (bfd_int64_t vmstime
)
7555 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
7556 tm
= gmtime (&unxtime
);
7557 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7558 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
7559 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
7564 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
7566 switch (entry
->d_tag
)
7568 case DT_IA_64_PLT_RESERVE
:
7569 /* First 3 slots reserved. */
7570 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7572 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
7575 case DT_IA_64_VMS_LINKTIME
:
7577 print_vms_time (entry
->d_un
.d_val
);
7581 case DT_IA_64_VMS_LNKFLAGS
:
7582 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7583 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
7584 printf (" CALL_DEBUG");
7585 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
7586 printf (" NOP0BUFS");
7587 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
7588 printf (" P0IMAGE");
7589 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
7590 printf (" MKTHREADS");
7591 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
7592 printf (" UPCALLS");
7593 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
7595 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
7596 printf (" INITIALIZE");
7597 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
7599 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
7600 printf (" EXE_INIT");
7601 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
7602 printf (" TBK_IN_IMG");
7603 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
7604 printf (" DBG_IN_IMG");
7605 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
7606 printf (" TBK_IN_DSF");
7607 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
7608 printf (" DBG_IN_DSF");
7609 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
7610 printf (" SIGNATURES");
7611 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
7612 printf (" REL_SEG_OFF");
7616 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
7623 get_32bit_dynamic_section (FILE * file
)
7625 Elf32_External_Dyn
* edyn
;
7626 Elf32_External_Dyn
* ext
;
7627 Elf_Internal_Dyn
* entry
;
7629 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7630 dynamic_size
, _("dynamic section"));
7634 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7635 might not have the luxury of section headers. Look for the DT_NULL
7636 terminator to determine the number of entries. */
7637 for (ext
= edyn
, dynamic_nent
= 0;
7638 (char *) ext
< (char *) edyn
+ dynamic_size
;
7642 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7646 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7648 if (dynamic_section
== NULL
)
7650 error (_("Out of memory\n"));
7655 for (ext
= edyn
, entry
= dynamic_section
;
7656 entry
< dynamic_section
+ dynamic_nent
;
7659 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7660 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7669 get_64bit_dynamic_section (FILE * file
)
7671 Elf64_External_Dyn
* edyn
;
7672 Elf64_External_Dyn
* ext
;
7673 Elf_Internal_Dyn
* entry
;
7675 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7676 dynamic_size
, _("dynamic section"));
7680 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7681 might not have the luxury of section headers. Look for the DT_NULL
7682 terminator to determine the number of entries. */
7683 for (ext
= edyn
, dynamic_nent
= 0;
7684 (char *) ext
< (char *) edyn
+ dynamic_size
;
7688 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7692 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7694 if (dynamic_section
== NULL
)
7696 error (_("Out of memory\n"));
7701 for (ext
= edyn
, entry
= dynamic_section
;
7702 entry
< dynamic_section
+ dynamic_nent
;
7705 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7706 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7715 print_dynamic_flags (bfd_vma flags
)
7723 flag
= flags
& - flags
;
7733 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7734 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7735 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7736 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7737 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7738 default: fputs (_("unknown"), stdout
); break;
7744 /* Parse and display the contents of the dynamic section. */
7747 process_dynamic_section (FILE * file
)
7749 Elf_Internal_Dyn
* entry
;
7751 if (dynamic_size
== 0)
7754 printf (_("\nThere is no dynamic section in this file.\n"));
7761 if (! get_32bit_dynamic_section (file
))
7764 else if (! get_64bit_dynamic_section (file
))
7767 /* Find the appropriate symbol table. */
7768 if (dynamic_symbols
== NULL
)
7770 for (entry
= dynamic_section
;
7771 entry
< dynamic_section
+ dynamic_nent
;
7774 Elf_Internal_Shdr section
;
7776 if (entry
->d_tag
!= DT_SYMTAB
)
7779 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7781 /* Since we do not know how big the symbol table is,
7782 we default to reading in the entire file (!) and
7783 processing that. This is overkill, I know, but it
7785 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7787 if (archive_file_offset
!= 0)
7788 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7791 if (fseek (file
, 0, SEEK_END
))
7792 error (_("Unable to seek to end of file!\n"));
7794 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7798 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7800 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7802 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
7803 if (num_dynamic_syms
< 1)
7805 error (_("Unable to determine the number of symbols to load\n"));
7811 /* Similarly find a string table. */
7812 if (dynamic_strings
== NULL
)
7814 for (entry
= dynamic_section
;
7815 entry
< dynamic_section
+ dynamic_nent
;
7818 unsigned long offset
;
7821 if (entry
->d_tag
!= DT_STRTAB
)
7824 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7826 /* Since we do not know how big the string table is,
7827 we default to reading in the entire file (!) and
7828 processing that. This is overkill, I know, but it
7831 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7833 if (archive_file_offset
!= 0)
7834 str_tab_len
= archive_file_size
- offset
;
7837 if (fseek (file
, 0, SEEK_END
))
7838 error (_("Unable to seek to end of file\n"));
7839 str_tab_len
= ftell (file
) - offset
;
7842 if (str_tab_len
< 1)
7845 (_("Unable to determine the length of the dynamic string table\n"));
7849 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7851 _("dynamic string table"));
7852 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
7857 /* And find the syminfo section if available. */
7858 if (dynamic_syminfo
== NULL
)
7860 unsigned long syminsz
= 0;
7862 for (entry
= dynamic_section
;
7863 entry
< dynamic_section
+ dynamic_nent
;
7866 if (entry
->d_tag
== DT_SYMINENT
)
7868 /* Note: these braces are necessary to avoid a syntax
7869 error from the SunOS4 C compiler. */
7870 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7872 else if (entry
->d_tag
== DT_SYMINSZ
)
7873 syminsz
= entry
->d_un
.d_val
;
7874 else if (entry
->d_tag
== DT_SYMINFO
)
7875 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7879 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7881 Elf_External_Syminfo
* extsyminfo
;
7882 Elf_External_Syminfo
* extsym
;
7883 Elf_Internal_Syminfo
* syminfo
;
7885 /* There is a syminfo section. Read the data. */
7886 extsyminfo
= (Elf_External_Syminfo
*)
7887 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7888 _("symbol information"));
7892 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7893 if (dynamic_syminfo
== NULL
)
7895 error (_("Out of memory\n"));
7899 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7900 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7901 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7902 ++syminfo
, ++extsym
)
7904 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7905 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7912 if (do_dynamic
&& dynamic_addr
)
7913 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7914 dynamic_addr
, dynamic_nent
);
7916 printf (_(" Tag Type Name/Value\n"));
7918 for (entry
= dynamic_section
;
7919 entry
< dynamic_section
+ dynamic_nent
;
7927 print_vma (entry
->d_tag
, FULL_HEX
);
7928 dtype
= get_dynamic_type (entry
->d_tag
);
7929 printf (" (%s)%*s", dtype
,
7930 ((is_32bit_elf
? 27 : 19)
7931 - (int) strlen (dtype
)),
7935 switch (entry
->d_tag
)
7939 print_dynamic_flags (entry
->d_un
.d_val
);
7949 switch (entry
->d_tag
)
7952 printf (_("Auxiliary library"));
7956 printf (_("Filter library"));
7960 printf (_("Configuration file"));
7964 printf (_("Dependency audit library"));
7968 printf (_("Audit library"));
7972 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7973 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7977 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7986 printf (_("Flags:"));
7988 if (entry
->d_un
.d_val
== 0)
7989 printf (_(" None\n"));
7992 unsigned long int val
= entry
->d_un
.d_val
;
7994 if (val
& DTF_1_PARINIT
)
7996 printf (" PARINIT");
7997 val
^= DTF_1_PARINIT
;
7999 if (val
& DTF_1_CONFEXP
)
8001 printf (" CONFEXP");
8002 val
^= DTF_1_CONFEXP
;
8005 printf (" %lx", val
);
8014 printf (_("Flags:"));
8016 if (entry
->d_un
.d_val
== 0)
8017 printf (_(" None\n"));
8020 unsigned long int val
= entry
->d_un
.d_val
;
8022 if (val
& DF_P1_LAZYLOAD
)
8024 printf (" LAZYLOAD");
8025 val
^= DF_P1_LAZYLOAD
;
8027 if (val
& DF_P1_GROUPPERM
)
8029 printf (" GROUPPERM");
8030 val
^= DF_P1_GROUPPERM
;
8033 printf (" %lx", val
);
8042 printf (_("Flags:"));
8043 if (entry
->d_un
.d_val
== 0)
8044 printf (_(" None\n"));
8047 unsigned long int val
= entry
->d_un
.d_val
;
8054 if (val
& DF_1_GLOBAL
)
8059 if (val
& DF_1_GROUP
)
8064 if (val
& DF_1_NODELETE
)
8066 printf (" NODELETE");
8067 val
^= DF_1_NODELETE
;
8069 if (val
& DF_1_LOADFLTR
)
8071 printf (" LOADFLTR");
8072 val
^= DF_1_LOADFLTR
;
8074 if (val
& DF_1_INITFIRST
)
8076 printf (" INITFIRST");
8077 val
^= DF_1_INITFIRST
;
8079 if (val
& DF_1_NOOPEN
)
8084 if (val
& DF_1_ORIGIN
)
8089 if (val
& DF_1_DIRECT
)
8094 if (val
& DF_1_TRANS
)
8099 if (val
& DF_1_INTERPOSE
)
8101 printf (" INTERPOSE");
8102 val
^= DF_1_INTERPOSE
;
8104 if (val
& DF_1_NODEFLIB
)
8106 printf (" NODEFLIB");
8107 val
^= DF_1_NODEFLIB
;
8109 if (val
& DF_1_NODUMP
)
8114 if (val
& DF_1_CONLFAT
)
8116 printf (" CONLFAT");
8117 val
^= DF_1_CONLFAT
;
8120 printf (" %lx", val
);
8127 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8129 puts (get_dynamic_type (entry
->d_un
.d_val
));
8149 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8155 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8156 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8162 switch (entry
->d_tag
)
8165 printf (_("Shared library: [%s]"), name
);
8167 if (streq (name
, program_interpreter
))
8168 printf (_(" program interpreter"));
8172 printf (_("Library soname: [%s]"), name
);
8176 printf (_("Library rpath: [%s]"), name
);
8180 printf (_("Library runpath: [%s]"), name
);
8184 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8189 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8202 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
8206 case DT_INIT_ARRAYSZ
:
8207 case DT_FINI_ARRAYSZ
:
8208 case DT_GNU_CONFLICTSZ
:
8209 case DT_GNU_LIBLISTSZ
:
8212 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8213 printf (_(" (bytes)\n"));
8223 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
8236 if (entry
->d_tag
== DT_USED
8237 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8239 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
8243 printf (_("Not needed object: [%s]\n"), name
);
8248 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8254 /* The value of this entry is ignored. */
8259 case DT_GNU_PRELINKED
:
8263 time_t atime
= entry
->d_un
.d_val
;
8265 tmp
= gmtime (&atime
);
8266 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8267 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8268 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8274 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
8277 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8283 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
8284 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
8289 switch (elf_header
.e_machine
)
8292 case EM_MIPS_RS3_LE
:
8293 dynamic_section_mips_val (entry
);
8296 dynamic_section_parisc_val (entry
);
8299 dynamic_section_ia64_val (entry
);
8302 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
8314 get_ver_flags (unsigned int flags
)
8316 static char buff
[32];
8323 if (flags
& VER_FLG_BASE
)
8324 strcat (buff
, "BASE ");
8326 if (flags
& VER_FLG_WEAK
)
8328 if (flags
& VER_FLG_BASE
)
8329 strcat (buff
, "| ");
8331 strcat (buff
, "WEAK ");
8334 if (flags
& VER_FLG_INFO
)
8336 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
8337 strcat (buff
, "| ");
8339 strcat (buff
, "INFO ");
8342 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
8343 strcat (buff
, _("| <unknown>"));
8348 /* Display the contents of the version sections. */
8351 process_version_sections (FILE * file
)
8353 Elf_Internal_Shdr
* section
;
8360 for (i
= 0, section
= section_headers
;
8361 i
< elf_header
.e_shnum
;
8364 switch (section
->sh_type
)
8366 case SHT_GNU_verdef
:
8368 Elf_External_Verdef
* edefs
;
8376 (_("\nVersion definition section '%s' contains %u entries:\n"),
8377 SECTION_NAME (section
), section
->sh_info
);
8379 printf (_(" Addr: 0x"));
8380 printf_vma (section
->sh_addr
);
8381 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8382 (unsigned long) section
->sh_offset
, section
->sh_link
,
8383 section
->sh_link
< elf_header
.e_shnum
8384 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8387 edefs
= (Elf_External_Verdef
*)
8388 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
8389 _("version definition section"));
8392 endbuf
= (char *) edefs
+ section
->sh_size
;
8394 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8397 Elf_External_Verdef
* edef
;
8398 Elf_Internal_Verdef ent
;
8399 Elf_External_Verdaux
* eaux
;
8400 Elf_Internal_Verdaux aux
;
8404 /* Check for negative or very large indicies. */
8405 if ((unsigned char *) edefs
+ idx
< (unsigned char *) edefs
)
8408 vstart
= ((char *) edefs
) + idx
;
8409 if (vstart
+ sizeof (*edef
) > endbuf
)
8412 edef
= (Elf_External_Verdef
*) vstart
;
8414 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
8415 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
8416 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
8417 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
8418 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
8419 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
8420 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
8422 printf (_(" %#06x: Rev: %d Flags: %s"),
8423 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
8425 printf (_(" Index: %d Cnt: %d "),
8426 ent
.vd_ndx
, ent
.vd_cnt
);
8428 /* Check for overflow. */
8429 if ((unsigned char *)(vstart
+ ent
.vd_aux
) < (unsigned char *) vstart
8430 || (unsigned char *)(vstart
+ ent
.vd_aux
) > (unsigned char *) endbuf
)
8433 vstart
+= ent
.vd_aux
;
8435 eaux
= (Elf_External_Verdaux
*) vstart
;
8437 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8438 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8440 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8441 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
8443 printf (_("Name index: %ld\n"), aux
.vda_name
);
8445 isum
= idx
+ ent
.vd_aux
;
8447 for (j
= 1; j
< ent
.vd_cnt
; j
++)
8449 /* Check for overflow. */
8450 if ((unsigned char *)(vstart
+ aux
.vda_next
) < (unsigned char *) vstart
8451 || (unsigned char *)(vstart
+ aux
.vda_next
) > (unsigned char *) endbuf
)
8454 isum
+= aux
.vda_next
;
8455 vstart
+= aux
.vda_next
;
8457 eaux
= (Elf_External_Verdaux
*) vstart
;
8458 if (vstart
+ sizeof (*eaux
) > endbuf
)
8461 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
8462 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
8464 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
8465 printf (_(" %#06x: Parent %d: %s\n"),
8466 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
8468 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8469 isum
, j
, aux
.vda_name
);
8473 printf (_(" Version def aux past end of section\n"));
8478 if (cnt
< section
->sh_info
)
8479 printf (_(" Version definition past end of section\n"));
8485 case SHT_GNU_verneed
:
8487 Elf_External_Verneed
* eneed
;
8494 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8495 SECTION_NAME (section
), section
->sh_info
);
8497 printf (_(" Addr: 0x"));
8498 printf_vma (section
->sh_addr
);
8499 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8500 (unsigned long) section
->sh_offset
, section
->sh_link
,
8501 section
->sh_link
< elf_header
.e_shnum
8502 ? SECTION_NAME (section_headers
+ section
->sh_link
)
8505 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
8506 section
->sh_offset
, 1,
8508 _("Version Needs section"));
8511 endbuf
= (char *) eneed
+ section
->sh_size
;
8513 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
8515 Elf_External_Verneed
* entry
;
8516 Elf_Internal_Verneed ent
;
8521 if ((unsigned char *) eneed
+ idx
< (unsigned char *) eneed
)
8524 vstart
= ((char *) eneed
) + idx
;
8525 if (vstart
+ sizeof (*entry
) > endbuf
)
8528 entry
= (Elf_External_Verneed
*) vstart
;
8530 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
8531 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
8532 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
8533 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
8534 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
8536 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
8538 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
8539 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
8541 printf (_(" File: %lx"), ent
.vn_file
);
8543 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
8545 /* Check for overflow. */
8546 if ((unsigned char *)(vstart
+ ent
.vn_aux
) < (unsigned char *) vstart
8547 || (unsigned char *)(vstart
+ ent
.vn_aux
) > (unsigned char *) endbuf
)
8550 vstart
+= ent
.vn_aux
;
8552 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
8554 Elf_External_Vernaux
* eaux
;
8555 Elf_Internal_Vernaux aux
;
8557 if (vstart
+ sizeof (*eaux
) > endbuf
)
8559 eaux
= (Elf_External_Vernaux
*) vstart
;
8561 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
8562 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
8563 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
8564 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
8565 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
8567 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
8568 printf (_(" %#06x: Name: %s"),
8569 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
8571 printf (_(" %#06x: Name index: %lx"),
8572 isum
, aux
.vna_name
);
8574 printf (_(" Flags: %s Version: %d\n"),
8575 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
8577 /* Check for overflow. */
8578 if ((unsigned char *)(vstart
+ aux
.vna_next
) < (unsigned char *) vstart
8579 || (unsigned char *)(vstart
+ aux
.vna_next
) > (unsigned char *) endbuf
)
8582 isum
+= aux
.vna_next
;
8583 vstart
+= aux
.vna_next
;
8587 warn (_("Missing Version Needs auxillary information\n"));
8592 if (cnt
< section
->sh_info
)
8593 warn (_("Missing Version Needs information\n"));
8599 case SHT_GNU_versym
:
8601 Elf_Internal_Shdr
* link_section
;
8604 unsigned char * edata
;
8605 unsigned short * data
;
8607 Elf_Internal_Sym
* symbols
;
8608 Elf_Internal_Shdr
* string_sec
;
8609 unsigned long num_syms
;
8612 if (section
->sh_link
>= elf_header
.e_shnum
)
8615 link_section
= section_headers
+ section
->sh_link
;
8616 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
8618 if (link_section
->sh_link
>= elf_header
.e_shnum
)
8623 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
8624 if (symbols
== NULL
)
8627 string_sec
= section_headers
+ link_section
->sh_link
;
8629 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
8630 string_sec
->sh_size
,
8631 _("version string table"));
8638 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8639 SECTION_NAME (section
), total
);
8641 printf (_(" Addr: "));
8642 printf_vma (section
->sh_addr
);
8643 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8644 (unsigned long) section
->sh_offset
, section
->sh_link
,
8645 SECTION_NAME (link_section
));
8647 off
= offset_from_vma (file
,
8648 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8649 total
* sizeof (short));
8650 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
8652 _("version symbol data"));
8660 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
8662 for (cnt
= total
; cnt
--;)
8663 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
8668 for (cnt
= 0; cnt
< total
; cnt
+= 4)
8671 int check_def
, check_need
;
8674 printf (" %03x:", cnt
);
8676 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
8677 switch (data
[cnt
+ j
])
8680 fputs (_(" 0 (*local*) "), stdout
);
8684 fputs (_(" 1 (*global*) "), stdout
);
8688 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8689 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8691 /* If this index value is greater than the size of the symbols
8692 array, break to avoid an out-of-bounds read. */
8693 if ((unsigned long)(cnt
+ j
) >= num_syms
)
8695 warn (_("invalid index into symbol array\n"));
8701 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8702 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8705 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8712 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8714 Elf_Internal_Verneed ivn
;
8715 unsigned long offset
;
8717 offset
= offset_from_vma
8718 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8719 sizeof (Elf_External_Verneed
));
8723 Elf_Internal_Vernaux ivna
;
8724 Elf_External_Verneed evn
;
8725 Elf_External_Vernaux evna
;
8726 unsigned long a_off
;
8728 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8729 _("version need")) == NULL
)
8732 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8733 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8735 a_off
= offset
+ ivn
.vn_aux
;
8739 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
8740 1, _("version need aux (2)")) == NULL
)
8747 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8748 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8751 a_off
+= ivna
.vna_next
;
8753 while (ivna
.vna_other
!= data
[cnt
+ j
]
8754 && ivna
.vna_next
!= 0);
8756 if (ivna
.vna_other
== data
[cnt
+ j
])
8758 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8760 if (ivna
.vna_name
>= string_sec
->sh_size
)
8761 name
= _("*invalid*");
8763 name
= strtab
+ ivna
.vna_name
;
8764 nn
+= printf ("(%s%-*s",
8766 12 - (int) strlen (name
),
8772 offset
+= ivn
.vn_next
;
8774 while (ivn
.vn_next
);
8777 if (check_def
&& data
[cnt
+ j
] != 0x8001
8778 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8780 Elf_Internal_Verdef ivd
;
8781 Elf_External_Verdef evd
;
8782 unsigned long offset
;
8784 offset
= offset_from_vma
8785 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8790 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8791 _("version def")) == NULL
)
8798 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8799 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8802 offset
+= ivd
.vd_next
;
8804 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8805 && ivd
.vd_next
!= 0);
8807 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8809 Elf_External_Verdaux evda
;
8810 Elf_Internal_Verdaux ivda
;
8812 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8814 if (get_data (&evda
, file
,
8815 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8817 _("version def aux")) == NULL
)
8820 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8822 if (ivda
.vda_name
>= string_sec
->sh_size
)
8823 name
= _("*invalid*");
8825 name
= strtab
+ ivda
.vda_name
;
8826 nn
+= printf ("(%s%-*s",
8828 12 - (int) strlen (name
),
8834 printf ("%*c", 18 - nn
, ' ');
8852 printf (_("\nNo version information found in this file.\n"));
8858 get_symbol_binding (unsigned int binding
)
8860 static char buff
[32];
8864 case STB_LOCAL
: return "LOCAL";
8865 case STB_GLOBAL
: return "GLOBAL";
8866 case STB_WEAK
: return "WEAK";
8868 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8869 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8871 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8873 if (binding
== STB_GNU_UNIQUE
8874 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8875 /* GNU is still using the default value 0. */
8876 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8878 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8881 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8887 get_symbol_type (unsigned int type
)
8889 static char buff
[32];
8893 case STT_NOTYPE
: return "NOTYPE";
8894 case STT_OBJECT
: return "OBJECT";
8895 case STT_FUNC
: return "FUNC";
8896 case STT_SECTION
: return "SECTION";
8897 case STT_FILE
: return "FILE";
8898 case STT_COMMON
: return "COMMON";
8899 case STT_TLS
: return "TLS";
8900 case STT_RELC
: return "RELC";
8901 case STT_SRELC
: return "SRELC";
8903 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8905 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8906 return "THUMB_FUNC";
8908 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8911 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8912 return "PARISC_MILLI";
8914 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8916 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8918 if (elf_header
.e_machine
== EM_PARISC
)
8920 if (type
== STT_HP_OPAQUE
)
8922 if (type
== STT_HP_STUB
)
8926 if (type
== STT_GNU_IFUNC
8927 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
8928 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
8929 /* GNU is still using the default value 0. */
8930 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8933 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8936 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8942 get_symbol_visibility (unsigned int visibility
)
8946 case STV_DEFAULT
: return "DEFAULT";
8947 case STV_INTERNAL
: return "INTERNAL";
8948 case STV_HIDDEN
: return "HIDDEN";
8949 case STV_PROTECTED
: return "PROTECTED";
8955 get_mips_symbol_other (unsigned int other
)
8967 case STO_MICROMIPS
| STO_MIPS_PIC
:
8968 return "MICROMIPS, MIPS PIC";
8977 get_ia64_symbol_other (unsigned int other
)
8981 static char res
[32];
8985 /* Function types is for images and .STB files only. */
8986 switch (elf_header
.e_type
)
8990 switch (VMS_ST_FUNC_TYPE (other
))
8992 case VMS_SFT_CODE_ADDR
:
8993 strcat (res
, " CA");
8995 case VMS_SFT_SYMV_IDX
:
8996 strcat (res
, " VEC");
8999 strcat (res
, " FD");
9001 case VMS_SFT_RESERVE
:
9002 strcat (res
, " RSV");
9011 switch (VMS_ST_LINKAGE (other
))
9013 case VMS_STL_IGNORE
:
9014 strcat (res
, " IGN");
9016 case VMS_STL_RESERVE
:
9017 strcat (res
, " RSV");
9020 strcat (res
, " STD");
9023 strcat (res
, " LNK");
9038 get_symbol_other (unsigned int other
)
9040 const char * result
= NULL
;
9041 static char buff
[32];
9046 switch (elf_header
.e_machine
)
9049 result
= get_mips_symbol_other (other
);
9052 result
= get_ia64_symbol_other (other
);
9061 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
9066 get_symbol_index_type (unsigned int type
)
9068 static char buff
[32];
9072 case SHN_UNDEF
: return "UND";
9073 case SHN_ABS
: return "ABS";
9074 case SHN_COMMON
: return "COM";
9076 if (type
== SHN_IA_64_ANSI_COMMON
9077 && elf_header
.e_machine
== EM_IA_64
9078 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
9080 else if ((elf_header
.e_machine
== EM_X86_64
9081 || elf_header
.e_machine
== EM_L1OM
9082 || elf_header
.e_machine
== EM_K1OM
)
9083 && type
== SHN_X86_64_LCOMMON
)
9085 else if ((type
== SHN_MIPS_SCOMMON
9086 && elf_header
.e_machine
== EM_MIPS
)
9087 || (type
== SHN_TIC6X_SCOMMON
9088 && elf_header
.e_machine
== EM_TI_C6000
))
9090 else if (type
== SHN_MIPS_SUNDEFINED
9091 && elf_header
.e_machine
== EM_MIPS
)
9093 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
9094 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
9095 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
9096 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
9097 else if (type
>= SHN_LORESERVE
)
9098 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
9099 else if (type
>= elf_header
.e_shnum
)
9100 sprintf (buff
, "bad section index[%3d]", type
);
9102 sprintf (buff
, "%3d", type
);
9110 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
9112 unsigned char * e_data
;
9115 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
9119 error (_("Out of memory\n"));
9123 if (fread (e_data
, ent_size
, number
, file
) != number
)
9125 error (_("Unable to read in dynamic data\n"));
9129 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
9133 error (_("Out of memory\n"));
9139 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
9147 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
9149 Elf_Internal_Sym
* psym
;
9152 psym
= dynamic_symbols
+ si
;
9154 n
= print_vma (si
, DEC_5
);
9156 fputs (" " + n
, stdout
);
9157 printf (" %3lu: ", hn
);
9158 print_vma (psym
->st_value
, LONG_HEX
);
9160 print_vma (psym
->st_size
, DEC_5
);
9162 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9163 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9164 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9165 /* Check to see if any other bits in the st_other field are set.
9166 Note - displaying this information disrupts the layout of the
9167 table being generated, but for the moment this case is very
9169 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9170 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9171 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
9172 if (VALID_DYNAMIC_NAME (psym
->st_name
))
9173 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
9175 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
9179 /* Dump the symbol table. */
9181 process_symbol_table (FILE * file
)
9183 Elf_Internal_Shdr
* section
;
9184 bfd_vma nbuckets
= 0;
9185 bfd_vma nchains
= 0;
9186 bfd_vma
* buckets
= NULL
;
9187 bfd_vma
* chains
= NULL
;
9188 bfd_vma ngnubuckets
= 0;
9189 bfd_vma
* gnubuckets
= NULL
;
9190 bfd_vma
* gnuchains
= NULL
;
9191 bfd_vma gnusymidx
= 0;
9193 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
9196 if (dynamic_info
[DT_HASH
]
9198 || (do_using_dynamic
9200 && dynamic_strings
!= NULL
)))
9202 unsigned char nb
[8];
9203 unsigned char nc
[8];
9204 int hash_ent_size
= 4;
9206 if ((elf_header
.e_machine
== EM_ALPHA
9207 || elf_header
.e_machine
== EM_S390
9208 || elf_header
.e_machine
== EM_S390_OLD
)
9209 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
9213 (archive_file_offset
9214 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
9215 sizeof nb
+ sizeof nc
)),
9218 error (_("Unable to seek to start of dynamic information\n"));
9222 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
9224 error (_("Failed to read in number of buckets\n"));
9228 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
9230 error (_("Failed to read in number of chains\n"));
9234 nbuckets
= byte_get (nb
, hash_ent_size
);
9235 nchains
= byte_get (nc
, hash_ent_size
);
9237 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
9238 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
9241 if (buckets
== NULL
|| chains
== NULL
)
9243 if (do_using_dynamic
)
9254 if (dynamic_info_DT_GNU_HASH
9256 || (do_using_dynamic
9258 && dynamic_strings
!= NULL
)))
9260 unsigned char nb
[16];
9261 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
9262 bfd_vma buckets_vma
;
9265 (archive_file_offset
9266 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
9270 error (_("Unable to seek to start of dynamic information\n"));
9274 if (fread (nb
, 16, 1, file
) != 1)
9276 error (_("Failed to read in number of buckets\n"));
9280 ngnubuckets
= byte_get (nb
, 4);
9281 gnusymidx
= byte_get (nb
+ 4, 4);
9282 bitmaskwords
= byte_get (nb
+ 8, 4);
9283 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
9285 buckets_vma
+= bitmaskwords
* 4;
9287 buckets_vma
+= bitmaskwords
* 8;
9290 (archive_file_offset
9291 + offset_from_vma (file
, buckets_vma
, 4)),
9294 error (_("Unable to seek to start of dynamic information\n"));
9298 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
9300 if (gnubuckets
== NULL
)
9303 for (i
= 0; i
< ngnubuckets
; i
++)
9304 if (gnubuckets
[i
] != 0)
9306 if (gnubuckets
[i
] < gnusymidx
)
9309 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
9310 maxchain
= gnubuckets
[i
];
9313 if (maxchain
== 0xffffffff)
9316 maxchain
-= gnusymidx
;
9319 (archive_file_offset
9320 + offset_from_vma (file
, buckets_vma
9321 + 4 * (ngnubuckets
+ maxchain
), 4)),
9324 error (_("Unable to seek to start of dynamic information\n"));
9330 if (fread (nb
, 4, 1, file
) != 1)
9332 error (_("Failed to determine last chain length\n"));
9336 if (maxchain
+ 1 == 0)
9341 while ((byte_get (nb
, 4) & 1) == 0);
9344 (archive_file_offset
9345 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
9348 error (_("Unable to seek to start of dynamic information\n"));
9352 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
9355 if (gnuchains
== NULL
)
9360 if (do_using_dynamic
)
9365 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
9368 && dynamic_strings
!= NULL
)
9372 if (dynamic_info
[DT_HASH
])
9376 printf (_("\nSymbol table for image:\n"));
9378 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9380 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9382 for (hn
= 0; hn
< nbuckets
; hn
++)
9387 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
9388 print_dynamic_symbol (si
, hn
);
9392 if (dynamic_info_DT_GNU_HASH
)
9394 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9396 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9398 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9400 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9401 if (gnubuckets
[hn
] != 0)
9403 bfd_vma si
= gnubuckets
[hn
];
9404 bfd_vma off
= si
- gnusymidx
;
9408 print_dynamic_symbol (si
, hn
);
9411 while ((gnuchains
[off
++] & 1) == 0);
9415 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
9419 for (i
= 0, section
= section_headers
;
9420 i
< elf_header
.e_shnum
;
9424 char * strtab
= NULL
;
9425 unsigned long int strtab_size
= 0;
9426 Elf_Internal_Sym
* symtab
;
9427 Elf_Internal_Sym
* psym
;
9428 unsigned long num_syms
;
9430 if ((section
->sh_type
!= SHT_SYMTAB
9431 && section
->sh_type
!= SHT_DYNSYM
)
9433 && section
->sh_type
== SHT_SYMTAB
))
9436 if (section
->sh_entsize
== 0)
9438 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9439 SECTION_NAME (section
));
9443 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9444 SECTION_NAME (section
),
9445 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
9448 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9450 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9452 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
9456 if (section
->sh_link
== elf_header
.e_shstrndx
)
9458 strtab
= string_table
;
9459 strtab_size
= string_table_length
;
9461 else if (section
->sh_link
< elf_header
.e_shnum
)
9463 Elf_Internal_Shdr
* string_sec
;
9465 string_sec
= section_headers
+ section
->sh_link
;
9467 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
9468 1, string_sec
->sh_size
,
9470 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
9473 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
9475 printf ("%6d: ", si
);
9476 print_vma (psym
->st_value
, LONG_HEX
);
9478 print_vma (psym
->st_size
, DEC_5
);
9479 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
9480 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
9481 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
9482 /* Check to see if any other bits in the st_other field are set.
9483 Note - displaying this information disrupts the layout of the
9484 table being generated, but for the moment this case is very rare. */
9485 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
9486 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
9487 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
9488 print_symbol (25, psym
->st_name
< strtab_size
9489 ? strtab
+ psym
->st_name
: _("<corrupt>"));
9491 if (section
->sh_type
== SHT_DYNSYM
9492 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
9494 unsigned char data
[2];
9495 unsigned short vers_data
;
9496 unsigned long offset
;
9500 offset
= offset_from_vma
9501 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9502 sizeof data
+ si
* sizeof (vers_data
));
9504 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
9505 sizeof (data
), 1, _("version data")) == NULL
)
9508 vers_data
= byte_get (data
, 2);
9510 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
9511 && section_headers
[psym
->st_shndx
].sh_type
9514 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
9516 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
9518 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
9519 && (is_nobits
|| ! check_def
))
9521 Elf_External_Verneed evn
;
9522 Elf_Internal_Verneed ivn
;
9523 Elf_Internal_Vernaux ivna
;
9525 /* We must test both. */
9526 offset
= offset_from_vma
9527 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9532 unsigned long vna_off
;
9534 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9535 _("version need")) == NULL
)
9543 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9544 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9546 vna_off
= offset
+ ivn
.vn_aux
;
9550 Elf_External_Vernaux evna
;
9552 if (get_data (&evna
, file
, vna_off
,
9554 _("version need aux (3)")) == NULL
)
9562 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9563 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9564 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9567 vna_off
+= ivna
.vna_next
;
9569 while (ivna
.vna_other
!= vers_data
9570 && ivna
.vna_next
!= 0);
9572 if (ivna
.vna_other
== vers_data
)
9575 offset
+= ivn
.vn_next
;
9577 while (ivn
.vn_next
!= 0);
9579 if (ivna
.vna_other
== vers_data
)
9582 ivna
.vna_name
< strtab_size
9583 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
9587 else if (! is_nobits
)
9588 error (_("bad dynamic symbol\n"));
9595 if (vers_data
!= 0x8001
9596 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9598 Elf_Internal_Verdef ivd
;
9599 Elf_Internal_Verdaux ivda
;
9600 Elf_External_Verdaux evda
;
9603 off
= offset_from_vma
9605 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9606 sizeof (Elf_External_Verdef
));
9610 Elf_External_Verdef evd
;
9612 if (get_data (&evd
, file
, off
, sizeof (evd
),
9613 1, _("version def")) == NULL
)
9621 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
9622 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
9623 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
9628 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
9629 && ivd
.vd_next
!= 0);
9634 if (get_data (&evda
, file
, off
, sizeof (evda
),
9635 1, _("version def aux")) == NULL
)
9638 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
9640 if (psym
->st_name
!= ivda
.vda_name
)
9641 printf ((vers_data
& VERSYM_HIDDEN
)
9643 ivda
.vda_name
< strtab_size
9644 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
9654 if (strtab
!= string_table
)
9660 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9662 if (do_histogram
&& buckets
!= NULL
)
9664 unsigned long * lengths
;
9665 unsigned long * counts
;
9668 unsigned long maxlength
= 0;
9669 unsigned long nzero_counts
= 0;
9670 unsigned long nsyms
= 0;
9672 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9673 (unsigned long) nbuckets
);
9674 printf (_(" Length Number %% of total Coverage\n"));
9676 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
9677 if (lengths
== NULL
)
9679 error (_("Out of memory\n"));
9682 for (hn
= 0; hn
< nbuckets
; ++hn
)
9684 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
9687 if (maxlength
< ++lengths
[hn
])
9692 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9695 error (_("Out of memory\n"));
9699 for (hn
= 0; hn
< nbuckets
; ++hn
)
9700 ++counts
[lengths
[hn
]];
9705 printf (" 0 %-10lu (%5.1f%%)\n",
9706 counts
[0], (counts
[0] * 100.0) / nbuckets
);
9707 for (i
= 1; i
<= maxlength
; ++i
)
9709 nzero_counts
+= counts
[i
] * i
;
9710 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9711 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
9712 (nzero_counts
* 100.0) / nsyms
);
9720 if (buckets
!= NULL
)
9726 if (do_histogram
&& gnubuckets
!= NULL
)
9728 unsigned long * lengths
;
9729 unsigned long * counts
;
9731 unsigned long maxlength
= 0;
9732 unsigned long nzero_counts
= 0;
9733 unsigned long nsyms
= 0;
9735 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
9736 if (lengths
== NULL
)
9738 error (_("Out of memory\n"));
9742 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9743 (unsigned long) ngnubuckets
);
9744 printf (_(" Length Number %% of total Coverage\n"));
9746 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9747 if (gnubuckets
[hn
] != 0)
9749 bfd_vma off
, length
= 1;
9751 for (off
= gnubuckets
[hn
] - gnusymidx
;
9752 (gnuchains
[off
] & 1) == 0; ++off
)
9754 lengths
[hn
] = length
;
9755 if (length
> maxlength
)
9760 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9763 error (_("Out of memory\n"));
9767 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9768 ++counts
[lengths
[hn
]];
9770 if (ngnubuckets
> 0)
9773 printf (" 0 %-10lu (%5.1f%%)\n",
9774 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9775 for (j
= 1; j
<= maxlength
; ++j
)
9777 nzero_counts
+= counts
[j
] * j
;
9778 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9779 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9780 (nzero_counts
* 100.0) / nsyms
);
9794 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9798 if (dynamic_syminfo
== NULL
9800 /* No syminfo, this is ok. */
9803 /* There better should be a dynamic symbol section. */
9804 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9808 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9809 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9811 printf (_(" Num: Name BoundTo Flags\n"));
9812 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9814 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9816 printf ("%4d: ", i
);
9817 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9818 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9820 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9823 switch (dynamic_syminfo
[i
].si_boundto
)
9825 case SYMINFO_BT_SELF
:
9826 fputs ("SELF ", stdout
);
9828 case SYMINFO_BT_PARENT
:
9829 fputs ("PARENT ", stdout
);
9832 if (dynamic_syminfo
[i
].si_boundto
> 0
9833 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9834 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9836 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9840 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9844 if (flags
& SYMINFO_FLG_DIRECT
)
9846 if (flags
& SYMINFO_FLG_PASSTHRU
)
9847 printf (" PASSTHRU");
9848 if (flags
& SYMINFO_FLG_COPY
)
9850 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9851 printf (" LAZYLOAD");
9859 /* Check to see if the given reloc needs to be handled in a target specific
9860 manner. If so then process the reloc and return TRUE otherwise return
9864 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9865 unsigned char * start
,
9866 Elf_Internal_Sym
* symtab
)
9868 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9870 switch (elf_header
.e_machine
)
9873 case EM_CYGNUS_MN10300
:
9875 static Elf_Internal_Sym
* saved_sym
= NULL
;
9879 case 34: /* R_MN10300_ALIGN */
9881 case 33: /* R_MN10300_SYM_DIFF */
9882 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9884 case 1: /* R_MN10300_32 */
9885 case 2: /* R_MN10300_16 */
9886 if (saved_sym
!= NULL
)
9890 value
= reloc
->r_addend
9891 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9892 - saved_sym
->st_value
);
9894 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9901 if (saved_sym
!= NULL
)
9902 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9912 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9913 DWARF debug sections. This is a target specific test. Note - we do not
9914 go through the whole including-target-headers-multiple-times route, (as
9915 we have already done with <elf/h8.h>) because this would become very
9916 messy and even then this function would have to contain target specific
9917 information (the names of the relocs instead of their numeric values).
9918 FIXME: This is not the correct way to solve this problem. The proper way
9919 is to have target specific reloc sizing and typing functions created by
9920 the reloc-macros.h header, in the same way that it already creates the
9921 reloc naming functions. */
9924 is_32bit_abs_reloc (unsigned int reloc_type
)
9926 switch (elf_header
.e_machine
)
9930 return reloc_type
== 1; /* R_386_32. */
9932 return reloc_type
== 1; /* R_68K_32. */
9934 return reloc_type
== 1; /* R_860_32. */
9936 return reloc_type
== 2; /* R_960_32. */
9938 return reloc_type
== 258; /* R_AARCH64_ABS32 */
9940 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
9942 return reloc_type
== 1; /* R_ARC_32. */
9944 return reloc_type
== 2; /* R_ARM_ABS32 */
9947 return reloc_type
== 1;
9948 case EM_ADAPTEVA_EPIPHANY
:
9949 return reloc_type
== 3;
9951 return reloc_type
== 0x12; /* R_byte4_data. */
9953 return reloc_type
== 3; /* R_CRIS_32. */
9955 return reloc_type
== 3; /* R_CR16_NUM32. */
9957 return reloc_type
== 15; /* R_CRX_NUM32. */
9959 return reloc_type
== 1;
9960 case EM_CYGNUS_D10V
:
9962 return reloc_type
== 6; /* R_D10V_32. */
9963 case EM_CYGNUS_D30V
:
9965 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9967 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9968 case EM_CYGNUS_FR30
:
9970 return reloc_type
== 3; /* R_FR30_32. */
9974 return reloc_type
== 1; /* R_H8_DIR32. */
9976 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9979 return reloc_type
== 2; /* R_IP2K_32. */
9981 return reloc_type
== 2; /* R_IQ2000_32. */
9982 case EM_LATTICEMICO32
:
9983 return reloc_type
== 3; /* R_LM32_32. */
9986 return reloc_type
== 3; /* R_M32C_32. */
9988 return reloc_type
== 34; /* R_M32R_32_RELA. */
9990 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9992 return reloc_type
== 4; /* R_MEP_32. */
9994 return reloc_type
== 1; /* R_MICROBLAZE_32. */
9996 return reloc_type
== 2; /* R_MIPS_32. */
9998 return reloc_type
== 4; /* R_MMIX_32. */
9999 case EM_CYGNUS_MN10200
:
10001 return reloc_type
== 1; /* R_MN10200_32. */
10002 case EM_CYGNUS_MN10300
:
10004 return reloc_type
== 1; /* R_MN10300_32. */
10006 return reloc_type
== 1; /* R_MOXIE_32. */
10007 case EM_MSP430_OLD
:
10009 return reloc_type
== 1; /* R_MSP43_32. */
10011 return reloc_type
== 2; /* R_MT_32. */
10012 case EM_ALTERA_NIOS2
:
10014 return reloc_type
== 1; /* R_NIOS_32. */
10017 return reloc_type
== 1; /* R_OR32_32. */
10019 return (reloc_type
== 1 /* R_PARISC_DIR32. */
10020 || reloc_type
== 41); /* R_PARISC_SECREL32. */
10023 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
10025 return reloc_type
== 1; /* R_PPC64_ADDR32. */
10027 return reloc_type
== 1; /* R_PPC_ADDR32. */
10029 return reloc_type
== 1; /* R_RL78_DIR32. */
10031 return reloc_type
== 1; /* R_RX_DIR32. */
10033 return reloc_type
== 1; /* R_I370_ADDR31. */
10036 return reloc_type
== 4; /* R_S390_32. */
10038 return reloc_type
== 8; /* R_SCORE_ABS32. */
10040 return reloc_type
== 1; /* R_SH_DIR32. */
10041 case EM_SPARC32PLUS
:
10044 return reloc_type
== 3 /* R_SPARC_32. */
10045 || reloc_type
== 23; /* R_SPARC_UA32. */
10047 return reloc_type
== 6; /* R_SPU_ADDR32 */
10049 return reloc_type
== 1; /* R_C6000_ABS32. */
10051 return reloc_type
== 2; /* R_TILEGX_32. */
10053 return reloc_type
== 1; /* R_TILEPRO_32. */
10054 case EM_CYGNUS_V850
:
10056 return reloc_type
== 6; /* R_V850_ABS32. */
10058 return reloc_type
== 0x33; /* R_V810_WORD. */
10060 return reloc_type
== 1; /* R_VAX_32. */
10064 return reloc_type
== 10; /* R_X86_64_32. */
10067 return reloc_type
== 3; /* R_XC16C_ABS_32. */
10069 return reloc_type
== 4; /* R_XGATE_32. */
10071 return reloc_type
== 1; /* R_XSTROMY16_32. */
10072 case EM_XTENSA_OLD
:
10074 return reloc_type
== 1; /* R_XTENSA_32. */
10076 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10077 elf_header
.e_machine
);
10082 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10083 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10086 is_32bit_pcrel_reloc (unsigned int reloc_type
)
10088 switch (elf_header
.e_machine
)
10092 return reloc_type
== 2; /* R_386_PC32. */
10094 return reloc_type
== 4; /* R_68K_PC32. */
10096 return reloc_type
== 261; /* R_AARCH64_PREL32 */
10097 case EM_ADAPTEVA_EPIPHANY
:
10098 return reloc_type
== 6;
10100 return reloc_type
== 10; /* R_ALPHA_SREL32. */
10102 return reloc_type
== 3; /* R_ARM_REL32 */
10103 case EM_MICROBLAZE
:
10104 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
10106 return reloc_type
== 9; /* R_PARISC_PCREL32. */
10108 return reloc_type
== 26; /* R_PPC_REL32. */
10110 return reloc_type
== 26; /* R_PPC64_REL32. */
10113 return reloc_type
== 5; /* R_390_PC32. */
10115 return reloc_type
== 2; /* R_SH_REL32. */
10116 case EM_SPARC32PLUS
:
10119 return reloc_type
== 6; /* R_SPARC_DISP32. */
10121 return reloc_type
== 13; /* R_SPU_REL32. */
10123 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
10125 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
10129 return reloc_type
== 2; /* R_X86_64_PC32. */
10130 case EM_XTENSA_OLD
:
10132 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
10134 /* Do not abort or issue an error message here. Not all targets use
10135 pc-relative 32-bit relocs in their DWARF debug information and we
10136 have already tested for target coverage in is_32bit_abs_reloc. A
10137 more helpful warning message will be generated by apply_relocations
10138 anyway, so just return. */
10143 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10144 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10147 is_64bit_abs_reloc (unsigned int reloc_type
)
10149 switch (elf_header
.e_machine
)
10152 return reloc_type
== 257; /* R_AARCH64_ABS64. */
10154 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
10156 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
10158 return reloc_type
== 80; /* R_PARISC_DIR64. */
10160 return reloc_type
== 38; /* R_PPC64_ADDR64. */
10161 case EM_SPARC32PLUS
:
10164 return reloc_type
== 54; /* R_SPARC_UA64. */
10168 return reloc_type
== 1; /* R_X86_64_64. */
10171 return reloc_type
== 22; /* R_S390_64. */
10173 return reloc_type
== 1; /* R_TILEGX_64. */
10175 return reloc_type
== 18; /* R_MIPS_64. */
10181 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10182 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10185 is_64bit_pcrel_reloc (unsigned int reloc_type
)
10187 switch (elf_header
.e_machine
)
10190 return reloc_type
== 260; /* R_AARCH64_PREL64. */
10192 return reloc_type
== 11; /* R_ALPHA_SREL64. */
10194 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
10196 return reloc_type
== 72; /* R_PARISC_PCREL64. */
10198 return reloc_type
== 44; /* R_PPC64_REL64. */
10199 case EM_SPARC32PLUS
:
10202 return reloc_type
== 46; /* R_SPARC_DISP64. */
10206 return reloc_type
== 24; /* R_X86_64_PC64. */
10209 return reloc_type
== 23; /* R_S390_PC64. */
10211 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
10217 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10218 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10221 is_24bit_abs_reloc (unsigned int reloc_type
)
10223 switch (elf_header
.e_machine
)
10225 case EM_CYGNUS_MN10200
:
10227 return reloc_type
== 4; /* R_MN10200_24. */
10233 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10234 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10237 is_16bit_abs_reloc (unsigned int reloc_type
)
10239 switch (elf_header
.e_machine
)
10243 return reloc_type
== 4; /* R_AVR_16. */
10244 case EM_ADAPTEVA_EPIPHANY
:
10245 return reloc_type
== 5;
10246 case EM_CYGNUS_D10V
:
10248 return reloc_type
== 3; /* R_D10V_16. */
10252 return reloc_type
== R_H8_DIR16
;
10255 return reloc_type
== 1; /* R_IP2K_16. */
10258 return reloc_type
== 1; /* R_M32C_16 */
10259 case EM_MSP430_OLD
:
10261 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
10262 case EM_ALTERA_NIOS2
:
10264 return reloc_type
== 9; /* R_NIOS_16. */
10266 return reloc_type
== 2; /* R_C6000_ABS16. */
10269 return reloc_type
== 2; /* R_XC16C_ABS_16. */
10270 case EM_CYGNUS_MN10200
:
10272 return reloc_type
== 2; /* R_MN10200_16. */
10273 case EM_CYGNUS_MN10300
:
10275 return reloc_type
== 2; /* R_MN10300_16. */
10277 return reloc_type
== 3; /* R_XGATE_16. */
10283 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10284 relocation entries (possibly formerly used for SHT_GROUP sections). */
10287 is_none_reloc (unsigned int reloc_type
)
10289 switch (elf_header
.e_machine
)
10291 case EM_68K
: /* R_68K_NONE. */
10292 case EM_386
: /* R_386_NONE. */
10293 case EM_SPARC32PLUS
:
10295 case EM_SPARC
: /* R_SPARC_NONE. */
10296 case EM_MIPS
: /* R_MIPS_NONE. */
10297 case EM_PARISC
: /* R_PARISC_NONE. */
10298 case EM_ALPHA
: /* R_ALPHA_NONE. */
10299 case EM_ADAPTEVA_EPIPHANY
:
10300 case EM_PPC
: /* R_PPC_NONE. */
10301 case EM_PPC64
: /* R_PPC64_NONE. */
10302 case EM_ARM
: /* R_ARM_NONE. */
10303 case EM_IA_64
: /* R_IA64_NONE. */
10304 case EM_SH
: /* R_SH_NONE. */
10306 case EM_S390
: /* R_390_NONE. */
10307 case EM_CRIS
: /* R_CRIS_NONE. */
10308 case EM_X86_64
: /* R_X86_64_NONE. */
10309 case EM_L1OM
: /* R_X86_64_NONE. */
10310 case EM_K1OM
: /* R_X86_64_NONE. */
10311 case EM_MN10300
: /* R_MN10300_NONE. */
10312 case EM_MOXIE
: /* R_MOXIE_NONE. */
10313 case EM_M32R
: /* R_M32R_NONE. */
10314 case EM_TI_C6000
:/* R_C6000_NONE. */
10315 case EM_TILEGX
: /* R_TILEGX_NONE. */
10316 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
10318 case EM_C166
: /* R_XC16X_NONE. */
10319 return reloc_type
== 0;
10321 return reloc_type
== 0 || reloc_type
== 256;
10322 case EM_XTENSA_OLD
:
10324 return (reloc_type
== 0 /* R_XTENSA_NONE. */
10325 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
10326 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
10327 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
10332 /* Apply relocations to a section.
10333 Note: So far support has been added only for those relocations
10334 which can be found in debug sections.
10335 FIXME: Add support for more relocations ? */
10338 apply_relocations (void * file
,
10339 Elf_Internal_Shdr
* section
,
10340 unsigned char * start
)
10342 Elf_Internal_Shdr
* relsec
;
10343 unsigned char * end
= start
+ section
->sh_size
;
10345 if (elf_header
.e_type
!= ET_REL
)
10348 /* Find the reloc section associated with the section. */
10349 for (relsec
= section_headers
;
10350 relsec
< section_headers
+ elf_header
.e_shnum
;
10353 bfd_boolean is_rela
;
10354 unsigned long num_relocs
;
10355 Elf_Internal_Rela
* relocs
;
10356 Elf_Internal_Rela
* rp
;
10357 Elf_Internal_Shdr
* symsec
;
10358 Elf_Internal_Sym
* symtab
;
10359 unsigned long num_syms
;
10360 Elf_Internal_Sym
* sym
;
10362 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10363 || relsec
->sh_info
>= elf_header
.e_shnum
10364 || section_headers
+ relsec
->sh_info
!= section
10365 || relsec
->sh_size
== 0
10366 || relsec
->sh_link
>= elf_header
.e_shnum
)
10369 is_rela
= relsec
->sh_type
== SHT_RELA
;
10373 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
10374 relsec
->sh_size
, & relocs
, & num_relocs
))
10379 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
10380 relsec
->sh_size
, & relocs
, & num_relocs
))
10384 /* SH uses RELA but uses in place value instead of the addend field. */
10385 if (elf_header
.e_machine
== EM_SH
)
10388 symsec
= section_headers
+ relsec
->sh_link
;
10389 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
10391 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
10394 unsigned int reloc_type
;
10395 unsigned int reloc_size
;
10396 unsigned char * rloc
;
10397 unsigned long sym_index
;
10399 reloc_type
= get_reloc_type (rp
->r_info
);
10401 if (target_specific_reloc_handling (rp
, start
, symtab
))
10403 else if (is_none_reloc (reloc_type
))
10405 else if (is_32bit_abs_reloc (reloc_type
)
10406 || is_32bit_pcrel_reloc (reloc_type
))
10408 else if (is_64bit_abs_reloc (reloc_type
)
10409 || is_64bit_pcrel_reloc (reloc_type
))
10411 else if (is_24bit_abs_reloc (reloc_type
))
10413 else if (is_16bit_abs_reloc (reloc_type
))
10417 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10418 reloc_type
, SECTION_NAME (section
));
10422 rloc
= start
+ rp
->r_offset
;
10423 if ((rloc
+ reloc_size
) > end
)
10425 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10426 (unsigned long) rp
->r_offset
,
10427 SECTION_NAME (section
));
10431 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
10432 if (sym_index
>= num_syms
)
10434 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10435 sym_index
, SECTION_NAME (section
));
10438 sym
= symtab
+ sym_index
;
10440 /* If the reloc has a symbol associated with it,
10441 make sure that it is of an appropriate type.
10443 Relocations against symbols without type can happen.
10444 Gcc -feliminate-dwarf2-dups may generate symbols
10445 without type for debug info.
10447 Icc generates relocations against function symbols
10448 instead of local labels.
10450 Relocations against object symbols can happen, eg when
10451 referencing a global array. For an example of this see
10452 the _clz.o binary in libgcc.a. */
10454 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
10456 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10457 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
10458 (long int)(rp
- relocs
),
10459 SECTION_NAME (relsec
));
10465 addend
+= rp
->r_addend
;
10466 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10467 partial_inplace. */
10469 || (elf_header
.e_machine
== EM_XTENSA
10470 && reloc_type
== 1)
10471 || ((elf_header
.e_machine
== EM_PJ
10472 || elf_header
.e_machine
== EM_PJ_OLD
)
10473 && reloc_type
== 1)
10474 || ((elf_header
.e_machine
== EM_D30V
10475 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
10476 && reloc_type
== 12))
10477 addend
+= byte_get (rloc
, reloc_size
);
10479 if (is_32bit_pcrel_reloc (reloc_type
)
10480 || is_64bit_pcrel_reloc (reloc_type
))
10482 /* On HPPA, all pc-relative relocations are biased by 8. */
10483 if (elf_header
.e_machine
== EM_PARISC
)
10485 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
10489 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
10498 #ifdef SUPPORT_DISASSEMBLY
10500 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
10502 printf (_("\nAssembly dump of section %s\n"),
10503 SECTION_NAME (section
));
10505 /* XXX -- to be done --- XXX */
10511 /* Reads in the contents of SECTION from FILE, returning a pointer
10512 to a malloc'ed buffer or NULL if something went wrong. */
10515 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
10517 bfd_size_type num_bytes
;
10519 num_bytes
= section
->sh_size
;
10521 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
10523 printf (_("\nSection '%s' has no data to dump.\n"),
10524 SECTION_NAME (section
));
10528 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
10529 _("section contents"));
10534 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
10536 Elf_Internal_Shdr
* relsec
;
10537 bfd_size_type num_bytes
;
10541 char * name
= SECTION_NAME (section
);
10542 bfd_boolean some_strings_shown
;
10544 start
= get_section_contents (section
, file
);
10548 printf (_("\nString dump of section '%s':\n"), name
);
10550 /* If the section being dumped has relocations against it the user might
10551 be expecting these relocations to have been applied. Check for this
10552 case and issue a warning message in order to avoid confusion.
10553 FIXME: Maybe we ought to have an option that dumps a section with
10554 relocs applied ? */
10555 for (relsec
= section_headers
;
10556 relsec
< section_headers
+ elf_header
.e_shnum
;
10559 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10560 || relsec
->sh_info
>= elf_header
.e_shnum
10561 || section_headers
+ relsec
->sh_info
!= section
10562 || relsec
->sh_size
== 0
10563 || relsec
->sh_link
>= elf_header
.e_shnum
)
10566 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10570 num_bytes
= section
->sh_size
;
10572 end
= start
+ num_bytes
;
10573 some_strings_shown
= FALSE
;
10577 while (!ISPRINT (* data
))
10578 if (++ data
>= end
)
10584 /* PR 11128: Use two separate invocations in order to work
10585 around bugs in the Solaris 8 implementation of printf. */
10586 printf (" [%6tx] ", data
- start
);
10587 printf ("%s\n", data
);
10589 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
10591 data
+= strlen (data
);
10592 some_strings_shown
= TRUE
;
10596 if (! some_strings_shown
)
10597 printf (_(" No strings found in this section."));
10605 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
10607 bfd_boolean relocate
)
10609 Elf_Internal_Shdr
* relsec
;
10610 bfd_size_type bytes
;
10612 unsigned char * data
;
10613 unsigned char * start
;
10615 start
= (unsigned char *) get_section_contents (section
, file
);
10619 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
10623 apply_relocations (file
, section
, start
);
10627 /* If the section being dumped has relocations against it the user might
10628 be expecting these relocations to have been applied. Check for this
10629 case and issue a warning message in order to avoid confusion.
10630 FIXME: Maybe we ought to have an option that dumps a section with
10631 relocs applied ? */
10632 for (relsec
= section_headers
;
10633 relsec
< section_headers
+ elf_header
.e_shnum
;
10636 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
10637 || relsec
->sh_info
>= elf_header
.e_shnum
10638 || section_headers
+ relsec
->sh_info
!= section
10639 || relsec
->sh_size
== 0
10640 || relsec
->sh_link
>= elf_header
.e_shnum
)
10643 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10648 addr
= section
->sh_addr
;
10649 bytes
= section
->sh_size
;
10658 lbytes
= (bytes
> 16 ? 16 : bytes
);
10660 printf (" 0x%8.8lx ", (unsigned long) addr
);
10662 for (j
= 0; j
< 16; j
++)
10665 printf ("%2.2x", data
[j
]);
10673 for (j
= 0; j
< lbytes
; j
++)
10676 if (k
>= ' ' && k
< 0x7f)
10694 /* Uncompresses a section that was compressed using zlib, in place. */
10697 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
10698 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
10700 #ifndef HAVE_ZLIB_H
10703 dwarf_size_type compressed_size
= *size
;
10704 unsigned char * compressed_buffer
= *buffer
;
10705 dwarf_size_type uncompressed_size
;
10706 unsigned char * uncompressed_buffer
;
10709 dwarf_size_type header_size
= 12;
10711 /* Read the zlib header. In this case, it should be "ZLIB" followed
10712 by the uncompressed section size, 8 bytes in big-endian order. */
10713 if (compressed_size
< header_size
10714 || ! streq ((char *) compressed_buffer
, "ZLIB"))
10717 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
10718 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
10719 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
10720 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
10721 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
10722 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
10723 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
10724 uncompressed_size
+= compressed_buffer
[11];
10726 /* It is possible the section consists of several compressed
10727 buffers concatenated together, so we uncompress in a loop. */
10728 strm
.zalloc
= NULL
;
10730 strm
.opaque
= NULL
;
10731 strm
.avail_in
= compressed_size
- header_size
;
10732 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
10733 strm
.avail_out
= uncompressed_size
;
10734 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
10736 rc
= inflateInit (& strm
);
10737 while (strm
.avail_in
> 0)
10741 strm
.next_out
= ((Bytef
*) uncompressed_buffer
10742 + (uncompressed_size
- strm
.avail_out
));
10743 rc
= inflate (&strm
, Z_FINISH
);
10744 if (rc
!= Z_STREAM_END
)
10746 rc
= inflateReset (& strm
);
10748 rc
= inflateEnd (& strm
);
10750 || strm
.avail_out
!= 0)
10753 free (compressed_buffer
);
10754 *buffer
= uncompressed_buffer
;
10755 *size
= uncompressed_size
;
10759 free (uncompressed_buffer
);
10760 /* Indicate decompression failure. */
10763 #endif /* HAVE_ZLIB_H */
10767 load_specific_debug_section (enum dwarf_section_display_enum debug
,
10768 Elf_Internal_Shdr
* sec
, void * file
)
10770 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10773 /* If it is already loaded, do nothing. */
10774 if (section
->start
!= NULL
)
10777 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
10778 section
->address
= sec
->sh_addr
;
10779 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
10781 sec
->sh_size
, buf
);
10782 if (section
->start
== NULL
)
10786 section
->size
= sec
->sh_size
;
10787 if (uncompress_section_contents (§ion
->start
, §ion
->size
))
10788 sec
->sh_size
= section
->size
;
10791 if (section
->start
== NULL
)
10794 if (debug_displays
[debug
].relocate
)
10795 apply_relocations ((FILE *) file
, sec
, section
->start
);
10800 /* If this is not NULL, load_debug_section will only look for sections
10801 within the list of sections given here. */
10802 unsigned int *section_subset
= NULL
;
10805 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
10807 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10808 Elf_Internal_Shdr
* sec
;
10810 /* Locate the debug section. */
10811 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
10813 section
->name
= section
->uncompressed_name
;
10816 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
10818 section
->name
= section
->compressed_name
;
10823 /* If we're loading from a subset of sections, and we've loaded
10824 a section matching this name before, it's likely that it's a
10826 if (section_subset
!= NULL
)
10827 free_debug_section (debug
);
10829 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
10833 free_debug_section (enum dwarf_section_display_enum debug
)
10835 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10837 if (section
->start
== NULL
)
10840 free ((char *) section
->start
);
10841 section
->start
= NULL
;
10842 section
->address
= 0;
10847 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
10849 char * name
= SECTION_NAME (section
);
10850 bfd_size_type length
;
10854 length
= section
->sh_size
;
10857 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10860 if (section
->sh_type
== SHT_NOBITS
)
10862 /* There is no point in dumping the contents of a debugging section
10863 which has the NOBITS type - the bits in the file will be random.
10864 This can happen when a file containing a .eh_frame section is
10865 stripped with the --only-keep-debug command line option. */
10866 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10870 if (const_strneq (name
, ".gnu.linkonce.wi."))
10871 name
= ".debug_info";
10873 /* See if we know how to display the contents of this section. */
10874 for (i
= 0; i
< max
; i
++)
10875 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10876 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10878 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10879 int secondary
= (section
!= find_section (name
));
10882 free_debug_section ((enum dwarf_section_display_enum
) i
);
10884 if (streq (sec
->uncompressed_name
, name
))
10885 sec
->name
= sec
->uncompressed_name
;
10887 sec
->name
= sec
->compressed_name
;
10888 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10891 /* If this debug section is part of a CU/TU set in a .dwp file,
10892 restrict load_debug_section to the sections in that set. */
10893 section_subset
= find_cu_tu_set (file
, shndx
);
10895 result
&= debug_displays
[i
].display (sec
, file
);
10897 section_subset
= NULL
;
10899 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10900 free_debug_section ((enum dwarf_section_display_enum
) i
);
10908 printf (_("Unrecognized debug section: %s\n"), name
);
10915 /* Set DUMP_SECTS for all sections where dumps were requested
10916 based on section name. */
10919 initialise_dumps_byname (void)
10921 struct dump_list_entry
* cur
;
10923 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10928 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10929 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10931 request_dump_bynumber (i
, cur
->type
);
10936 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10942 process_section_contents (FILE * file
)
10944 Elf_Internal_Shdr
* section
;
10950 initialise_dumps_byname ();
10952 for (i
= 0, section
= section_headers
;
10953 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10956 #ifdef SUPPORT_DISASSEMBLY
10957 if (dump_sects
[i
] & DISASS_DUMP
)
10958 disassemble_section (section
, file
);
10960 if (dump_sects
[i
] & HEX_DUMP
)
10961 dump_section_as_bytes (section
, file
, FALSE
);
10963 if (dump_sects
[i
] & RELOC_DUMP
)
10964 dump_section_as_bytes (section
, file
, TRUE
);
10966 if (dump_sects
[i
] & STRING_DUMP
)
10967 dump_section_as_strings (section
, file
);
10969 if (dump_sects
[i
] & DEBUG_DUMP
)
10970 display_debug_section (i
, section
, file
);
10973 /* Check to see if the user requested a
10974 dump of a section that does not exist. */
10975 while (i
++ < num_dump_sects
)
10977 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10981 process_mips_fpe_exception (int mask
)
10986 if (mask
& OEX_FPU_INEX
)
10987 fputs ("INEX", stdout
), first
= 0;
10988 if (mask
& OEX_FPU_UFLO
)
10989 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10990 if (mask
& OEX_FPU_OFLO
)
10991 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10992 if (mask
& OEX_FPU_DIV0
)
10993 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10994 if (mask
& OEX_FPU_INVAL
)
10995 printf ("%sINVAL", first
? "" : "|");
10998 fputs ("0", stdout
);
11001 /* ARM EABI attributes section. */
11006 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11008 const char ** table
;
11009 } arm_attr_public_tag
;
11011 static const char * arm_attr_tag_CPU_arch
[] =
11012 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11013 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11014 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
11015 static const char * arm_attr_tag_THUMB_ISA_use
[] =
11016 {"No", "Thumb-1", "Thumb-2"};
11017 static const char * arm_attr_tag_FP_arch
[] =
11018 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11020 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
11021 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
11022 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11023 static const char * arm_attr_tag_PCS_config
[] =
11024 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11025 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11026 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
11027 {"V6", "SB", "TLS", "Unused"};
11028 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
11029 {"Absolute", "PC-relative", "SB-relative", "None"};
11030 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
11031 {"Absolute", "PC-relative", "None"};
11032 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
11033 {"None", "direct", "GOT-indirect"};
11034 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
11035 {"None", "??? 1", "2", "??? 3", "4"};
11036 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
11037 static const char * arm_attr_tag_ABI_FP_denormal
[] =
11038 {"Unused", "Needed", "Sign only"};
11039 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
11040 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
11041 static const char * arm_attr_tag_ABI_FP_number_model
[] =
11042 {"Unused", "Finite", "RTABI", "IEEE 754"};
11043 static const char * arm_attr_tag_ABI_enum_size
[] =
11044 {"Unused", "small", "int", "forced to int"};
11045 static const char * arm_attr_tag_ABI_HardFP_use
[] =
11046 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11047 static const char * arm_attr_tag_ABI_VFP_args
[] =
11048 {"AAPCS", "VFP registers", "custom"};
11049 static const char * arm_attr_tag_ABI_WMMX_args
[] =
11050 {"AAPCS", "WMMX registers", "custom"};
11051 static const char * arm_attr_tag_ABI_optimization_goals
[] =
11052 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11053 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11054 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
11055 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11056 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11057 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
11058 static const char * arm_attr_tag_FP_HP_extension
[] =
11059 {"Not Allowed", "Allowed"};
11060 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
11061 {"None", "IEEE 754", "Alternative Format"};
11062 static const char * arm_attr_tag_MPextension_use
[] =
11063 {"Not Allowed", "Allowed"};
11064 static const char * arm_attr_tag_DIV_use
[] =
11065 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11066 "Allowed in v7-A with integer division extension"};
11067 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
11068 static const char * arm_attr_tag_Virtualization_use
[] =
11069 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11070 "TrustZone and Virtualization Extensions"};
11071 static const char * arm_attr_tag_MPextension_use_legacy
[] =
11072 {"Not Allowed", "Allowed"};
11074 #define LOOKUP(id, name) \
11075 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11076 static arm_attr_public_tag arm_attr_public_tags
[] =
11078 {4, "CPU_raw_name", 1, NULL
},
11079 {5, "CPU_name", 1, NULL
},
11080 LOOKUP(6, CPU_arch
),
11081 {7, "CPU_arch_profile", 0, NULL
},
11082 LOOKUP(8, ARM_ISA_use
),
11083 LOOKUP(9, THUMB_ISA_use
),
11084 LOOKUP(10, FP_arch
),
11085 LOOKUP(11, WMMX_arch
),
11086 LOOKUP(12, Advanced_SIMD_arch
),
11087 LOOKUP(13, PCS_config
),
11088 LOOKUP(14, ABI_PCS_R9_use
),
11089 LOOKUP(15, ABI_PCS_RW_data
),
11090 LOOKUP(16, ABI_PCS_RO_data
),
11091 LOOKUP(17, ABI_PCS_GOT_use
),
11092 LOOKUP(18, ABI_PCS_wchar_t
),
11093 LOOKUP(19, ABI_FP_rounding
),
11094 LOOKUP(20, ABI_FP_denormal
),
11095 LOOKUP(21, ABI_FP_exceptions
),
11096 LOOKUP(22, ABI_FP_user_exceptions
),
11097 LOOKUP(23, ABI_FP_number_model
),
11098 {24, "ABI_align_needed", 0, NULL
},
11099 {25, "ABI_align_preserved", 0, NULL
},
11100 LOOKUP(26, ABI_enum_size
),
11101 LOOKUP(27, ABI_HardFP_use
),
11102 LOOKUP(28, ABI_VFP_args
),
11103 LOOKUP(29, ABI_WMMX_args
),
11104 LOOKUP(30, ABI_optimization_goals
),
11105 LOOKUP(31, ABI_FP_optimization_goals
),
11106 {32, "compatibility", 0, NULL
},
11107 LOOKUP(34, CPU_unaligned_access
),
11108 LOOKUP(36, FP_HP_extension
),
11109 LOOKUP(38, ABI_FP_16bit_format
),
11110 LOOKUP(42, MPextension_use
),
11111 LOOKUP(44, DIV_use
),
11112 {64, "nodefaults", 0, NULL
},
11113 {65, "also_compatible_with", 0, NULL
},
11114 LOOKUP(66, T2EE_use
),
11115 {67, "conformance", 1, NULL
},
11116 LOOKUP(68, Virtualization_use
),
11117 LOOKUP(70, MPextension_use_legacy
)
11121 static unsigned char *
11122 display_arm_attribute (unsigned char * p
)
11127 arm_attr_public_tag
* attr
;
11131 tag
= read_uleb128 (p
, &len
);
11134 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
11136 if (arm_attr_public_tags
[i
].tag
== tag
)
11138 attr
= &arm_attr_public_tags
[i
];
11145 printf (" Tag_%s: ", attr
->name
);
11146 switch (attr
->type
)
11151 case 7: /* Tag_CPU_arch_profile. */
11152 val
= read_uleb128 (p
, &len
);
11156 case 0: printf (_("None\n")); break;
11157 case 'A': printf (_("Application\n")); break;
11158 case 'R': printf (_("Realtime\n")); break;
11159 case 'M': printf (_("Microcontroller\n")); break;
11160 case 'S': printf (_("Application or Realtime\n")); break;
11161 default: printf ("??? (%d)\n", val
); break;
11165 case 24: /* Tag_align_needed. */
11166 val
= read_uleb128 (p
, &len
);
11170 case 0: printf (_("None\n")); break;
11171 case 1: printf (_("8-byte\n")); break;
11172 case 2: printf (_("4-byte\n")); break;
11173 case 3: printf ("??? 3\n"); break;
11176 printf (_("8-byte and up to %d-byte extended\n"),
11179 printf ("??? (%d)\n", val
);
11184 case 25: /* Tag_align_preserved. */
11185 val
= read_uleb128 (p
, &len
);
11189 case 0: printf (_("None\n")); break;
11190 case 1: printf (_("8-byte, except leaf SP\n")); break;
11191 case 2: printf (_("8-byte\n")); break;
11192 case 3: printf ("??? 3\n"); break;
11195 printf (_("8-byte and up to %d-byte extended\n"),
11198 printf ("??? (%d)\n", val
);
11203 case 32: /* Tag_compatibility. */
11204 val
= read_uleb128 (p
, &len
);
11206 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11207 p
+= strlen ((char *) p
) + 1;
11210 case 64: /* Tag_nodefaults. */
11212 printf (_("True\n"));
11215 case 65: /* Tag_also_compatible_with. */
11216 val
= read_uleb128 (p
, &len
);
11218 if (val
== 6 /* Tag_CPU_arch. */)
11220 val
= read_uleb128 (p
, &len
);
11222 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
11223 printf ("??? (%d)\n", val
);
11225 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
11229 while (*(p
++) != '\0' /* NUL terminator. */);
11243 assert (attr
->type
& 0x80);
11244 val
= read_uleb128 (p
, &len
);
11246 type
= attr
->type
& 0x7f;
11248 printf ("??? (%d)\n", val
);
11250 printf ("%s\n", attr
->table
[val
]);
11257 type
= 1; /* String. */
11259 type
= 2; /* uleb128. */
11260 printf (" Tag_unknown_%d: ", tag
);
11265 printf ("\"%s\"\n", p
);
11266 p
+= strlen ((char *) p
) + 1;
11270 val
= read_uleb128 (p
, &len
);
11272 printf ("%d (0x%x)\n", val
, val
);
11278 static unsigned char *
11279 display_gnu_attribute (unsigned char * p
,
11280 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11287 tag
= read_uleb128 (p
, &len
);
11290 /* Tag_compatibility is the only generic GNU attribute defined at
11294 val
= read_uleb128 (p
, &len
);
11296 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11297 p
+= strlen ((char *) p
) + 1;
11301 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
11302 return display_proc_gnu_attribute (p
, tag
);
11305 type
= 1; /* String. */
11307 type
= 2; /* uleb128. */
11308 printf (" Tag_unknown_%d: ", tag
);
11312 printf ("\"%s\"\n", p
);
11313 p
+= strlen ((char *) p
) + 1;
11317 val
= read_uleb128 (p
, &len
);
11319 printf ("%d (0x%x)\n", val
, val
);
11325 static unsigned char *
11326 display_power_gnu_attribute (unsigned char * p
, int tag
)
11332 if (tag
== Tag_GNU_Power_ABI_FP
)
11334 val
= read_uleb128 (p
, &len
);
11336 printf (" Tag_GNU_Power_ABI_FP: ");
11341 printf (_("Hard or soft float\n"));
11344 printf (_("Hard float\n"));
11347 printf (_("Soft float\n"));
11350 printf (_("Single-precision hard float\n"));
11353 printf ("??? (%d)\n", val
);
11359 if (tag
== Tag_GNU_Power_ABI_Vector
)
11361 val
= read_uleb128 (p
, &len
);
11363 printf (" Tag_GNU_Power_ABI_Vector: ");
11367 printf (_("Any\n"));
11370 printf (_("Generic\n"));
11373 printf ("AltiVec\n");
11379 printf ("??? (%d)\n", val
);
11385 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
11387 val
= read_uleb128 (p
, &len
);
11389 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11393 printf (_("Any\n"));
11396 printf ("r3/r4\n");
11399 printf (_("Memory\n"));
11402 printf ("??? (%d)\n", val
);
11409 type
= 1; /* String. */
11411 type
= 2; /* uleb128. */
11412 printf (" Tag_unknown_%d: ", tag
);
11416 printf ("\"%s\"\n", p
);
11417 p
+= strlen ((char *) p
) + 1;
11421 val
= read_uleb128 (p
, &len
);
11423 printf ("%d (0x%x)\n", val
, val
);
11430 display_sparc_hwcaps (int mask
)
11435 if (mask
& ELF_SPARC_HWCAP_MUL32
)
11436 fputs ("mul32", stdout
), first
= 0;
11437 if (mask
& ELF_SPARC_HWCAP_DIV32
)
11438 printf ("%sdiv32", first
? "" : "|"), first
= 0;
11439 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
11440 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
11441 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
11442 printf ("%sv8plus", first
? "" : "|"), first
= 0;
11443 if (mask
& ELF_SPARC_HWCAP_POPC
)
11444 printf ("%spopc", first
? "" : "|"), first
= 0;
11445 if (mask
& ELF_SPARC_HWCAP_VIS
)
11446 printf ("%svis", first
? "" : "|"), first
= 0;
11447 if (mask
& ELF_SPARC_HWCAP_VIS2
)
11448 printf ("%svis2", first
? "" : "|"), first
= 0;
11449 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
11450 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
11451 if (mask
& ELF_SPARC_HWCAP_FMAF
)
11452 printf ("%sfmaf", first
? "" : "|"), first
= 0;
11453 if (mask
& ELF_SPARC_HWCAP_VIS3
)
11454 printf ("%svis3", first
? "" : "|"), first
= 0;
11455 if (mask
& ELF_SPARC_HWCAP_HPC
)
11456 printf ("%shpc", first
? "" : "|"), first
= 0;
11457 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
11458 printf ("%srandom", first
? "" : "|"), first
= 0;
11459 if (mask
& ELF_SPARC_HWCAP_TRANS
)
11460 printf ("%strans", first
? "" : "|"), first
= 0;
11461 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
11462 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
11463 if (mask
& ELF_SPARC_HWCAP_IMA
)
11464 printf ("%sima", first
? "" : "|"), first
= 0;
11465 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
11466 printf ("%scspare", first
? "" : "|"), first
= 0;
11469 fputc('0', stdout
);
11470 fputc('\n', stdout
);
11473 static unsigned char *
11474 display_sparc_gnu_attribute (unsigned char * p
, int tag
)
11480 if (tag
== Tag_GNU_Sparc_HWCAPS
)
11482 val
= read_uleb128 (p
, &len
);
11484 printf (" Tag_GNU_Sparc_HWCAPS: ");
11486 display_sparc_hwcaps (val
);
11491 type
= 1; /* String. */
11493 type
= 2; /* uleb128. */
11494 printf (" Tag_unknown_%d: ", tag
);
11498 printf ("\"%s\"\n", p
);
11499 p
+= strlen ((char *) p
) + 1;
11503 val
= read_uleb128 (p
, &len
);
11505 printf ("%d (0x%x)\n", val
, val
);
11511 static unsigned char *
11512 display_mips_gnu_attribute (unsigned char * p
, int tag
)
11518 if (tag
== Tag_GNU_MIPS_ABI_FP
)
11520 val
= read_uleb128 (p
, &len
);
11522 printf (" Tag_GNU_MIPS_ABI_FP: ");
11527 printf (_("Hard or soft float\n"));
11530 printf (_("Hard float (double precision)\n"));
11533 printf (_("Hard float (single precision)\n"));
11536 printf (_("Soft float\n"));
11539 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11542 printf ("??? (%d)\n", val
);
11549 type
= 1; /* String. */
11551 type
= 2; /* uleb128. */
11552 printf (" Tag_unknown_%d: ", tag
);
11556 printf ("\"%s\"\n", p
);
11557 p
+= strlen ((char *) p
) + 1;
11561 val
= read_uleb128 (p
, &len
);
11563 printf ("%d (0x%x)\n", val
, val
);
11569 static unsigned char *
11570 display_tic6x_attribute (unsigned char * p
)
11576 tag
= read_uleb128 (p
, &len
);
11582 val
= read_uleb128 (p
, &len
);
11584 printf (" Tag_ISA: ");
11588 case C6XABI_Tag_ISA_none
:
11589 printf (_("None\n"));
11591 case C6XABI_Tag_ISA_C62X
:
11594 case C6XABI_Tag_ISA_C67X
:
11597 case C6XABI_Tag_ISA_C67XP
:
11598 printf ("C67x+\n");
11600 case C6XABI_Tag_ISA_C64X
:
11603 case C6XABI_Tag_ISA_C64XP
:
11604 printf ("C64x+\n");
11606 case C6XABI_Tag_ISA_C674X
:
11607 printf ("C674x\n");
11610 printf ("??? (%d)\n", val
);
11615 case Tag_ABI_wchar_t
:
11616 val
= read_uleb128 (p
, &len
);
11618 printf (" Tag_ABI_wchar_t: ");
11622 printf (_("Not used\n"));
11625 printf (_("2 bytes\n"));
11628 printf (_("4 bytes\n"));
11631 printf ("??? (%d)\n", val
);
11636 case Tag_ABI_stack_align_needed
:
11637 val
= read_uleb128 (p
, &len
);
11639 printf (" Tag_ABI_stack_align_needed: ");
11643 printf (_("8-byte\n"));
11646 printf (_("16-byte\n"));
11649 printf ("??? (%d)\n", val
);
11654 case Tag_ABI_stack_align_preserved
:
11655 val
= read_uleb128 (p
, &len
);
11657 printf (" Tag_ABI_stack_align_preserved: ");
11661 printf (_("8-byte\n"));
11664 printf (_("16-byte\n"));
11667 printf ("??? (%d)\n", val
);
11673 val
= read_uleb128 (p
, &len
);
11675 printf (" Tag_ABI_DSBT: ");
11679 printf (_("DSBT addressing not used\n"));
11682 printf (_("DSBT addressing used\n"));
11685 printf ("??? (%d)\n", val
);
11691 val
= read_uleb128 (p
, &len
);
11693 printf (" Tag_ABI_PID: ");
11697 printf (_("Data addressing position-dependent\n"));
11700 printf (_("Data addressing position-independent, GOT near DP\n"));
11703 printf (_("Data addressing position-independent, GOT far from DP\n"));
11706 printf ("??? (%d)\n", val
);
11712 val
= read_uleb128 (p
, &len
);
11714 printf (" Tag_ABI_PIC: ");
11718 printf (_("Code addressing position-dependent\n"));
11721 printf (_("Code addressing position-independent\n"));
11724 printf ("??? (%d)\n", val
);
11729 case Tag_ABI_array_object_alignment
:
11730 val
= read_uleb128 (p
, &len
);
11732 printf (" Tag_ABI_array_object_alignment: ");
11736 printf (_("8-byte\n"));
11739 printf (_("4-byte\n"));
11742 printf (_("16-byte\n"));
11745 printf ("??? (%d)\n", val
);
11750 case Tag_ABI_array_object_align_expected
:
11751 val
= read_uleb128 (p
, &len
);
11753 printf (" Tag_ABI_array_object_align_expected: ");
11757 printf (_("8-byte\n"));
11760 printf (_("4-byte\n"));
11763 printf (_("16-byte\n"));
11766 printf ("??? (%d)\n", val
);
11771 case Tag_ABI_compatibility
:
11772 val
= read_uleb128 (p
, &len
);
11774 printf (" Tag_ABI_compatibility: ");
11775 printf (_("flag = %d, vendor = %s\n"), val
, p
);
11776 p
+= strlen ((char *) p
) + 1;
11779 case Tag_ABI_conformance
:
11780 printf (" Tag_ABI_conformance: ");
11781 printf ("\"%s\"\n", p
);
11782 p
+= strlen ((char *) p
) + 1;
11786 printf (" Tag_unknown_%d: ", tag
);
11790 printf ("\"%s\"\n", p
);
11791 p
+= strlen ((char *) p
) + 1;
11795 val
= read_uleb128 (p
, &len
);
11797 printf ("%d (0x%x)\n", val
, val
);
11804 process_attributes (FILE * file
,
11805 const char * public_name
,
11806 unsigned int proc_type
,
11807 unsigned char * (* display_pub_attribute
) (unsigned char *),
11808 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
11810 Elf_Internal_Shdr
* sect
;
11811 unsigned char * contents
;
11813 unsigned char * end
;
11814 bfd_vma section_len
;
11818 /* Find the section header so that we get the size. */
11819 for (i
= 0, sect
= section_headers
;
11820 i
< elf_header
.e_shnum
;
11823 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
11826 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
11827 sect
->sh_size
, _("attributes"));
11828 if (contents
== NULL
)
11834 len
= sect
->sh_size
- 1;
11840 bfd_boolean public_section
;
11841 bfd_boolean gnu_section
;
11843 section_len
= byte_get (p
, 4);
11846 if (section_len
> len
)
11848 printf (_("ERROR: Bad section length (%d > %d)\n"),
11849 (int) section_len
, (int) len
);
11853 len
-= section_len
;
11854 printf (_("Attribute Section: %s\n"), p
);
11856 if (public_name
&& streq ((char *) p
, public_name
))
11857 public_section
= TRUE
;
11859 public_section
= FALSE
;
11861 if (streq ((char *) p
, "gnu"))
11862 gnu_section
= TRUE
;
11864 gnu_section
= FALSE
;
11866 namelen
= strlen ((char *) p
) + 1;
11868 section_len
-= namelen
+ 4;
11870 while (section_len
> 0)
11876 size
= byte_get (p
, 4);
11877 if (size
> section_len
)
11879 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11880 (int) size
, (int) section_len
);
11881 size
= section_len
;
11884 section_len
-= size
;
11885 end
= p
+ size
- 1;
11891 printf (_("File Attributes\n"));
11894 printf (_("Section Attributes:"));
11897 printf (_("Symbol Attributes:"));
11903 val
= read_uleb128 (p
, &j
);
11907 printf (" %d", val
);
11912 printf (_("Unknown tag: %d\n"), tag
);
11913 public_section
= FALSE
;
11917 if (public_section
)
11920 p
= display_pub_attribute (p
);
11922 else if (gnu_section
)
11925 p
= display_gnu_attribute (p
,
11926 display_proc_gnu_attribute
);
11930 /* ??? Do something sensible, like dump hex. */
11931 printf (_(" Unknown section contexts\n"));
11938 printf (_("Unknown format '%c'\n"), *p
);
11946 process_arm_specific (FILE * file
)
11948 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
11949 display_arm_attribute
, NULL
);
11953 process_power_specific (FILE * file
)
11955 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11956 display_power_gnu_attribute
);
11960 process_sparc_specific (FILE * file
)
11962 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
11963 display_sparc_gnu_attribute
);
11967 process_tic6x_specific (FILE * file
)
11969 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
11970 display_tic6x_attribute
, NULL
);
11973 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11974 Print the Address, Access and Initial fields of an entry at VMA ADDR
11975 and return the VMA of the next entry. */
11978 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
11981 print_vma (addr
, LONG_HEX
);
11983 if (addr
< pltgot
+ 0xfff0)
11984 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
11986 printf ("%10s", "");
11989 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
11994 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
11995 print_vma (entry
, LONG_HEX
);
11997 return addr
+ (is_32bit_elf
? 4 : 8);
12000 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12001 PLTGOT. Print the Address and Initial fields of an entry at VMA
12002 ADDR and return the VMA of the next entry. */
12005 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
12008 print_vma (addr
, LONG_HEX
);
12011 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
12016 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
12017 print_vma (entry
, LONG_HEX
);
12019 return addr
+ (is_32bit_elf
? 4 : 8);
12023 process_mips_specific (FILE * file
)
12025 Elf_Internal_Dyn
* entry
;
12026 size_t liblist_offset
= 0;
12027 size_t liblistno
= 0;
12028 size_t conflictsno
= 0;
12029 size_t options_offset
= 0;
12030 size_t conflicts_offset
= 0;
12031 size_t pltrelsz
= 0;
12033 bfd_vma pltgot
= 0;
12034 bfd_vma mips_pltgot
= 0;
12035 bfd_vma jmprel
= 0;
12036 bfd_vma local_gotno
= 0;
12037 bfd_vma gotsym
= 0;
12038 bfd_vma symtabno
= 0;
12040 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
12041 display_mips_gnu_attribute
);
12043 /* We have a lot of special sections. Thanks SGI! */
12044 if (dynamic_section
== NULL
)
12045 /* No information available. */
12048 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
12049 switch (entry
->d_tag
)
12051 case DT_MIPS_LIBLIST
:
12053 = offset_from_vma (file
, entry
->d_un
.d_val
,
12054 liblistno
* sizeof (Elf32_External_Lib
));
12056 case DT_MIPS_LIBLISTNO
:
12057 liblistno
= entry
->d_un
.d_val
;
12059 case DT_MIPS_OPTIONS
:
12060 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
12062 case DT_MIPS_CONFLICT
:
12064 = offset_from_vma (file
, entry
->d_un
.d_val
,
12065 conflictsno
* sizeof (Elf32_External_Conflict
));
12067 case DT_MIPS_CONFLICTNO
:
12068 conflictsno
= entry
->d_un
.d_val
;
12071 pltgot
= entry
->d_un
.d_ptr
;
12073 case DT_MIPS_LOCAL_GOTNO
:
12074 local_gotno
= entry
->d_un
.d_val
;
12076 case DT_MIPS_GOTSYM
:
12077 gotsym
= entry
->d_un
.d_val
;
12079 case DT_MIPS_SYMTABNO
:
12080 symtabno
= entry
->d_un
.d_val
;
12082 case DT_MIPS_PLTGOT
:
12083 mips_pltgot
= entry
->d_un
.d_ptr
;
12086 pltrel
= entry
->d_un
.d_val
;
12089 pltrelsz
= entry
->d_un
.d_val
;
12092 jmprel
= entry
->d_un
.d_ptr
;
12098 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
12100 Elf32_External_Lib
* elib
;
12103 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
12105 sizeof (Elf32_External_Lib
),
12106 _("liblist section data"));
12109 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12110 (unsigned long) liblistno
);
12111 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12114 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
12121 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12122 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12123 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12124 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12125 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12127 tmp
= gmtime (&atime
);
12128 snprintf (timebuf
, sizeof (timebuf
),
12129 "%04u-%02u-%02uT%02u:%02u:%02u",
12130 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12131 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12133 printf ("%3lu: ", (unsigned long) cnt
);
12134 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
12135 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
12137 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
12138 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
12139 liblist
.l_version
);
12141 if (liblist
.l_flags
== 0)
12145 static const struct
12152 { " EXACT_MATCH", LL_EXACT_MATCH
},
12153 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
12154 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
12155 { " EXPORTS", LL_EXPORTS
},
12156 { " DELAY_LOAD", LL_DELAY_LOAD
},
12157 { " DELTA", LL_DELTA
}
12159 int flags
= liblist
.l_flags
;
12162 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
12163 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
12165 fputs (l_flags_vals
[fcnt
].name
, stdout
);
12166 flags
^= l_flags_vals
[fcnt
].bit
;
12169 printf (" %#x", (unsigned int) flags
);
12179 if (options_offset
!= 0)
12181 Elf_External_Options
* eopt
;
12182 Elf_Internal_Shdr
* sect
= section_headers
;
12183 Elf_Internal_Options
* iopt
;
12184 Elf_Internal_Options
* option
;
12188 /* Find the section header so that we get the size. */
12189 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
12192 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
12193 sect
->sh_size
, _("options"));
12196 iopt
= (Elf_Internal_Options
*)
12197 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
12200 error (_("Out of memory\n"));
12207 while (offset
< sect
->sh_size
)
12209 Elf_External_Options
* eoption
;
12211 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
12213 option
->kind
= BYTE_GET (eoption
->kind
);
12214 option
->size
= BYTE_GET (eoption
->size
);
12215 option
->section
= BYTE_GET (eoption
->section
);
12216 option
->info
= BYTE_GET (eoption
->info
);
12218 offset
+= option
->size
;
12224 printf (_("\nSection '%s' contains %d entries:\n"),
12225 SECTION_NAME (sect
), cnt
);
12233 switch (option
->kind
)
12236 /* This shouldn't happen. */
12237 printf (" NULL %d %lx", option
->section
, option
->info
);
12240 printf (" REGINFO ");
12241 if (elf_header
.e_machine
== EM_MIPS
)
12244 Elf32_External_RegInfo
* ereg
;
12245 Elf32_RegInfo reginfo
;
12247 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
12248 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12249 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12250 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12251 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12252 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12253 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12255 printf ("GPR %08lx GP 0x%lx\n",
12256 reginfo
.ri_gprmask
,
12257 (unsigned long) reginfo
.ri_gp_value
);
12258 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12259 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12260 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12265 Elf64_External_RegInfo
* ereg
;
12266 Elf64_Internal_RegInfo reginfo
;
12268 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
12269 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
12270 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
12271 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
12272 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
12273 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
12274 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
12276 printf ("GPR %08lx GP 0x",
12277 reginfo
.ri_gprmask
);
12278 printf_vma (reginfo
.ri_gp_value
);
12281 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12282 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
12283 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
12287 case ODK_EXCEPTIONS
:
12288 fputs (" EXCEPTIONS fpe_min(", stdout
);
12289 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
12290 fputs (") fpe_max(", stdout
);
12291 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
12292 fputs (")", stdout
);
12294 if (option
->info
& OEX_PAGE0
)
12295 fputs (" PAGE0", stdout
);
12296 if (option
->info
& OEX_SMM
)
12297 fputs (" SMM", stdout
);
12298 if (option
->info
& OEX_FPDBUG
)
12299 fputs (" FPDBUG", stdout
);
12300 if (option
->info
& OEX_DISMISS
)
12301 fputs (" DISMISS", stdout
);
12304 fputs (" PAD ", stdout
);
12305 if (option
->info
& OPAD_PREFIX
)
12306 fputs (" PREFIX", stdout
);
12307 if (option
->info
& OPAD_POSTFIX
)
12308 fputs (" POSTFIX", stdout
);
12309 if (option
->info
& OPAD_SYMBOL
)
12310 fputs (" SYMBOL", stdout
);
12313 fputs (" HWPATCH ", stdout
);
12314 if (option
->info
& OHW_R4KEOP
)
12315 fputs (" R4KEOP", stdout
);
12316 if (option
->info
& OHW_R8KPFETCH
)
12317 fputs (" R8KPFETCH", stdout
);
12318 if (option
->info
& OHW_R5KEOP
)
12319 fputs (" R5KEOP", stdout
);
12320 if (option
->info
& OHW_R5KCVTL
)
12321 fputs (" R5KCVTL", stdout
);
12324 fputs (" FILL ", stdout
);
12325 /* XXX Print content of info word? */
12328 fputs (" TAGS ", stdout
);
12329 /* XXX Print content of info word? */
12332 fputs (" HWAND ", stdout
);
12333 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12334 fputs (" R4KEOP_CHECKED", stdout
);
12335 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12336 fputs (" R4KEOP_CLEAN", stdout
);
12339 fputs (" HWOR ", stdout
);
12340 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
12341 fputs (" R4KEOP_CHECKED", stdout
);
12342 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
12343 fputs (" R4KEOP_CLEAN", stdout
);
12346 printf (" GP_GROUP %#06lx self-contained %#06lx",
12347 option
->info
& OGP_GROUP
,
12348 (option
->info
& OGP_SELF
) >> 16);
12351 printf (" IDENT %#06lx self-contained %#06lx",
12352 option
->info
& OGP_GROUP
,
12353 (option
->info
& OGP_SELF
) >> 16);
12356 /* This shouldn't happen. */
12357 printf (" %3d ??? %d %lx",
12358 option
->kind
, option
->section
, option
->info
);
12362 len
= sizeof (* eopt
);
12363 while (len
< option
->size
)
12364 if (((char *) option
)[len
] >= ' '
12365 && ((char *) option
)[len
] < 0x7f)
12366 printf ("%c", ((char *) option
)[len
++]);
12368 printf ("\\%03o", ((char *) option
)[len
++]);
12370 fputs ("\n", stdout
);
12378 if (conflicts_offset
!= 0 && conflictsno
!= 0)
12380 Elf32_Conflict
* iconf
;
12383 if (dynamic_symbols
== NULL
)
12385 error (_("conflict list found without a dynamic symbol table\n"));
12389 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
12392 error (_("Out of memory\n"));
12398 Elf32_External_Conflict
* econf32
;
12400 econf32
= (Elf32_External_Conflict
*)
12401 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12402 sizeof (* econf32
), _("conflict"));
12406 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12407 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
12413 Elf64_External_Conflict
* econf64
;
12415 econf64
= (Elf64_External_Conflict
*)
12416 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
12417 sizeof (* econf64
), _("conflict"));
12421 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12422 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
12427 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12428 (unsigned long) conflictsno
);
12429 puts (_(" Num: Index Value Name"));
12431 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
12433 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
12435 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
12436 print_vma (psym
->st_value
, FULL_HEX
);
12438 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12439 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
12441 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12448 if (pltgot
!= 0 && local_gotno
!= 0)
12450 bfd_vma ent
, local_end
, global_end
;
12452 unsigned char * data
;
12456 addr_size
= (is_32bit_elf
? 4 : 8);
12457 local_end
= pltgot
+ local_gotno
* addr_size
;
12458 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
12460 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
12461 data
= (unsigned char *) get_data (NULL
, file
, offset
,
12462 global_end
- pltgot
, 1,
12463 _("Global Offset Table data"));
12467 printf (_("\nPrimary GOT:\n"));
12468 printf (_(" Canonical gp value: "));
12469 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
12472 printf (_(" Reserved entries:\n"));
12473 printf (_(" %*s %10s %*s Purpose\n"),
12474 addr_size
* 2, _("Address"), _("Access"),
12475 addr_size
* 2, _("Initial"));
12476 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12477 printf (_(" Lazy resolver\n"));
12479 && (byte_get (data
+ ent
- pltgot
, addr_size
)
12480 >> (addr_size
* 8 - 1)) != 0)
12482 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12483 printf (_(" Module pointer (GNU extension)\n"));
12487 if (ent
< local_end
)
12489 printf (_(" Local entries:\n"));
12490 printf (" %*s %10s %*s\n",
12491 addr_size
* 2, _("Address"), _("Access"),
12492 addr_size
* 2, _("Initial"));
12493 while (ent
< local_end
)
12495 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12501 if (gotsym
< symtabno
)
12505 printf (_(" Global entries:\n"));
12506 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12507 addr_size
* 2, _("Address"),
12509 addr_size
* 2, _("Initial"),
12510 addr_size
* 2, _("Sym.Val."),
12512 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12513 _("Ndx"), _("Name"));
12515 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
12516 for (i
= gotsym
; i
< symtabno
; i
++)
12518 Elf_Internal_Sym
* psym
;
12520 psym
= dynamic_symbols
+ i
;
12521 ent
= print_mips_got_entry (data
, pltgot
, ent
);
12523 print_vma (psym
->st_value
, LONG_HEX
);
12524 printf (" %-7s %3s ",
12525 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12526 get_symbol_index_type (psym
->st_shndx
));
12527 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12528 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12530 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12540 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
12543 size_t offset
, rel_offset
;
12544 unsigned long count
, i
;
12545 unsigned char * data
;
12546 int addr_size
, sym_width
;
12547 Elf_Internal_Rela
* rels
;
12549 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
12550 if (pltrel
== DT_RELA
)
12552 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12557 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
12562 addr_size
= (is_32bit_elf
? 4 : 8);
12563 end
= mips_pltgot
+ (2 + count
) * addr_size
;
12565 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
12566 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
12567 1, _("Procedure Linkage Table data"));
12571 printf ("\nPLT GOT:\n\n");
12572 printf (_(" Reserved entries:\n"));
12573 printf (_(" %*s %*s Purpose\n"),
12574 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
12575 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12576 printf (_(" PLT lazy resolver\n"));
12577 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12578 printf (_(" Module pointer\n"));
12581 printf (_(" Entries:\n"));
12582 printf (" %*s %*s %*s %-7s %3s %s\n",
12583 addr_size
* 2, _("Address"),
12584 addr_size
* 2, _("Initial"),
12585 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12586 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
12587 for (i
= 0; i
< count
; i
++)
12589 Elf_Internal_Sym
* psym
;
12591 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
12592 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
12594 print_vma (psym
->st_value
, LONG_HEX
);
12595 printf (" %-7s %3s ",
12596 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
12597 get_symbol_index_type (psym
->st_shndx
));
12598 if (VALID_DYNAMIC_NAME (psym
->st_name
))
12599 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
12601 printf (_("<corrupt: %14ld>"), psym
->st_name
);
12615 process_gnu_liblist (FILE * file
)
12617 Elf_Internal_Shdr
* section
;
12618 Elf_Internal_Shdr
* string_sec
;
12619 Elf32_External_Lib
* elib
;
12621 size_t strtab_size
;
12628 for (i
= 0, section
= section_headers
;
12629 i
< elf_header
.e_shnum
;
12632 switch (section
->sh_type
)
12634 case SHT_GNU_LIBLIST
:
12635 if (section
->sh_link
>= elf_header
.e_shnum
)
12638 elib
= (Elf32_External_Lib
*)
12639 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
12640 _("liblist section data"));
12644 string_sec
= section_headers
+ section
->sh_link
;
12646 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
12647 string_sec
->sh_size
,
12648 _("liblist string table"));
12650 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
12656 strtab_size
= string_sec
->sh_size
;
12658 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12659 SECTION_NAME (section
),
12660 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
12662 puts (_(" Library Time Stamp Checksum Version Flags"));
12664 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
12672 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
12673 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
12674 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
12675 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
12676 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
12678 tmp
= gmtime (&atime
);
12679 snprintf (timebuf
, sizeof (timebuf
),
12680 "%04u-%02u-%02uT%02u:%02u:%02u",
12681 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
12682 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
12684 printf ("%3lu: ", (unsigned long) cnt
);
12686 printf ("%-20s", liblist
.l_name
< strtab_size
12687 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12689 printf ("%-20.20s", liblist
.l_name
< strtab_size
12690 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
12691 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
12692 liblist
.l_version
, liblist
.l_flags
);
12703 static const char *
12704 get_note_type (unsigned e_type
)
12706 static char buff
[64];
12708 if (elf_header
.e_type
== ET_CORE
)
12712 return _("NT_AUXV (auxiliary vector)");
12714 return _("NT_PRSTATUS (prstatus structure)");
12716 return _("NT_FPREGSET (floating point registers)");
12718 return _("NT_PRPSINFO (prpsinfo structure)");
12719 case NT_TASKSTRUCT
:
12720 return _("NT_TASKSTRUCT (task structure)");
12722 return _("NT_PRXFPREG (user_xfpregs structure)");
12724 return _("NT_PPC_VMX (ppc Altivec registers)");
12726 return _("NT_PPC_VSX (ppc VSX registers)");
12728 return _("NT_386_TLS (x86 TLS information)");
12729 case NT_386_IOPERM
:
12730 return _("NT_386_IOPERM (x86 I/O permissions)");
12731 case NT_X86_XSTATE
:
12732 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12733 case NT_S390_HIGH_GPRS
:
12734 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12735 case NT_S390_TIMER
:
12736 return _("NT_S390_TIMER (s390 timer register)");
12737 case NT_S390_TODCMP
:
12738 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12739 case NT_S390_TODPREG
:
12740 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12742 return _("NT_S390_CTRS (s390 control registers)");
12743 case NT_S390_PREFIX
:
12744 return _("NT_S390_PREFIX (s390 prefix register)");
12746 return _("NT_ARM_VFP (arm VFP registers)");
12748 return _("NT_PSTATUS (pstatus structure)");
12750 return _("NT_FPREGS (floating point registers)");
12752 return _("NT_PSINFO (psinfo structure)");
12754 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12756 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12757 case NT_WIN32PSTATUS
:
12758 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12760 return _("NT_SIGINFO (siginfo_t data)");
12762 return _("NT_FILE (mapped files)");
12770 return _("NT_VERSION (version)");
12772 return _("NT_ARCH (architecture)");
12777 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12782 print_core_note (Elf_Internal_Note
*pnote
)
12784 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
12785 bfd_vma count
, page_size
;
12786 unsigned char *descdata
, *filenames
, *descend
;
12788 if (pnote
->type
!= NT_FILE
)
12794 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12795 /* Still "successful". */
12800 if (pnote
->descsz
< 2 * addr_size
)
12802 printf (_(" Malformed note - too short for header\n"));
12806 descdata
= (unsigned char *) pnote
->descdata
;
12807 descend
= descdata
+ pnote
->descsz
;
12809 if (descdata
[pnote
->descsz
- 1] != '\0')
12811 printf (_(" Malformed note - does not end with \\0\n"));
12815 count
= byte_get (descdata
, addr_size
);
12816 descdata
+= addr_size
;
12818 page_size
= byte_get (descdata
, addr_size
);
12819 descdata
+= addr_size
;
12821 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
12823 printf (_(" Malformed note - too short for supplied file count\n"));
12827 printf (_(" Page size: "));
12828 print_vma (page_size
, DEC
);
12831 printf (_(" %*s%*s%*s\n"),
12832 (int) (2 + 2 * addr_size
), _("Start"),
12833 (int) (4 + 2 * addr_size
), _("End"),
12834 (int) (4 + 2 * addr_size
), _("Page Offset"));
12835 filenames
= descdata
+ count
* 3 * addr_size
;
12836 while (--count
> 0)
12838 bfd_vma start
, end
, file_ofs
;
12840 if (filenames
== descend
)
12842 printf (_(" Malformed note - filenames end too early\n"));
12846 start
= byte_get (descdata
, addr_size
);
12847 descdata
+= addr_size
;
12848 end
= byte_get (descdata
, addr_size
);
12849 descdata
+= addr_size
;
12850 file_ofs
= byte_get (descdata
, addr_size
);
12851 descdata
+= addr_size
;
12854 print_vma (start
, FULL_HEX
);
12856 print_vma (end
, FULL_HEX
);
12858 print_vma (file_ofs
, FULL_HEX
);
12859 printf ("\n %s\n", filenames
);
12861 filenames
+= 1 + strlen ((char *) filenames
);
12867 static const char *
12868 get_gnu_elf_note_type (unsigned e_type
)
12870 static char buff
[64];
12874 case NT_GNU_ABI_TAG
:
12875 return _("NT_GNU_ABI_TAG (ABI version tag)");
12877 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12878 case NT_GNU_BUILD_ID
:
12879 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12880 case NT_GNU_GOLD_VERSION
:
12881 return _("NT_GNU_GOLD_VERSION (gold version)");
12886 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12891 print_gnu_note (Elf_Internal_Note
*pnote
)
12893 switch (pnote
->type
)
12895 case NT_GNU_BUILD_ID
:
12899 printf (_(" Build ID: "));
12900 for (i
= 0; i
< pnote
->descsz
; ++i
)
12901 printf ("%02x", pnote
->descdata
[i
] & 0xff);
12906 case NT_GNU_ABI_TAG
:
12908 unsigned long os
, major
, minor
, subminor
;
12909 const char *osname
;
12911 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
12912 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
12913 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
12914 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
12918 case GNU_ABI_TAG_LINUX
:
12921 case GNU_ABI_TAG_HURD
:
12924 case GNU_ABI_TAG_SOLARIS
:
12925 osname
= "Solaris";
12927 case GNU_ABI_TAG_FREEBSD
:
12928 osname
= "FreeBSD";
12930 case GNU_ABI_TAG_NETBSD
:
12934 osname
= "Unknown";
12938 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
12939 major
, minor
, subminor
);
12947 static const char *
12948 get_netbsd_elfcore_note_type (unsigned e_type
)
12950 static char buff
[64];
12952 if (e_type
== NT_NETBSDCORE_PROCINFO
)
12954 /* NetBSD core "procinfo" structure. */
12955 return _("NetBSD procinfo structure");
12958 /* As of Jan 2002 there are no other machine-independent notes
12959 defined for NetBSD core files. If the note type is less
12960 than the start of the machine-dependent note types, we don't
12963 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
12965 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
12969 switch (elf_header
.e_machine
)
12971 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12972 and PT_GETFPREGS == mach+2. */
12977 case EM_SPARC32PLUS
:
12981 case NT_NETBSDCORE_FIRSTMACH
+ 0:
12982 return _("PT_GETREGS (reg structure)");
12983 case NT_NETBSDCORE_FIRSTMACH
+ 2:
12984 return _("PT_GETFPREGS (fpreg structure)");
12990 /* On all other arch's, PT_GETREGS == mach+1 and
12991 PT_GETFPREGS == mach+3. */
12995 case NT_NETBSDCORE_FIRSTMACH
+ 1:
12996 return _("PT_GETREGS (reg structure)");
12997 case NT_NETBSDCORE_FIRSTMACH
+ 3:
12998 return _("PT_GETFPREGS (fpreg structure)");
13004 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
13005 e_type
- NT_NETBSDCORE_FIRSTMACH
);
13009 static const char *
13010 get_stapsdt_note_type (unsigned e_type
)
13012 static char buff
[64];
13017 return _("NT_STAPSDT (SystemTap probe descriptors)");
13023 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13028 print_stapsdt_note (Elf_Internal_Note
*pnote
)
13030 int addr_size
= is_32bit_elf
? 4 : 8;
13031 char *data
= pnote
->descdata
;
13032 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
13033 bfd_vma pc
, base_addr
, semaphore
;
13034 char *provider
, *probe
, *arg_fmt
;
13036 pc
= byte_get ((unsigned char *) data
, addr_size
);
13038 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
13040 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
13044 data
+= strlen (data
) + 1;
13046 data
+= strlen (data
) + 1;
13048 data
+= strlen (data
) + 1;
13050 printf (_(" Provider: %s\n"), provider
);
13051 printf (_(" Name: %s\n"), probe
);
13052 printf (_(" Location: "));
13053 print_vma (pc
, FULL_HEX
);
13054 printf (_(", Base: "));
13055 print_vma (base_addr
, FULL_HEX
);
13056 printf (_(", Semaphore: "));
13057 print_vma (semaphore
, FULL_HEX
);
13059 printf (_(" Arguments: %s\n"), arg_fmt
);
13061 return data
== data_end
;
13064 static const char *
13065 get_ia64_vms_note_type (unsigned e_type
)
13067 static char buff
[64];
13072 return _("NT_VMS_MHD (module header)");
13074 return _("NT_VMS_LNM (language name)");
13076 return _("NT_VMS_SRC (source files)");
13078 return "NT_VMS_TITLE";
13080 return _("NT_VMS_EIDC (consistency check)");
13081 case NT_VMS_FPMODE
:
13082 return _("NT_VMS_FPMODE (FP mode)");
13083 case NT_VMS_LINKTIME
:
13084 return "NT_VMS_LINKTIME";
13085 case NT_VMS_IMGNAM
:
13086 return _("NT_VMS_IMGNAM (image name)");
13088 return _("NT_VMS_IMGID (image id)");
13089 case NT_VMS_LINKID
:
13090 return _("NT_VMS_LINKID (link id)");
13091 case NT_VMS_IMGBID
:
13092 return _("NT_VMS_IMGBID (build id)");
13093 case NT_VMS_GSTNAM
:
13094 return _("NT_VMS_GSTNAM (sym table name)");
13095 case NT_VMS_ORIG_DYN
:
13096 return "NT_VMS_ORIG_DYN";
13097 case NT_VMS_PATCHTIME
:
13098 return "NT_VMS_PATCHTIME";
13100 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
13106 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
13108 switch (pnote
->type
)
13111 if (pnote
->descsz
> 36)
13113 size_t l
= strlen (pnote
->descdata
+ 34);
13114 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
13115 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
13116 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
13117 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
13120 printf (_(" Invalid size\n"));
13123 printf (_(" Language: %s\n"), pnote
->descdata
);
13126 case NT_VMS_FPMODE
:
13127 printf (_(" Floating Point mode: "));
13128 printf ("0x%016" BFD_VMA_FMT
"x\n",
13129 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
, 8));
13131 case NT_VMS_LINKTIME
:
13132 printf (_(" Link time: "));
13134 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13137 case NT_VMS_PATCHTIME
:
13138 printf (_(" Patch time: "));
13140 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
13143 case NT_VMS_ORIG_DYN
:
13144 printf (_(" Major id: %u, minor id: %u\n"),
13145 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
13146 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
13147 printf (_(" Last modified : "));
13149 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
13150 printf (_("\n Link flags : "));
13151 printf ("0x%016" BFD_VMA_FMT
"x\n",
13152 (bfd_vma
)byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
13153 printf (_(" Header flags: 0x%08x\n"),
13154 (unsigned)byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
13155 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
13158 case NT_VMS_IMGNAM
:
13159 printf (_(" Image name: %s\n"), pnote
->descdata
);
13161 case NT_VMS_GSTNAM
:
13162 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
13165 printf (_(" Image id: %s\n"), pnote
->descdata
);
13167 case NT_VMS_LINKID
:
13168 printf (_(" Linker id: %s\n"), pnote
->descdata
);
13176 /* Note that by the ELF standard, the name field is already null byte
13177 terminated, and namesz includes the terminating null byte.
13178 I.E. the value of namesz for the name "FSF" is 4.
13180 If the value of namesz is zero, there is no name present. */
13182 process_note (Elf_Internal_Note
* pnote
)
13184 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
13187 if (pnote
->namesz
== 0)
13188 /* If there is no note name, then use the default set of
13189 note type strings. */
13190 nt
= get_note_type (pnote
->type
);
13192 else if (const_strneq (pnote
->namedata
, "GNU"))
13193 /* GNU-specific object file notes. */
13194 nt
= get_gnu_elf_note_type (pnote
->type
);
13196 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
13197 /* NetBSD-specific core file notes. */
13198 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
13200 else if (strneq (pnote
->namedata
, "SPU/", 4))
13202 /* SPU-specific core file notes. */
13203 nt
= pnote
->namedata
+ 4;
13207 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13208 /* VMS/ia64-specific file notes. */
13209 nt
= get_ia64_vms_note_type (pnote
->type
);
13211 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13212 nt
= get_stapsdt_note_type (pnote
->type
);
13215 /* Don't recognize this note name; just use the default set of
13216 note type strings. */
13217 nt
= get_note_type (pnote
->type
);
13219 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
13221 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
13222 return print_ia64_vms_note (pnote
);
13223 else if (const_strneq (pnote
->namedata
, "GNU"))
13224 return print_gnu_note (pnote
);
13225 else if (const_strneq (pnote
->namedata
, "stapsdt"))
13226 return print_stapsdt_note (pnote
);
13227 else if (const_strneq (pnote
->namedata
, "CORE"))
13228 return print_core_note (pnote
);
13235 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
13237 Elf_External_Note
* pnotes
;
13238 Elf_External_Note
* external
;
13244 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
13246 if (pnotes
== NULL
)
13251 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13252 (unsigned long) offset
, (unsigned long) length
);
13253 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13255 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
13257 Elf_External_Note
* next
;
13258 Elf_Internal_Note inote
;
13259 char * temp
= NULL
;
13261 if (!is_ia64_vms ())
13263 inote
.type
= BYTE_GET (external
->type
);
13264 inote
.namesz
= BYTE_GET (external
->namesz
);
13265 inote
.namedata
= external
->name
;
13266 inote
.descsz
= BYTE_GET (external
->descsz
);
13267 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
13268 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13270 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
13274 Elf64_External_VMS_Note
*vms_external
;
13276 vms_external
= (Elf64_External_VMS_Note
*)external
;
13277 inote
.type
= BYTE_GET (vms_external
->type
);
13278 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
13279 inote
.namedata
= vms_external
->name
;
13280 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
13281 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
13282 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
13284 next
= (Elf_External_Note
*)
13285 (inote
.descdata
+ align_power (inote
.descsz
, 3));
13288 if ( ((char *) next
> ((char *) pnotes
) + length
)
13289 || ((char *) next
< (char *) pnotes
))
13291 warn (_("corrupt note found at offset %lx into core notes\n"),
13292 (unsigned long) ((char *) external
- (char *) pnotes
));
13293 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13294 inote
.type
, inote
.namesz
, inote
.descsz
);
13300 /* Prevent out-of-bounds indexing. */
13301 if (inote
.namedata
+ inote
.namesz
> (char *) pnotes
+ length
13302 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
13304 warn (_("corrupt note found at offset %lx into core notes\n"),
13305 (unsigned long) ((char *) external
- (char *) pnotes
));
13306 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13307 inote
.type
, inote
.namesz
, inote
.descsz
);
13311 /* Verify that name is null terminated. It appears that at least
13312 one version of Linux (RedHat 6.0) generates corefiles that don't
13313 comply with the ELF spec by failing to include the null byte in
13315 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
13317 temp
= (char *) malloc (inote
.namesz
+ 1);
13321 error (_("Out of memory\n"));
13326 strncpy (temp
, inote
.namedata
, inote
.namesz
);
13327 temp
[inote
.namesz
] = 0;
13329 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13330 inote
.namedata
= temp
;
13333 res
&= process_note (& inote
);
13348 process_corefile_note_segments (FILE * file
)
13350 Elf_Internal_Phdr
* segment
;
13354 if (! get_program_headers (file
))
13357 for (i
= 0, segment
= program_headers
;
13358 i
< elf_header
.e_phnum
;
13361 if (segment
->p_type
== PT_NOTE
)
13362 res
&= process_corefile_note_segment (file
,
13363 (bfd_vma
) segment
->p_offset
,
13364 (bfd_vma
) segment
->p_filesz
);
13371 process_note_sections (FILE * file
)
13373 Elf_Internal_Shdr
* section
;
13377 for (i
= 0, section
= section_headers
;
13378 i
< elf_header
.e_shnum
&& section
!= NULL
;
13380 if (section
->sh_type
== SHT_NOTE
)
13381 res
&= process_corefile_note_segment (file
,
13382 (bfd_vma
) section
->sh_offset
,
13383 (bfd_vma
) section
->sh_size
);
13389 process_notes (FILE * file
)
13391 /* If we have not been asked to display the notes then do nothing. */
13395 if (elf_header
.e_type
!= ET_CORE
)
13396 return process_note_sections (file
);
13398 /* No program headers means no NOTE segment. */
13399 if (elf_header
.e_phnum
> 0)
13400 return process_corefile_note_segments (file
);
13402 printf (_("No note segments present in the core file.\n"));
13407 process_arch_specific (FILE * file
)
13412 switch (elf_header
.e_machine
)
13415 return process_arm_specific (file
);
13417 case EM_MIPS_RS3_LE
:
13418 return process_mips_specific (file
);
13421 return process_power_specific (file
);
13424 case EM_SPARC32PLUS
:
13426 return process_sparc_specific (file
);
13429 return process_tic6x_specific (file
);
13438 get_file_header (FILE * file
)
13440 /* Read in the identity array. */
13441 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
13444 /* Determine how to read the rest of the header. */
13445 switch (elf_header
.e_ident
[EI_DATA
])
13447 default: /* fall through */
13448 case ELFDATANONE
: /* fall through */
13450 byte_get
= byte_get_little_endian
;
13451 byte_put
= byte_put_little_endian
;
13454 byte_get
= byte_get_big_endian
;
13455 byte_put
= byte_put_big_endian
;
13459 /* For now we only support 32 bit and 64 bit ELF files. */
13460 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
13462 /* Read in the rest of the header. */
13465 Elf32_External_Ehdr ehdr32
;
13467 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
13470 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
13471 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
13472 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
13473 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
13474 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
13475 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
13476 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
13477 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
13478 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
13479 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
13480 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
13481 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
13482 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
13486 Elf64_External_Ehdr ehdr64
;
13488 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13489 we will not be able to cope with the 64bit data found in
13490 64 ELF files. Detect this now and abort before we start
13491 overwriting things. */
13492 if (sizeof (bfd_vma
) < 8)
13494 error (_("This instance of readelf has been built without support for a\n\
13495 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13499 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
13502 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
13503 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
13504 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
13505 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
13506 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
13507 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
13508 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
13509 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
13510 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
13511 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
13512 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
13513 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
13514 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
13517 if (elf_header
.e_shoff
)
13519 /* There may be some extensions in the first section header. Don't
13520 bomb if we can't read it. */
13522 get_32bit_section_headers (file
, 1);
13524 get_64bit_section_headers (file
, 1);
13530 /* Process one ELF object file according to the command line options.
13531 This file may actually be stored in an archive. The file is
13532 positioned at the start of the ELF object. */
13535 process_object (char * file_name
, FILE * file
)
13539 if (! get_file_header (file
))
13541 error (_("%s: Failed to read file header\n"), file_name
);
13545 /* Initialise per file variables. */
13546 for (i
= ARRAY_SIZE (version_info
); i
--;)
13547 version_info
[i
] = 0;
13549 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
13550 dynamic_info
[i
] = 0;
13551 dynamic_info_DT_GNU_HASH
= 0;
13553 /* Process the file. */
13555 printf (_("\nFile: %s\n"), file_name
);
13557 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13558 Note we do this even if cmdline_dump_sects is empty because we
13559 must make sure that the dump_sets array is zeroed out before each
13560 object file is processed. */
13561 if (num_dump_sects
> num_cmdline_dump_sects
)
13562 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
13564 if (num_cmdline_dump_sects
> 0)
13566 if (num_dump_sects
== 0)
13567 /* A sneaky way of allocating the dump_sects array. */
13568 request_dump_bynumber (num_cmdline_dump_sects
, 0);
13570 assert (num_dump_sects
>= num_cmdline_dump_sects
);
13571 memcpy (dump_sects
, cmdline_dump_sects
,
13572 num_cmdline_dump_sects
* sizeof (* dump_sects
));
13575 if (! process_file_header ())
13578 if (! process_section_headers (file
))
13580 /* Without loaded section headers we cannot process lots of
13582 do_unwind
= do_version
= do_dump
= do_arch
= 0;
13584 if (! do_using_dynamic
)
13585 do_syms
= do_dyn_syms
= do_reloc
= 0;
13588 if (! process_section_groups (file
))
13590 /* Without loaded section groups we cannot process unwind. */
13594 if (process_program_headers (file
))
13595 process_dynamic_section (file
);
13597 process_relocs (file
);
13599 process_unwind (file
);
13601 process_symbol_table (file
);
13603 process_syminfo (file
);
13605 process_version_sections (file
);
13607 process_section_contents (file
);
13609 process_notes (file
);
13611 process_gnu_liblist (file
);
13613 process_arch_specific (file
);
13615 if (program_headers
)
13617 free (program_headers
);
13618 program_headers
= NULL
;
13621 if (section_headers
)
13623 free (section_headers
);
13624 section_headers
= NULL
;
13629 free (string_table
);
13630 string_table
= NULL
;
13631 string_table_length
= 0;
13634 if (dynamic_strings
)
13636 free (dynamic_strings
);
13637 dynamic_strings
= NULL
;
13638 dynamic_strings_length
= 0;
13641 if (dynamic_symbols
)
13643 free (dynamic_symbols
);
13644 dynamic_symbols
= NULL
;
13645 num_dynamic_syms
= 0;
13648 if (dynamic_syminfo
)
13650 free (dynamic_syminfo
);
13651 dynamic_syminfo
= NULL
;
13654 if (dynamic_section
)
13656 free (dynamic_section
);
13657 dynamic_section
= NULL
;
13660 if (section_headers_groups
)
13662 free (section_headers_groups
);
13663 section_headers_groups
= NULL
;
13666 if (section_groups
)
13668 struct group_list
* g
;
13669 struct group_list
* next
;
13671 for (i
= 0; i
< group_count
; i
++)
13673 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
13680 free (section_groups
);
13681 section_groups
= NULL
;
13684 free_debug_memory ();
13689 /* Process an ELF archive.
13690 On entry the file is positioned just after the ARMAG string. */
13693 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
13695 struct archive_info arch
;
13696 struct archive_info nested_arch
;
13702 /* The ARCH structure is used to hold information about this archive. */
13703 arch
.file_name
= NULL
;
13705 arch
.index_array
= NULL
;
13706 arch
.sym_table
= NULL
;
13707 arch
.longnames
= NULL
;
13709 /* The NESTED_ARCH structure is used as a single-item cache of information
13710 about a nested archive (when members of a thin archive reside within
13711 another regular archive file). */
13712 nested_arch
.file_name
= NULL
;
13713 nested_arch
.file
= NULL
;
13714 nested_arch
.index_array
= NULL
;
13715 nested_arch
.sym_table
= NULL
;
13716 nested_arch
.longnames
= NULL
;
13718 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
13724 if (do_archive_index
)
13726 if (arch
.sym_table
== NULL
)
13727 error (_("%s: unable to dump the index as none was found\n"), file_name
);
13731 unsigned long current_pos
;
13733 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13734 file_name
, (long) arch
.index_num
, arch
.sym_size
);
13735 current_pos
= ftell (file
);
13737 for (i
= l
= 0; i
< arch
.index_num
; i
++)
13739 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
13741 char * member_name
;
13743 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
13745 if (member_name
!= NULL
)
13747 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
13749 if (qualified_name
!= NULL
)
13751 printf (_("Contents of binary %s at offset "), qualified_name
);
13752 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
13754 free (qualified_name
);
13759 if (l
>= arch
.sym_size
)
13761 error (_("%s: end of the symbol table reached before the end of the index\n"),
13765 printf ("\t%s\n", arch
.sym_table
+ l
);
13766 l
+= strlen (arch
.sym_table
+ l
) + 1;
13769 if (arch
.uses_64bit_indicies
)
13774 if (l
< arch
.sym_size
)
13775 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13776 file_name
, arch
.sym_size
- l
);
13778 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
13780 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
13786 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
13787 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
13788 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
13789 && !do_section_groups
&& !do_dyn_syms
)
13791 ret
= 0; /* Archive index only. */
13802 char * qualified_name
;
13804 /* Read the next archive header. */
13805 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
13807 error (_("%s: failed to seek to next archive header\n"), file_name
);
13810 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
13811 if (got
!= sizeof arch
.arhdr
)
13815 error (_("%s: failed to read archive header\n"), file_name
);
13819 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
13821 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
13826 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
13828 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
13829 if (archive_file_size
& 01)
13830 ++archive_file_size
;
13832 name
= get_archive_member_name (&arch
, &nested_arch
);
13835 error (_("%s: bad archive file name\n"), file_name
);
13839 namelen
= strlen (name
);
13841 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
13842 if (qualified_name
== NULL
)
13844 error (_("%s: bad archive file name\n"), file_name
);
13849 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
13851 /* This is a proxy for an external member of a thin archive. */
13852 FILE * member_file
;
13853 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
13854 if (member_file_name
== NULL
)
13860 member_file
= fopen (member_file_name
, "rb");
13861 if (member_file
== NULL
)
13863 error (_("Input file '%s' is not readable.\n"), member_file_name
);
13864 free (member_file_name
);
13869 archive_file_offset
= arch
.nested_member_origin
;
13871 ret
|= process_object (qualified_name
, member_file
);
13873 fclose (member_file
);
13874 free (member_file_name
);
13876 else if (is_thin_archive
)
13878 /* This is a proxy for a member of a nested archive. */
13879 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
13881 /* The nested archive file will have been opened and setup by
13882 get_archive_member_name. */
13883 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
13885 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
13890 ret
|= process_object (qualified_name
, nested_arch
.file
);
13894 archive_file_offset
= arch
.next_arhdr_offset
;
13895 arch
.next_arhdr_offset
+= archive_file_size
;
13897 ret
|= process_object (qualified_name
, file
);
13900 if (dump_sects
!= NULL
)
13904 num_dump_sects
= 0;
13907 free (qualified_name
);
13911 if (nested_arch
.file
!= NULL
)
13912 fclose (nested_arch
.file
);
13913 release_archive (&nested_arch
);
13914 release_archive (&arch
);
13920 process_file (char * file_name
)
13923 struct stat statbuf
;
13924 char armag
[SARMAG
];
13927 if (stat (file_name
, &statbuf
) < 0)
13929 if (errno
== ENOENT
)
13930 error (_("'%s': No such file\n"), file_name
);
13932 error (_("Could not locate '%s'. System error message: %s\n"),
13933 file_name
, strerror (errno
));
13937 if (! S_ISREG (statbuf
.st_mode
))
13939 error (_("'%s' is not an ordinary file\n"), file_name
);
13943 file
= fopen (file_name
, "rb");
13946 error (_("Input file '%s' is not readable.\n"), file_name
);
13950 if (fread (armag
, SARMAG
, 1, file
) != 1)
13952 error (_("%s: Failed to read file's magic number\n"), file_name
);
13957 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
13958 ret
= process_archive (file_name
, file
, FALSE
);
13959 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
13960 ret
= process_archive (file_name
, file
, TRUE
);
13963 if (do_archive_index
)
13964 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13968 archive_file_size
= archive_file_offset
= 0;
13969 ret
= process_object (file_name
, file
);
13977 #ifdef SUPPORT_DISASSEMBLY
13978 /* Needed by the i386 disassembler. For extra credit, someone could
13979 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13983 print_address (unsigned int addr
, FILE * outfile
)
13985 fprintf (outfile
,"0x%8.8x", addr
);
13988 /* Needed by the i386 disassembler. */
13990 db_task_printsym (unsigned int addr
)
13992 print_address (addr
, stderr
);
13997 main (int argc
, char ** argv
)
14001 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14002 setlocale (LC_MESSAGES
, "");
14004 #if defined (HAVE_SETLOCALE)
14005 setlocale (LC_CTYPE
, "");
14007 bindtextdomain (PACKAGE
, LOCALEDIR
);
14008 textdomain (PACKAGE
);
14010 expandargv (&argc
, &argv
);
14012 parse_args (argc
, argv
);
14014 if (num_dump_sects
> 0)
14016 /* Make a copy of the dump_sects array. */
14017 cmdline_dump_sects
= (dump_type
*)
14018 malloc (num_dump_sects
* sizeof (* dump_sects
));
14019 if (cmdline_dump_sects
== NULL
)
14020 error (_("Out of memory allocating dump request table.\n"));
14023 memcpy (cmdline_dump_sects
, dump_sects
,
14024 num_dump_sects
* sizeof (* dump_sects
));
14025 num_cmdline_dump_sects
= num_dump_sects
;
14029 if (optind
< (argc
- 1))
14033 while (optind
< argc
)
14034 err
|= process_file (argv
[optind
++]);
14036 if (dump_sects
!= NULL
)
14038 if (cmdline_dump_sects
!= NULL
)
14039 free (cmdline_dump_sects
);