1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
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. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
129 #include "elf/msp430.h"
130 #include "elf/or32.h"
133 #include "elf/ppc64.h"
135 #include "elf/s390.h"
136 #include "elf/score.h"
138 #include "elf/sparc.h"
140 #include "elf/tic6x.h"
141 #include "elf/v850.h"
143 #include "elf/x86-64.h"
144 #include "elf/xc16x.h"
145 #include "elf/xstormy16.h"
146 #include "elf/xtensa.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
155 char * program_name
= "readelf";
156 static long archive_file_offset
;
157 static unsigned long archive_file_size
;
158 static unsigned long dynamic_addr
;
159 static bfd_size_type dynamic_size
;
160 static unsigned int dynamic_nent
;
161 static char * dynamic_strings
;
162 static unsigned long dynamic_strings_length
;
163 static char * string_table
;
164 static unsigned long string_table_length
;
165 static unsigned long num_dynamic_syms
;
166 static Elf_Internal_Sym
* dynamic_symbols
;
167 static Elf_Internal_Syminfo
* dynamic_syminfo
;
168 static unsigned long dynamic_syminfo_offset
;
169 static unsigned int dynamic_syminfo_nent
;
170 static char program_interpreter
[PATH_MAX
];
171 static bfd_vma dynamic_info
[DT_ENCODING
];
172 static bfd_vma dynamic_info_DT_GNU_HASH
;
173 static bfd_vma version_info
[16];
174 static Elf_Internal_Ehdr elf_header
;
175 static Elf_Internal_Shdr
* section_headers
;
176 static Elf_Internal_Phdr
* program_headers
;
177 static Elf_Internal_Dyn
* dynamic_section
;
178 static Elf_Internal_Shdr
* symtab_shndx_hdr
;
179 static int show_name
;
180 static int do_dynamic
;
182 static int do_dyn_syms
;
184 static int do_sections
;
185 static int do_section_groups
;
186 static int do_section_details
;
187 static int do_segments
;
188 static int do_unwind
;
189 static int do_using_dynamic
;
190 static int do_header
;
192 static int do_version
;
193 static int do_histogram
;
194 static int do_debugging
;
197 static int do_archive_index
;
198 static int is_32bit_elf
;
202 struct group_list
* next
;
203 unsigned int section_index
;
208 struct group_list
* root
;
209 unsigned int group_index
;
212 static size_t group_count
;
213 static struct group
* section_groups
;
214 static struct group
** section_headers_groups
;
217 /* Flag bits indicating particular types of dump. */
218 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
219 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
222 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
224 typedef unsigned char dump_type
;
226 /* A linked list of the section names for which dumps were requested. */
227 struct dump_list_entry
231 struct dump_list_entry
* next
;
233 static struct dump_list_entry
* dump_sects_byname
;
235 /* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237 static dump_type
* cmdline_dump_sects
= NULL
;
238 static unsigned int num_cmdline_dump_sects
= 0;
240 /* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
245 static dump_type
* dump_sects
= NULL
;
246 static unsigned int num_dump_sects
= 0;
249 /* How to print a vma value. */
250 typedef enum print_mode
262 static void (* byte_put
) (unsigned char *, bfd_vma
, int);
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
270 : string_table + (X)->sh_name))
272 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
274 #define BYTE_GET(field) byte_get (field, sizeof (field))
276 #define GET_ELF_SYMBOLS(file, section) \
277 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
278 : get_64bit_elf_symbols (file, section))
280 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
281 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
282 already been called and verified that the string exists. */
283 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
285 /* This is just a bit of syntatic sugar. */
286 #define streq(a,b) (strcmp ((a), (b)) == 0)
287 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
288 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
290 #define REMOVE_ARCH_BITS(ADDR) do { \
291 if (elf_header.e_machine == EM_ARM) \
296 get_data (void * var
, FILE * file
, long offset
, size_t size
, size_t nmemb
,
301 if (size
== 0 || nmemb
== 0)
304 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
306 error (_("Unable to seek to 0x%lx for %s\n"),
307 (unsigned long) archive_file_offset
+ offset
, reason
);
314 /* Check for overflow. */
315 if (nmemb
< (~(size_t) 0 - 1) / size
)
316 /* + 1 so that we can '\0' terminate invalid string table sections. */
317 mvar
= malloc (size
* nmemb
+ 1);
321 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
322 (unsigned long)(size
* nmemb
), reason
);
326 ((char *) mvar
)[size
* nmemb
] = '\0';
329 if (fread (mvar
, size
, nmemb
, file
) != nmemb
)
331 error (_("Unable to read in 0x%lx bytes of %s\n"),
332 (unsigned long)(size
* nmemb
), reason
);
342 byte_put_little_endian (unsigned char * field
, bfd_vma value
, int size
)
347 field
[7] = (((value
>> 24) >> 24) >> 8) & 0xff;
348 field
[6] = ((value
>> 24) >> 24) & 0xff;
349 field
[5] = ((value
>> 24) >> 16) & 0xff;
350 field
[4] = ((value
>> 24) >> 8) & 0xff;
353 field
[3] = (value
>> 24) & 0xff;
356 field
[2] = (value
>> 16) & 0xff;
359 field
[1] = (value
>> 8) & 0xff;
362 field
[0] = value
& 0xff;
366 error (_("Unhandled data length: %d\n"), size
);
371 /* Print a VMA value. */
374 print_vma (bfd_vma vma
, print_mode mode
)
387 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
394 return printf ("%5" BFD_VMA_FMT
"d", vma
);
402 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
405 return printf ("%" BFD_VMA_FMT
"d", vma
);
408 return printf ("%" BFD_VMA_FMT
"u", vma
);
413 /* Display a symbol on stdout. Handles the display of non-printing characters.
415 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
416 truncating as necessary. If WIDTH is negative then format the string to be
417 exactly - WIDTH characters, truncating or padding as necessary.
419 Returns the number of emitted characters. */
422 print_symbol (int width
, const char * symbol
)
425 bfd_boolean extra_padding
= FALSE
;
426 unsigned int num_printed
= 0;
430 /* Set the width to a very large value. This simplifies the code below. */
435 /* Keep the width positive. This also helps. */
437 extra_padding
= TRUE
;
446 /* Look for non-printing symbols inside the symbol's name.
447 This test is triggered in particular by the names generated
448 by the assembler for local labels. */
449 while (ISPRINT (* c
))
459 printf ("%.*s", len
, symbol
);
465 if (* c
== 0 || width
== 0)
468 /* Now display the non-printing character, if
469 there is room left in which to dipslay it. */
475 printf ("^%c", *c
+ 0x40);
485 printf ("<0x%.2x>", *c
);
494 if (extra_padding
&& width
> 0)
496 /* Fill in the remaining spaces. */
497 printf ("%-*s", width
, " ");
505 byte_put_big_endian (unsigned char * field
, bfd_vma value
, int size
)
510 field
[7] = value
& 0xff;
511 field
[6] = (value
>> 8) & 0xff;
512 field
[5] = (value
>> 16) & 0xff;
513 field
[4] = (value
>> 24) & 0xff;
518 field
[3] = value
& 0xff;
522 field
[2] = value
& 0xff;
526 field
[1] = value
& 0xff;
530 field
[0] = value
& 0xff;
534 error (_("Unhandled data length: %d\n"), size
);
539 /* Return a pointer to section NAME, or NULL if no such section exists. */
541 static Elf_Internal_Shdr
*
542 find_section (const char * name
)
546 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
547 if (streq (SECTION_NAME (section_headers
+ i
), name
))
548 return section_headers
+ i
;
553 /* Return a pointer to a section containing ADDR, or NULL if no such
556 static Elf_Internal_Shdr
*
557 find_section_by_address (bfd_vma addr
)
561 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
563 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
564 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
571 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
575 read_uleb128 (unsigned char *data
, unsigned int *length_return
)
577 return read_leb128 (data
, length_return
, 0);
580 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
581 This OS has so many departures from the ELF standard that we test it at
587 return elf_header
.e_machine
== EM_IA_64
588 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
591 /* Guess the relocation size commonly used by the specific machines. */
594 guess_is_rela (unsigned int e_machine
)
598 /* Targets that use REL relocations. */
614 /* Targets that use RELA relocations. */
618 case EM_ALTERA_NIOS2
:
638 case EM_LATTICEMICO32
:
646 case EM_CYGNUS_MN10200
:
648 case EM_CYGNUS_MN10300
:
673 case EM_MICROBLAZE_OLD
:
694 warn (_("Don't know about relocations on this machine architecture\n"));
700 slurp_rela_relocs (FILE * file
,
701 unsigned long rel_offset
,
702 unsigned long rel_size
,
703 Elf_Internal_Rela
** relasp
,
704 unsigned long * nrelasp
)
706 Elf_Internal_Rela
* relas
;
707 unsigned long nrelas
;
712 Elf32_External_Rela
* erelas
;
714 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
715 rel_size
, _("relocs"));
719 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
721 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
722 sizeof (Elf_Internal_Rela
));
727 error (_("out of memory parsing relocs\n"));
731 for (i
= 0; i
< nrelas
; i
++)
733 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
734 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
735 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
742 Elf64_External_Rela
* erelas
;
744 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
745 rel_size
, _("relocs"));
749 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
751 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
752 sizeof (Elf_Internal_Rela
));
757 error (_("out of memory parsing relocs\n"));
761 for (i
= 0; i
< nrelas
; i
++)
763 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
764 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
765 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
767 /* The #ifdef BFD64 below is to prevent a compile time
768 warning. We know that if we do not have a 64 bit data
769 type that we will never execute this code anyway. */
771 if (elf_header
.e_machine
== EM_MIPS
772 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
774 /* In little-endian objects, r_info isn't really a
775 64-bit little-endian value: it has a 32-bit
776 little-endian symbol index followed by four
777 individual byte fields. Reorder INFO
779 bfd_vma inf
= relas
[i
].r_info
;
780 inf
= (((inf
& 0xffffffff) << 32)
781 | ((inf
>> 56) & 0xff)
782 | ((inf
>> 40) & 0xff00)
783 | ((inf
>> 24) & 0xff0000)
784 | ((inf
>> 8) & 0xff000000));
785 relas
[i
].r_info
= inf
;
798 slurp_rel_relocs (FILE * file
,
799 unsigned long rel_offset
,
800 unsigned long rel_size
,
801 Elf_Internal_Rela
** relsp
,
802 unsigned long * nrelsp
)
804 Elf_Internal_Rela
* rels
;
810 Elf32_External_Rel
* erels
;
812 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
813 rel_size
, _("relocs"));
817 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
819 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
824 error (_("out of memory parsing relocs\n"));
828 for (i
= 0; i
< nrels
; i
++)
830 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
831 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
832 rels
[i
].r_addend
= 0;
839 Elf64_External_Rel
* erels
;
841 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
842 rel_size
, _("relocs"));
846 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
848 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
853 error (_("out of memory parsing relocs\n"));
857 for (i
= 0; i
< nrels
; i
++)
859 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
860 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
861 rels
[i
].r_addend
= 0;
863 /* The #ifdef BFD64 below is to prevent a compile time
864 warning. We know that if we do not have a 64 bit data
865 type that we will never execute this code anyway. */
867 if (elf_header
.e_machine
== EM_MIPS
868 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
870 /* In little-endian objects, r_info isn't really a
871 64-bit little-endian value: it has a 32-bit
872 little-endian symbol index followed by four
873 individual byte fields. Reorder INFO
875 bfd_vma inf
= rels
[i
].r_info
;
876 inf
= (((inf
& 0xffffffff) << 32)
877 | ((inf
>> 56) & 0xff)
878 | ((inf
>> 40) & 0xff00)
879 | ((inf
>> 24) & 0xff0000)
880 | ((inf
>> 8) & 0xff000000));
881 rels
[i
].r_info
= inf
;
893 /* Returns the reloc type extracted from the reloc info field. */
896 get_reloc_type (bfd_vma reloc_info
)
899 return ELF32_R_TYPE (reloc_info
);
901 switch (elf_header
.e_machine
)
904 /* Note: We assume that reloc_info has already been adjusted for us. */
905 return ELF64_MIPS_R_TYPE (reloc_info
);
908 return ELF64_R_TYPE_ID (reloc_info
);
911 return ELF64_R_TYPE (reloc_info
);
915 /* Return the symbol index extracted from the reloc info field. */
918 get_reloc_symindex (bfd_vma reloc_info
)
920 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
923 /* Display the contents of the relocation data found at the specified
927 dump_relocations (FILE * file
,
928 unsigned long rel_offset
,
929 unsigned long rel_size
,
930 Elf_Internal_Sym
* symtab
,
933 unsigned long strtablen
,
937 Elf_Internal_Rela
* rels
;
939 if (is_rela
== UNKNOWN
)
940 is_rela
= guess_is_rela (elf_header
.e_machine
);
944 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
949 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
958 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
960 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
965 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
967 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
975 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
977 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
982 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
984 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
988 for (i
= 0; i
< rel_size
; i
++)
993 bfd_vma symtab_index
;
996 offset
= rels
[i
].r_offset
;
997 inf
= rels
[i
].r_info
;
999 type
= get_reloc_type (inf
);
1000 symtab_index
= get_reloc_symindex (inf
);
1004 printf ("%8.8lx %8.8lx ",
1005 (unsigned long) offset
& 0xffffffff,
1006 (unsigned long) inf
& 0xffffffff);
1010 #if BFD_HOST_64BIT_LONG
1012 ? "%16.16lx %16.16lx "
1013 : "%12.12lx %12.12lx ",
1015 #elif BFD_HOST_64BIT_LONG_LONG
1018 ? "%16.16llx %16.16llx "
1019 : "%12.12llx %12.12llx ",
1023 ? "%16.16I64x %16.16I64x "
1024 : "%12.12I64x %12.12I64x ",
1029 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1030 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1031 _bfd_int64_high (offset
),
1032 _bfd_int64_low (offset
),
1033 _bfd_int64_high (inf
),
1034 _bfd_int64_low (inf
));
1038 switch (elf_header
.e_machine
)
1045 case EM_CYGNUS_M32R
:
1046 rtype
= elf_m32r_reloc_type (type
);
1051 rtype
= elf_i386_reloc_type (type
);
1056 rtype
= elf_m68hc11_reloc_type (type
);
1060 rtype
= elf_m68k_reloc_type (type
);
1064 rtype
= elf_i960_reloc_type (type
);
1069 rtype
= elf_avr_reloc_type (type
);
1072 case EM_OLD_SPARCV9
:
1073 case EM_SPARC32PLUS
:
1076 rtype
= elf_sparc_reloc_type (type
);
1080 rtype
= elf_spu_reloc_type (type
);
1084 case EM_CYGNUS_V850
:
1085 rtype
= v850_reloc_type (type
);
1089 case EM_CYGNUS_D10V
:
1090 rtype
= elf_d10v_reloc_type (type
);
1094 case EM_CYGNUS_D30V
:
1095 rtype
= elf_d30v_reloc_type (type
);
1099 rtype
= elf_dlx_reloc_type (type
);
1103 rtype
= elf_sh_reloc_type (type
);
1107 case EM_CYGNUS_MN10300
:
1108 rtype
= elf_mn10300_reloc_type (type
);
1112 case EM_CYGNUS_MN10200
:
1113 rtype
= elf_mn10200_reloc_type (type
);
1117 case EM_CYGNUS_FR30
:
1118 rtype
= elf_fr30_reloc_type (type
);
1122 rtype
= elf_frv_reloc_type (type
);
1126 rtype
= elf_mcore_reloc_type (type
);
1130 rtype
= elf_mmix_reloc_type (type
);
1135 rtype
= elf_msp430_reloc_type (type
);
1139 rtype
= elf_ppc_reloc_type (type
);
1143 rtype
= elf_ppc64_reloc_type (type
);
1147 case EM_MIPS_RS3_LE
:
1148 rtype
= elf_mips_reloc_type (type
);
1152 rtype
= elf_alpha_reloc_type (type
);
1156 rtype
= elf_arm_reloc_type (type
);
1160 rtype
= elf_arc_reloc_type (type
);
1164 rtype
= elf_hppa_reloc_type (type
);
1170 rtype
= elf_h8_reloc_type (type
);
1175 rtype
= elf_or32_reloc_type (type
);
1180 rtype
= elf_pj_reloc_type (type
);
1183 rtype
= elf_ia64_reloc_type (type
);
1187 rtype
= elf_cris_reloc_type (type
);
1191 rtype
= elf_i860_reloc_type (type
);
1196 rtype
= elf_x86_64_reloc_type (type
);
1200 rtype
= i370_reloc_type (type
);
1205 rtype
= elf_s390_reloc_type (type
);
1209 rtype
= elf_score_reloc_type (type
);
1213 rtype
= elf_xstormy16_reloc_type (type
);
1217 rtype
= elf_crx_reloc_type (type
);
1221 rtype
= elf_vax_reloc_type (type
);
1226 rtype
= elf_ip2k_reloc_type (type
);
1230 rtype
= elf_iq2000_reloc_type (type
);
1235 rtype
= elf_xtensa_reloc_type (type
);
1238 case EM_LATTICEMICO32
:
1239 rtype
= elf_lm32_reloc_type (type
);
1244 rtype
= elf_m32c_reloc_type (type
);
1248 rtype
= elf_mt_reloc_type (type
);
1252 rtype
= elf_bfin_reloc_type (type
);
1256 rtype
= elf_mep_reloc_type (type
);
1261 rtype
= elf_cr16_reloc_type (type
);
1265 case EM_MICROBLAZE_OLD
:
1266 rtype
= elf_microblaze_reloc_type (type
);
1270 rtype
= elf_rx_reloc_type (type
);
1275 rtype
= elf_xc16x_reloc_type (type
);
1279 rtype
= elf_tic6x_reloc_type (type
);
1284 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1286 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1288 if (elf_header
.e_machine
== EM_ALPHA
1290 && streq (rtype
, "R_ALPHA_LITUSE")
1293 switch (rels
[i
].r_addend
)
1295 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1296 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1297 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1298 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1299 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1300 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1301 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1302 default: rtype
= NULL
;
1305 printf (" (%s)", rtype
);
1309 printf (_("<unknown addend: %lx>"),
1310 (unsigned long) rels
[i
].r_addend
);
1313 else if (symtab_index
)
1315 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1316 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1319 Elf_Internal_Sym
* psym
;
1321 psym
= symtab
+ symtab_index
;
1325 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1329 unsigned int width
= is_32bit_elf
? 8 : 14;
1331 /* Relocations against GNU_IFUNC symbols do not use the value
1332 of the symbol as the address to relocate against. Instead
1333 they invoke the function named by the symbol and use its
1334 result as the address for relocation.
1336 To indicate this to the user, do not display the value of
1337 the symbol in the "Symbols's Value" field. Instead show
1338 its name followed by () as a hint that the symbol is
1342 || psym
->st_name
== 0
1343 || psym
->st_name
>= strtablen
)
1346 name
= strtab
+ psym
->st_name
;
1348 len
= print_symbol (width
, name
);
1349 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1353 print_vma (psym
->st_value
, LONG_HEX
);
1355 printf (is_32bit_elf
? " " : " ");
1358 if (psym
->st_name
== 0)
1360 const char * sec_name
= "<null>";
1363 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1365 if (psym
->st_shndx
< elf_header
.e_shnum
)
1367 = SECTION_NAME (section_headers
+ psym
->st_shndx
);
1368 else if (psym
->st_shndx
== SHN_ABS
)
1370 else if (psym
->st_shndx
== SHN_COMMON
)
1371 sec_name
= "COMMON";
1372 else if (elf_header
.e_machine
== EM_MIPS
1373 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1374 sec_name
= "SCOMMON";
1375 else if (elf_header
.e_machine
== EM_MIPS
1376 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1377 sec_name
= "SUNDEF";
1378 else if ((elf_header
.e_machine
== EM_X86_64
1379 || elf_header
.e_machine
== EM_L1OM
)
1380 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1381 sec_name
= "LARGE_COMMON";
1382 else if (elf_header
.e_machine
== EM_IA_64
1383 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1384 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1385 sec_name
= "ANSI_COM";
1386 else if (is_ia64_vms ()
1387 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1388 sec_name
= "VMS_SYMVEC";
1391 sprintf (name_buf
, "<section 0x%x>",
1392 (unsigned int) psym
->st_shndx
);
1393 sec_name
= name_buf
;
1396 print_symbol (22, sec_name
);
1398 else if (strtab
== NULL
)
1399 printf (_("<string table index: %3ld>"), psym
->st_name
);
1400 else if (psym
->st_name
>= strtablen
)
1401 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1403 print_symbol (22, strtab
+ psym
->st_name
);
1407 long off
= (long) (bfd_signed_vma
) rels
[i
].r_addend
;
1410 printf (" - %lx", - off
);
1412 printf (" + %lx", off
);
1418 printf ("%*c", is_32bit_elf
?
1419 (do_wide
? 34 : 28) : (do_wide
? 26 : 20), ' ');
1420 print_vma (rels
[i
].r_addend
, LONG_HEX
);
1423 if (elf_header
.e_machine
== EM_SPARCV9
1425 && streq (rtype
, "R_SPARC_OLO10"))
1426 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1431 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1433 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1434 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1435 const char * rtype2
= elf_mips_reloc_type (type2
);
1436 const char * rtype3
= elf_mips_reloc_type (type3
);
1438 printf (" Type2: ");
1441 printf (_("unrecognized: %-7lx"),
1442 (unsigned long) type2
& 0xffffffff);
1444 printf ("%-17.17s", rtype2
);
1446 printf ("\n Type3: ");
1449 printf (_("unrecognized: %-7lx"),
1450 (unsigned long) type3
& 0xffffffff);
1452 printf ("%-17.17s", rtype3
);
1463 get_mips_dynamic_type (unsigned long type
)
1467 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1468 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1469 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1470 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1471 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1472 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1473 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1474 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1475 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1476 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1477 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1478 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1479 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1480 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1481 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1482 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1483 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1484 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1485 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1486 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1487 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1488 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1489 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1490 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1491 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1492 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1493 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1494 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1495 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1496 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1497 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1498 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1499 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1500 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1501 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1502 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1503 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1504 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1505 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1506 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1507 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1508 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1509 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1510 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1511 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1518 get_sparc64_dynamic_type (unsigned long type
)
1522 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1529 get_ppc_dynamic_type (unsigned long type
)
1533 case DT_PPC_GOT
: return "PPC_GOT";
1534 case DT_PPC_TLSOPT
: return "PPC_TLSOPT";
1541 get_ppc64_dynamic_type (unsigned long type
)
1545 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1546 case DT_PPC64_OPD
: return "PPC64_OPD";
1547 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1548 case DT_PPC64_TLSOPT
: return "PPC64_TLSOPT";
1555 get_parisc_dynamic_type (unsigned long type
)
1559 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1560 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1561 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1562 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1563 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1564 case DT_HP_PREINIT
: return "HP_PREINIT";
1565 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1566 case DT_HP_NEEDED
: return "HP_NEEDED";
1567 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1568 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1569 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1570 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1571 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1572 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1573 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1574 case DT_HP_FILTERED
: return "HP_FILTERED";
1575 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1576 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1577 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1578 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1579 case DT_PLT
: return "PLT";
1580 case DT_PLT_SIZE
: return "PLT_SIZE";
1581 case DT_DLT
: return "DLT";
1582 case DT_DLT_SIZE
: return "DLT_SIZE";
1589 get_ia64_dynamic_type (unsigned long type
)
1593 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1594 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1595 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1596 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1597 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1598 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1599 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1600 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1601 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1602 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1603 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1604 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1605 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1606 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1607 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1608 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1609 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1610 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1611 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1612 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1613 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1614 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1615 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1616 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1617 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1618 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1619 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1620 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1621 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1622 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1623 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1630 get_alpha_dynamic_type (unsigned long type
)
1634 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1641 get_score_dynamic_type (unsigned long type
)
1645 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1646 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1647 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1648 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1649 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1650 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1657 get_tic6x_dynamic_type (unsigned long type
)
1661 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1662 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1663 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1664 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1665 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1666 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1673 get_dynamic_type (unsigned long type
)
1675 static char buff
[64];
1679 case DT_NULL
: return "NULL";
1680 case DT_NEEDED
: return "NEEDED";
1681 case DT_PLTRELSZ
: return "PLTRELSZ";
1682 case DT_PLTGOT
: return "PLTGOT";
1683 case DT_HASH
: return "HASH";
1684 case DT_STRTAB
: return "STRTAB";
1685 case DT_SYMTAB
: return "SYMTAB";
1686 case DT_RELA
: return "RELA";
1687 case DT_RELASZ
: return "RELASZ";
1688 case DT_RELAENT
: return "RELAENT";
1689 case DT_STRSZ
: return "STRSZ";
1690 case DT_SYMENT
: return "SYMENT";
1691 case DT_INIT
: return "INIT";
1692 case DT_FINI
: return "FINI";
1693 case DT_SONAME
: return "SONAME";
1694 case DT_RPATH
: return "RPATH";
1695 case DT_SYMBOLIC
: return "SYMBOLIC";
1696 case DT_REL
: return "REL";
1697 case DT_RELSZ
: return "RELSZ";
1698 case DT_RELENT
: return "RELENT";
1699 case DT_PLTREL
: return "PLTREL";
1700 case DT_DEBUG
: return "DEBUG";
1701 case DT_TEXTREL
: return "TEXTREL";
1702 case DT_JMPREL
: return "JMPREL";
1703 case DT_BIND_NOW
: return "BIND_NOW";
1704 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1705 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1706 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1707 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1708 case DT_RUNPATH
: return "RUNPATH";
1709 case DT_FLAGS
: return "FLAGS";
1711 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1712 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1714 case DT_CHECKSUM
: return "CHECKSUM";
1715 case DT_PLTPADSZ
: return "PLTPADSZ";
1716 case DT_MOVEENT
: return "MOVEENT";
1717 case DT_MOVESZ
: return "MOVESZ";
1718 case DT_FEATURE
: return "FEATURE";
1719 case DT_POSFLAG_1
: return "POSFLAG_1";
1720 case DT_SYMINSZ
: return "SYMINSZ";
1721 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1723 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1724 case DT_CONFIG
: return "CONFIG";
1725 case DT_DEPAUDIT
: return "DEPAUDIT";
1726 case DT_AUDIT
: return "AUDIT";
1727 case DT_PLTPAD
: return "PLTPAD";
1728 case DT_MOVETAB
: return "MOVETAB";
1729 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1731 case DT_VERSYM
: return "VERSYM";
1733 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1734 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1735 case DT_RELACOUNT
: return "RELACOUNT";
1736 case DT_RELCOUNT
: return "RELCOUNT";
1737 case DT_FLAGS_1
: return "FLAGS_1";
1738 case DT_VERDEF
: return "VERDEF";
1739 case DT_VERDEFNUM
: return "VERDEFNUM";
1740 case DT_VERNEED
: return "VERNEED";
1741 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1743 case DT_AUXILIARY
: return "AUXILIARY";
1744 case DT_USED
: return "USED";
1745 case DT_FILTER
: return "FILTER";
1747 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1748 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1749 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1750 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1751 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1752 case DT_GNU_HASH
: return "GNU_HASH";
1755 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1757 const char * result
;
1759 switch (elf_header
.e_machine
)
1762 case EM_MIPS_RS3_LE
:
1763 result
= get_mips_dynamic_type (type
);
1766 result
= get_sparc64_dynamic_type (type
);
1769 result
= get_ppc_dynamic_type (type
);
1772 result
= get_ppc64_dynamic_type (type
);
1775 result
= get_ia64_dynamic_type (type
);
1778 result
= get_alpha_dynamic_type (type
);
1781 result
= get_score_dynamic_type (type
);
1784 result
= get_tic6x_dynamic_type (type
);
1794 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
1796 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1797 || (elf_header
.e_machine
== EM_PARISC
1798 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
1800 const char * result
;
1802 switch (elf_header
.e_machine
)
1805 result
= get_parisc_dynamic_type (type
);
1808 result
= get_ia64_dynamic_type (type
);
1818 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
1822 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
1829 get_file_type (unsigned e_type
)
1831 static char buff
[32];
1835 case ET_NONE
: return _("NONE (None)");
1836 case ET_REL
: return _("REL (Relocatable file)");
1837 case ET_EXEC
: return _("EXEC (Executable file)");
1838 case ET_DYN
: return _("DYN (Shared object file)");
1839 case ET_CORE
: return _("CORE (Core file)");
1842 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1843 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
1844 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1845 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
1847 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
1853 get_machine_name (unsigned e_machine
)
1855 static char buff
[64]; /* XXX */
1859 case EM_NONE
: return _("None");
1860 case EM_M32
: return "WE32100";
1861 case EM_SPARC
: return "Sparc";
1862 case EM_SPU
: return "SPU";
1863 case EM_386
: return "Intel 80386";
1864 case EM_68K
: return "MC68000";
1865 case EM_88K
: return "MC88000";
1866 case EM_486
: return "Intel 80486";
1867 case EM_860
: return "Intel 80860";
1868 case EM_MIPS
: return "MIPS R3000";
1869 case EM_S370
: return "IBM System/370";
1870 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1871 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1872 case EM_PARISC
: return "HPPA";
1873 case EM_PPC_OLD
: return "Power PC (old)";
1874 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1875 case EM_960
: return "Intel 90860";
1876 case EM_PPC
: return "PowerPC";
1877 case EM_PPC64
: return "PowerPC64";
1878 case EM_V800
: return "NEC V800";
1879 case EM_FR20
: return "Fujitsu FR20";
1880 case EM_RH32
: return "TRW RH32";
1881 case EM_MCORE
: return "MCORE";
1882 case EM_ARM
: return "ARM";
1883 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1884 case EM_SH
: return "Renesas / SuperH SH";
1885 case EM_SPARCV9
: return "Sparc v9";
1886 case EM_TRICORE
: return "Siemens Tricore";
1887 case EM_ARC
: return "ARC";
1888 case EM_H8_300
: return "Renesas H8/300";
1889 case EM_H8_300H
: return "Renesas H8/300H";
1890 case EM_H8S
: return "Renesas H8S";
1891 case EM_H8_500
: return "Renesas H8/500";
1892 case EM_IA_64
: return "Intel IA-64";
1893 case EM_MIPS_X
: return "Stanford MIPS-X";
1894 case EM_COLDFIRE
: return "Motorola Coldfire";
1895 case EM_68HC12
: return "Motorola M68HC12";
1896 case EM_ALPHA
: return "Alpha";
1897 case EM_CYGNUS_D10V
:
1898 case EM_D10V
: return "d10v";
1899 case EM_CYGNUS_D30V
:
1900 case EM_D30V
: return "d30v";
1901 case EM_CYGNUS_M32R
:
1902 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
1903 case EM_CYGNUS_V850
:
1904 case EM_V850
: return "NEC v850";
1905 case EM_CYGNUS_MN10300
:
1906 case EM_MN10300
: return "mn10300";
1907 case EM_CYGNUS_MN10200
:
1908 case EM_MN10200
: return "mn10200";
1909 case EM_CYGNUS_FR30
:
1910 case EM_FR30
: return "Fujitsu FR30";
1911 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
1913 case EM_PJ
: return "picoJava";
1914 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1915 case EM_PCP
: return "Siemens PCP";
1916 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1917 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1918 case EM_STARCORE
: return "Motorola Star*Core processor";
1919 case EM_ME16
: return "Toyota ME16 processor";
1920 case EM_ST100
: return "STMicroelectronics ST100 processor";
1921 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1922 case EM_PDSP
: return "Sony DSP processor";
1923 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
1924 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
1925 case EM_FX66
: return "Siemens FX66 microcontroller";
1926 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1927 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1928 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1929 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1930 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1931 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1932 case EM_SVX
: return "Silicon Graphics SVx";
1933 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1934 case EM_VAX
: return "Digital VAX";
1936 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1937 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1938 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1939 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1940 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1941 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1942 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1943 case EM_PRISM
: return "Vitesse Prism";
1944 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1945 case EM_L1OM
: return "Intel L1OM";
1947 case EM_S390
: return "IBM S/390";
1948 case EM_SCORE
: return "SUNPLUS S+Core";
1949 case EM_XSTORMY16
: return "Sanyo Xstormy16 CPU core";
1951 case EM_OR32
: return "OpenRISC";
1952 case EM_ARC_A5
: return "ARC International ARCompact processor";
1953 case EM_CRX
: return "National Semiconductor CRX microprocessor";
1954 case EM_DLX
: return "OpenDLX";
1956 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
1957 case EM_IQ2000
: return "Vitesse IQ2000";
1959 case EM_XTENSA
: return "Tensilica Xtensa Processor";
1960 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
1961 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
1962 case EM_NS32K
: return "National Semiconductor 32000 series";
1963 case EM_TPC
: return "Tenor Network TPC processor";
1964 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
1965 case EM_MAX
: return "MAX Processor";
1966 case EM_CR
: return "National Semiconductor CompactRISC";
1967 case EM_F2MC16
: return "Fujitsu F2MC16";
1968 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
1969 case EM_LATTICEMICO32
: return "Lattice Mico32";
1971 case EM_M32C
: return "Renesas M32c";
1972 case EM_MT
: return "Morpho Techologies MT processor";
1973 case EM_BLACKFIN
: return "Analog Devices Blackfin";
1974 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
1975 case EM_SEP
: return "Sharp embedded microprocessor";
1976 case EM_ARCA
: return "Arca RISC microprocessor";
1977 case EM_UNICORE
: return "Unicore";
1978 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
1979 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
1980 case EM_NIOS32
: return "Altera Nios";
1981 case EM_ALTERA_NIOS2
: return "Altera Nios II";
1983 case EM_XC16X
: return "Infineon Technologies xc16x";
1984 case EM_M16C
: return "Renesas M16C series microprocessors";
1985 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
1986 case EM_CE
: return "Freescale Communication Engine RISC core";
1987 case EM_TSK3000
: return "Altium TSK3000 core";
1988 case EM_RS08
: return "Freescale RS08 embedded processor";
1989 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
1990 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
1991 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
1992 case EM_SE_C17
: return "Seiko Epson C17 family";
1993 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
1994 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
1995 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
1996 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1997 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
1998 case EM_R32C
: return "Renesas R32C series microprocessors";
1999 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2000 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2001 case EM_8051
: return "Intel 8051 and variants";
2002 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2003 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2004 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2005 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2006 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2007 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2008 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2009 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2011 case EM_CR16_OLD
: return "National Semiconductor's CR16";
2012 case EM_MICROBLAZE
: return "Xilinx MicroBlaze";
2013 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2014 case EM_RX
: return "Renesas RX";
2015 case EM_METAG
: return "Imagination Technologies META processor architecture";
2016 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2017 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2018 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2019 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2020 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2021 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2022 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2023 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2024 case EM_CUDA
: return "NVIDIA CUDA architecture";
2026 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2032 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2037 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2038 e_flags
&= ~ EF_ARM_EABIMASK
;
2040 /* Handle "generic" ARM flags. */
2041 if (e_flags
& EF_ARM_RELEXEC
)
2043 strcat (buf
, ", relocatable executable");
2044 e_flags
&= ~ EF_ARM_RELEXEC
;
2047 if (e_flags
& EF_ARM_HASENTRY
)
2049 strcat (buf
, ", has entry point");
2050 e_flags
&= ~ EF_ARM_HASENTRY
;
2053 /* Now handle EABI specific flags. */
2057 strcat (buf
, ", <unrecognized EABI>");
2062 case EF_ARM_EABI_VER1
:
2063 strcat (buf
, ", Version1 EABI");
2068 /* Process flags one bit at a time. */
2069 flag
= e_flags
& - e_flags
;
2074 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2075 strcat (buf
, ", sorted symbol tables");
2085 case EF_ARM_EABI_VER2
:
2086 strcat (buf
, ", Version2 EABI");
2091 /* Process flags one bit at a time. */
2092 flag
= e_flags
& - e_flags
;
2097 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2098 strcat (buf
, ", sorted symbol tables");
2101 case EF_ARM_DYNSYMSUSESEGIDX
:
2102 strcat (buf
, ", dynamic symbols use segment index");
2105 case EF_ARM_MAPSYMSFIRST
:
2106 strcat (buf
, ", mapping symbols precede others");
2116 case EF_ARM_EABI_VER3
:
2117 strcat (buf
, ", Version3 EABI");
2120 case EF_ARM_EABI_VER4
:
2121 strcat (buf
, ", Version4 EABI");
2124 case EF_ARM_EABI_VER5
:
2125 strcat (buf
, ", Version5 EABI");
2131 /* Process flags one bit at a time. */
2132 flag
= e_flags
& - e_flags
;
2138 strcat (buf
, ", BE8");
2142 strcat (buf
, ", LE8");
2152 case EF_ARM_EABI_UNKNOWN
:
2153 strcat (buf
, ", GNU EABI");
2158 /* Process flags one bit at a time. */
2159 flag
= e_flags
& - e_flags
;
2164 case EF_ARM_INTERWORK
:
2165 strcat (buf
, ", interworking enabled");
2168 case EF_ARM_APCS_26
:
2169 strcat (buf
, ", uses APCS/26");
2172 case EF_ARM_APCS_FLOAT
:
2173 strcat (buf
, ", uses APCS/float");
2177 strcat (buf
, ", position independent");
2181 strcat (buf
, ", 8 bit structure alignment");
2184 case EF_ARM_NEW_ABI
:
2185 strcat (buf
, ", uses new ABI");
2188 case EF_ARM_OLD_ABI
:
2189 strcat (buf
, ", uses old ABI");
2192 case EF_ARM_SOFT_FLOAT
:
2193 strcat (buf
, ", software FP");
2196 case EF_ARM_VFP_FLOAT
:
2197 strcat (buf
, ", VFP");
2200 case EF_ARM_MAVERICK_FLOAT
:
2201 strcat (buf
, ", Maverick FP");
2212 strcat (buf
,_(", <unknown>"));
2216 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2218 static char buf
[1024];
2230 decode_ARM_machine_flags (e_flags
, buf
);
2234 switch (e_flags
& EF_FRV_CPU_MASK
)
2236 case EF_FRV_CPU_GENERIC
:
2240 strcat (buf
, ", fr???");
2243 case EF_FRV_CPU_FR300
:
2244 strcat (buf
, ", fr300");
2247 case EF_FRV_CPU_FR400
:
2248 strcat (buf
, ", fr400");
2250 case EF_FRV_CPU_FR405
:
2251 strcat (buf
, ", fr405");
2254 case EF_FRV_CPU_FR450
:
2255 strcat (buf
, ", fr450");
2258 case EF_FRV_CPU_FR500
:
2259 strcat (buf
, ", fr500");
2261 case EF_FRV_CPU_FR550
:
2262 strcat (buf
, ", fr550");
2265 case EF_FRV_CPU_SIMPLE
:
2266 strcat (buf
, ", simple");
2268 case EF_FRV_CPU_TOMCAT
:
2269 strcat (buf
, ", tomcat");
2275 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2276 strcat (buf
, ", m68000");
2277 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2278 strcat (buf
, ", cpu32");
2279 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2280 strcat (buf
, ", fido_a");
2283 char const * isa
= _("unknown");
2284 char const * mac
= _("unknown mac");
2285 char const * additional
= NULL
;
2287 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2289 case EF_M68K_CF_ISA_A_NODIV
:
2291 additional
= ", nodiv";
2293 case EF_M68K_CF_ISA_A
:
2296 case EF_M68K_CF_ISA_A_PLUS
:
2299 case EF_M68K_CF_ISA_B_NOUSP
:
2301 additional
= ", nousp";
2303 case EF_M68K_CF_ISA_B
:
2307 strcat (buf
, ", cf, isa ");
2310 strcat (buf
, additional
);
2311 if (e_flags
& EF_M68K_CF_FLOAT
)
2312 strcat (buf
, ", float");
2313 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2318 case EF_M68K_CF_MAC
:
2321 case EF_M68K_CF_EMAC
:
2334 if (e_flags
& EF_PPC_EMB
)
2335 strcat (buf
, ", emb");
2337 if (e_flags
& EF_PPC_RELOCATABLE
)
2338 strcat (buf
, _(", relocatable"));
2340 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
2341 strcat (buf
, _(", relocatable-lib"));
2345 case EM_CYGNUS_V850
:
2346 switch (e_flags
& EF_V850_ARCH
)
2349 strcat (buf
, ", v850e1");
2352 strcat (buf
, ", v850e");
2355 strcat (buf
, ", v850");
2358 strcat (buf
, _(", unknown v850 architecture variant"));
2364 case EM_CYGNUS_M32R
:
2365 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
2366 strcat (buf
, ", m32r");
2370 case EM_MIPS_RS3_LE
:
2371 if (e_flags
& EF_MIPS_NOREORDER
)
2372 strcat (buf
, ", noreorder");
2374 if (e_flags
& EF_MIPS_PIC
)
2375 strcat (buf
, ", pic");
2377 if (e_flags
& EF_MIPS_CPIC
)
2378 strcat (buf
, ", cpic");
2380 if (e_flags
& EF_MIPS_UCODE
)
2381 strcat (buf
, ", ugen_reserved");
2383 if (e_flags
& EF_MIPS_ABI2
)
2384 strcat (buf
, ", abi2");
2386 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
2387 strcat (buf
, ", odk first");
2389 if (e_flags
& EF_MIPS_32BITMODE
)
2390 strcat (buf
, ", 32bitmode");
2392 switch ((e_flags
& EF_MIPS_MACH
))
2394 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
2395 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
2396 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
2397 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
2398 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
2399 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
2400 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
2401 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
2402 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
2403 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
2404 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
2405 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
2406 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
2407 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
2408 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
2410 /* We simply ignore the field in this case to avoid confusion:
2411 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2414 default: strcat (buf
, _(", unknown CPU")); break;
2417 switch ((e_flags
& EF_MIPS_ABI
))
2419 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
2420 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
2421 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
2422 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
2424 /* We simply ignore the field in this case to avoid confusion:
2425 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2426 This means it is likely to be an o32 file, but not for
2429 default: strcat (buf
, _(", unknown ABI")); break;
2432 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
2433 strcat (buf
, ", mdmx");
2435 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
2436 strcat (buf
, ", mips16");
2438 switch ((e_flags
& EF_MIPS_ARCH
))
2440 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
2441 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
2442 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
2443 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
2444 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
2445 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
2446 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
2447 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
2448 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
2449 default: strcat (buf
, _(", unknown ISA")); break;
2452 if (e_flags
& EF_SH_PIC
)
2453 strcat (buf
, ", pic");
2455 if (e_flags
& EF_SH_FDPIC
)
2456 strcat (buf
, ", fdpic");
2460 switch ((e_flags
& EF_SH_MACH_MASK
))
2462 case EF_SH1
: strcat (buf
, ", sh1"); break;
2463 case EF_SH2
: strcat (buf
, ", sh2"); break;
2464 case EF_SH3
: strcat (buf
, ", sh3"); break;
2465 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
2466 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
2467 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
2468 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
2469 case EF_SH4
: strcat (buf
, ", sh4"); break;
2470 case EF_SH5
: strcat (buf
, ", sh5"); break;
2471 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
2472 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
2473 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
2474 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
2475 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
2476 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
2477 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
2478 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
2479 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2480 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
2481 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
2482 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
2483 default: strcat (buf
, _(", unknown ISA")); break;
2489 if (e_flags
& EF_SPARC_32PLUS
)
2490 strcat (buf
, ", v8+");
2492 if (e_flags
& EF_SPARC_SUN_US1
)
2493 strcat (buf
, ", ultrasparcI");
2495 if (e_flags
& EF_SPARC_SUN_US3
)
2496 strcat (buf
, ", ultrasparcIII");
2498 if (e_flags
& EF_SPARC_HAL_R1
)
2499 strcat (buf
, ", halr1");
2501 if (e_flags
& EF_SPARC_LEDATA
)
2502 strcat (buf
, ", ledata");
2504 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
2505 strcat (buf
, ", tso");
2507 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
2508 strcat (buf
, ", pso");
2510 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
2511 strcat (buf
, ", rmo");
2515 switch (e_flags
& EF_PARISC_ARCH
)
2517 case EFA_PARISC_1_0
:
2518 strcpy (buf
, ", PA-RISC 1.0");
2520 case EFA_PARISC_1_1
:
2521 strcpy (buf
, ", PA-RISC 1.1");
2523 case EFA_PARISC_2_0
:
2524 strcpy (buf
, ", PA-RISC 2.0");
2529 if (e_flags
& EF_PARISC_TRAPNIL
)
2530 strcat (buf
, ", trapnil");
2531 if (e_flags
& EF_PARISC_EXT
)
2532 strcat (buf
, ", ext");
2533 if (e_flags
& EF_PARISC_LSB
)
2534 strcat (buf
, ", lsb");
2535 if (e_flags
& EF_PARISC_WIDE
)
2536 strcat (buf
, ", wide");
2537 if (e_flags
& EF_PARISC_NO_KABP
)
2538 strcat (buf
, ", no kabp");
2539 if (e_flags
& EF_PARISC_LAZYSWAP
)
2540 strcat (buf
, ", lazyswap");
2545 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
2546 strcat (buf
, ", new calling convention");
2548 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
2549 strcat (buf
, ", gnu calling convention");
2553 if ((e_flags
& EF_IA_64_ABI64
))
2554 strcat (buf
, ", 64-bit");
2556 strcat (buf
, ", 32-bit");
2557 if ((e_flags
& EF_IA_64_REDUCEDFP
))
2558 strcat (buf
, ", reduced fp model");
2559 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
2560 strcat (buf
, ", no function descriptors, constant gp");
2561 else if ((e_flags
& EF_IA_64_CONS_GP
))
2562 strcat (buf
, ", constant gp");
2563 if ((e_flags
& EF_IA_64_ABSOLUTE
))
2564 strcat (buf
, ", absolute");
2565 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
2567 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
2568 strcat (buf
, ", vms_linkages");
2569 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
2571 case EF_IA_64_VMS_COMCOD_SUCCESS
:
2573 case EF_IA_64_VMS_COMCOD_WARNING
:
2574 strcat (buf
, ", warning");
2576 case EF_IA_64_VMS_COMCOD_ERROR
:
2577 strcat (buf
, ", error");
2579 case EF_IA_64_VMS_COMCOD_ABORT
:
2580 strcat (buf
, ", abort");
2589 if ((e_flags
& EF_VAX_NONPIC
))
2590 strcat (buf
, ", non-PIC");
2591 if ((e_flags
& EF_VAX_DFLOAT
))
2592 strcat (buf
, ", D-Float");
2593 if ((e_flags
& EF_VAX_GFLOAT
))
2594 strcat (buf
, ", G-Float");
2598 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
2599 strcat (buf
, ", 64-bit doubles");
2600 if (e_flags
& E_FLAG_RX_DSP
)
2601 strcat (buf
, ", dsp");
2604 if (e_flags
& EF_S390_HIGH_GPRS
)
2605 strcat (buf
, ", highgprs");
2608 if ((e_flags
& EF_C6000_REL
))
2609 strcat (buf
, ", relocatable module");
2617 get_osabi_name (unsigned int osabi
)
2619 static char buff
[32];
2623 case ELFOSABI_NONE
: return "UNIX - System V";
2624 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
2625 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
2626 case ELFOSABI_LINUX
: return "UNIX - Linux";
2627 case ELFOSABI_HURD
: return "GNU/Hurd";
2628 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
2629 case ELFOSABI_AIX
: return "UNIX - AIX";
2630 case ELFOSABI_IRIX
: return "UNIX - IRIX";
2631 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
2632 case ELFOSABI_TRU64
: return "UNIX - TRU64";
2633 case ELFOSABI_MODESTO
: return "Novell - Modesto";
2634 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
2635 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
2636 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
2637 case ELFOSABI_AROS
: return "AROS";
2638 case ELFOSABI_FENIXOS
: return "FenixOS";
2641 switch (elf_header
.e_machine
)
2646 case ELFOSABI_ARM
: return "ARM";
2656 case ELFOSABI_STANDALONE
: return _("Standalone App");
2665 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
2666 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
2675 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
2681 get_arm_segment_type (unsigned long type
)
2695 get_mips_segment_type (unsigned long type
)
2699 case PT_MIPS_REGINFO
:
2701 case PT_MIPS_RTPROC
:
2703 case PT_MIPS_OPTIONS
:
2713 get_parisc_segment_type (unsigned long type
)
2717 case PT_HP_TLS
: return "HP_TLS";
2718 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
2719 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
2720 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
2721 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
2722 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
2723 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
2724 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
2725 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
2726 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
2727 case PT_HP_PARALLEL
: return "HP_PARALLEL";
2728 case PT_HP_FASTBIND
: return "HP_FASTBIND";
2729 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
2730 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
2731 case PT_HP_STACK
: return "HP_STACK";
2732 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
2733 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
2734 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
2735 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
2744 get_ia64_segment_type (unsigned long type
)
2748 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
2749 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
2750 case PT_HP_TLS
: return "HP_TLS";
2751 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
2752 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
2753 case PT_IA_64_HP_STACK
: return "HP_STACK";
2762 get_tic6x_segment_type (unsigned long type
)
2766 case PT_C6000_PHATTR
: return "C6000_PHATTR";
2775 get_segment_type (unsigned long p_type
)
2777 static char buff
[32];
2781 case PT_NULL
: return "NULL";
2782 case PT_LOAD
: return "LOAD";
2783 case PT_DYNAMIC
: return "DYNAMIC";
2784 case PT_INTERP
: return "INTERP";
2785 case PT_NOTE
: return "NOTE";
2786 case PT_SHLIB
: return "SHLIB";
2787 case PT_PHDR
: return "PHDR";
2788 case PT_TLS
: return "TLS";
2790 case PT_GNU_EH_FRAME
:
2791 return "GNU_EH_FRAME";
2792 case PT_GNU_STACK
: return "GNU_STACK";
2793 case PT_GNU_RELRO
: return "GNU_RELRO";
2796 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
2798 const char * result
;
2800 switch (elf_header
.e_machine
)
2803 result
= get_arm_segment_type (p_type
);
2806 case EM_MIPS_RS3_LE
:
2807 result
= get_mips_segment_type (p_type
);
2810 result
= get_parisc_segment_type (p_type
);
2813 result
= get_ia64_segment_type (p_type
);
2816 result
= get_tic6x_segment_type (p_type
);
2826 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
2828 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
2830 const char * result
;
2832 switch (elf_header
.e_machine
)
2835 result
= get_parisc_segment_type (p_type
);
2838 result
= get_ia64_segment_type (p_type
);
2848 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
2851 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
2858 get_mips_section_type_name (unsigned int sh_type
)
2862 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
2863 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
2864 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
2865 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
2866 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
2867 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
2868 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
2869 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
2870 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
2871 case SHT_MIPS_RELD
: return "MIPS_RELD";
2872 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
2873 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
2874 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
2875 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
2876 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
2877 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
2878 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
2879 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
2880 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
2881 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
2882 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
2883 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
2884 case SHT_MIPS_LINE
: return "MIPS_LINE";
2885 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
2886 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
2887 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
2888 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
2889 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
2890 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
2891 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
2892 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
2893 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
2894 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
2895 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
2896 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
2897 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
2898 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
2899 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
2900 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
2908 get_parisc_section_type_name (unsigned int sh_type
)
2912 case SHT_PARISC_EXT
: return "PARISC_EXT";
2913 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
2914 case SHT_PARISC_DOC
: return "PARISC_DOC";
2915 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
2916 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
2917 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
2918 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
2926 get_ia64_section_type_name (unsigned int sh_type
)
2928 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2929 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
2930 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
2934 case SHT_IA_64_EXT
: return "IA_64_EXT";
2935 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
2936 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
2937 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
2938 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
2939 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
2940 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
2941 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
2942 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
2943 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
2951 get_x86_64_section_type_name (unsigned int sh_type
)
2955 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
2963 get_arm_section_type_name (unsigned int sh_type
)
2967 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
2968 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
2969 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
2970 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
2971 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
2979 get_tic6x_section_type_name (unsigned int sh_type
)
2983 case SHT_C6000_UNWIND
:
2984 return "C6000_UNWIND";
2985 case SHT_C6000_PREEMPTMAP
:
2986 return "C6000_PREEMPTMAP";
2987 case SHT_C6000_ATTRIBUTES
:
2988 return "C6000_ATTRIBUTES";
2993 case SHT_TI_HANDLER
:
2994 return "TI_HANDLER";
2995 case SHT_TI_INITINFO
:
2996 return "TI_INITINFO";
2997 case SHT_TI_PHATTRS
:
2998 return "TI_PHATTRS";
3006 get_section_type_name (unsigned int sh_type
)
3008 static char buff
[32];
3012 case SHT_NULL
: return "NULL";
3013 case SHT_PROGBITS
: return "PROGBITS";
3014 case SHT_SYMTAB
: return "SYMTAB";
3015 case SHT_STRTAB
: return "STRTAB";
3016 case SHT_RELA
: return "RELA";
3017 case SHT_HASH
: return "HASH";
3018 case SHT_DYNAMIC
: return "DYNAMIC";
3019 case SHT_NOTE
: return "NOTE";
3020 case SHT_NOBITS
: return "NOBITS";
3021 case SHT_REL
: return "REL";
3022 case SHT_SHLIB
: return "SHLIB";
3023 case SHT_DYNSYM
: return "DYNSYM";
3024 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3025 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3026 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3027 case SHT_GNU_HASH
: return "GNU_HASH";
3028 case SHT_GROUP
: return "GROUP";
3029 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3030 case SHT_GNU_verdef
: return "VERDEF";
3031 case SHT_GNU_verneed
: return "VERNEED";
3032 case SHT_GNU_versym
: return "VERSYM";
3033 case 0x6ffffff0: return "VERSYM";
3034 case 0x6ffffffc: return "VERDEF";
3035 case 0x7ffffffd: return "AUXILIARY";
3036 case 0x7fffffff: return "FILTER";
3037 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3040 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3042 const char * result
;
3044 switch (elf_header
.e_machine
)
3047 case EM_MIPS_RS3_LE
:
3048 result
= get_mips_section_type_name (sh_type
);
3051 result
= get_parisc_section_type_name (sh_type
);
3054 result
= get_ia64_section_type_name (sh_type
);
3058 result
= get_x86_64_section_type_name (sh_type
);
3061 result
= get_arm_section_type_name (sh_type
);
3064 result
= get_tic6x_section_type_name (sh_type
);
3074 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3076 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3078 const char * result
;
3080 switch (elf_header
.e_machine
)
3083 result
= get_ia64_section_type_name (sh_type
);
3093 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3095 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3096 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3098 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), sh_type
);
3104 #define OPTION_DEBUG_DUMP 512
3105 #define OPTION_DYN_SYMS 513
3107 static struct option options
[] =
3109 {"all", no_argument
, 0, 'a'},
3110 {"file-header", no_argument
, 0, 'h'},
3111 {"program-headers", no_argument
, 0, 'l'},
3112 {"headers", no_argument
, 0, 'e'},
3113 {"histogram", no_argument
, 0, 'I'},
3114 {"segments", no_argument
, 0, 'l'},
3115 {"sections", no_argument
, 0, 'S'},
3116 {"section-headers", no_argument
, 0, 'S'},
3117 {"section-groups", no_argument
, 0, 'g'},
3118 {"section-details", no_argument
, 0, 't'},
3119 {"full-section-name",no_argument
, 0, 'N'},
3120 {"symbols", no_argument
, 0, 's'},
3121 {"syms", no_argument
, 0, 's'},
3122 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
3123 {"relocs", no_argument
, 0, 'r'},
3124 {"notes", no_argument
, 0, 'n'},
3125 {"dynamic", no_argument
, 0, 'd'},
3126 {"arch-specific", no_argument
, 0, 'A'},
3127 {"version-info", no_argument
, 0, 'V'},
3128 {"use-dynamic", no_argument
, 0, 'D'},
3129 {"unwind", no_argument
, 0, 'u'},
3130 {"archive-index", no_argument
, 0, 'c'},
3131 {"hex-dump", required_argument
, 0, 'x'},
3132 {"relocated-dump", required_argument
, 0, 'R'},
3133 {"string-dump", required_argument
, 0, 'p'},
3134 #ifdef SUPPORT_DISASSEMBLY
3135 {"instruction-dump", required_argument
, 0, 'i'},
3137 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
3139 {"version", no_argument
, 0, 'v'},
3140 {"wide", no_argument
, 0, 'W'},
3141 {"help", no_argument
, 0, 'H'},
3142 {0, no_argument
, 0, 0}
3146 usage (FILE * stream
)
3148 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
3149 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
3150 fprintf (stream
, _(" Options are:\n\
3151 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3152 -h --file-header Display the ELF file header\n\
3153 -l --program-headers Display the program headers\n\
3154 --segments An alias for --program-headers\n\
3155 -S --section-headers Display the sections' header\n\
3156 --sections An alias for --section-headers\n\
3157 -g --section-groups Display the section groups\n\
3158 -t --section-details Display the section details\n\
3159 -e --headers Equivalent to: -h -l -S\n\
3160 -s --syms Display the symbol table\n\
3161 --symbols An alias for --syms\n\
3162 --dyn-syms Display the dynamic symbol table\n\
3163 -n --notes Display the core notes (if present)\n\
3164 -r --relocs Display the relocations (if present)\n\
3165 -u --unwind Display the unwind info (if present)\n\
3166 -d --dynamic Display the dynamic section (if present)\n\
3167 -V --version-info Display the version sections (if present)\n\
3168 -A --arch-specific Display architecture specific information (if any).\n\
3169 -c --archive-index Display the symbol/file index in an archive\n\
3170 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3171 -x --hex-dump=<number|name>\n\
3172 Dump the contents of section <number|name> as bytes\n\
3173 -p --string-dump=<number|name>\n\
3174 Dump the contents of section <number|name> as strings\n\
3175 -R --relocated-dump=<number|name>\n\
3176 Dump the contents of section <number|name> as relocated bytes\n\
3177 -w[lLiaprmfFsoRt] or\n\
3178 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3179 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3180 =trace_info,=trace_abbrev,=trace_aranges]\n\
3181 Display the contents of DWARF2 debug sections\n"));
3182 #ifdef SUPPORT_DISASSEMBLY
3183 fprintf (stream
, _("\
3184 -i --instruction-dump=<number|name>\n\
3185 Disassemble the contents of section <number|name>\n"));
3187 fprintf (stream
, _("\
3188 -I --histogram Display histogram of bucket list lengths\n\
3189 -W --wide Allow output width to exceed 80 characters\n\
3190 @<file> Read options from <file>\n\
3191 -H --help Display this information\n\
3192 -v --version Display the version number of readelf\n"));
3194 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
3195 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
3197 exit (stream
== stdout
? 0 : 1);
3200 /* Record the fact that the user wants the contents of section number
3201 SECTION to be displayed using the method(s) encoded as flags bits
3202 in TYPE. Note, TYPE can be zero if we are creating the array for
3206 request_dump_bynumber (unsigned int section
, dump_type type
)
3208 if (section
>= num_dump_sects
)
3210 dump_type
* new_dump_sects
;
3212 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
3213 sizeof (* dump_sects
));
3215 if (new_dump_sects
== NULL
)
3216 error (_("Out of memory allocating dump request table.\n"));
3219 /* Copy current flag settings. */
3220 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
3224 dump_sects
= new_dump_sects
;
3225 num_dump_sects
= section
+ 1;
3230 dump_sects
[section
] |= type
;
3235 /* Request a dump by section name. */
3238 request_dump_byname (const char * section
, dump_type type
)
3240 struct dump_list_entry
* new_request
;
3242 new_request
= (struct dump_list_entry
*)
3243 malloc (sizeof (struct dump_list_entry
));
3245 error (_("Out of memory allocating dump request table.\n"));
3247 new_request
->name
= strdup (section
);
3248 if (!new_request
->name
)
3249 error (_("Out of memory allocating dump request table.\n"));
3251 new_request
->type
= type
;
3253 new_request
->next
= dump_sects_byname
;
3254 dump_sects_byname
= new_request
;
3258 request_dump (dump_type type
)
3264 section
= strtoul (optarg
, & cp
, 0);
3266 if (! *cp
&& section
>= 0)
3267 request_dump_bynumber (section
, type
);
3269 request_dump_byname (optarg
, type
);
3274 parse_args (int argc
, char ** argv
)
3281 while ((c
= getopt_long
3282 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options
, NULL
)) != EOF
)
3300 do_section_groups
++;
3308 do_section_groups
++;
3313 do_section_details
++;
3357 request_dump (HEX_DUMP
);
3360 request_dump (STRING_DUMP
);
3363 request_dump (RELOC_DUMP
);
3370 dwarf_select_sections_all ();
3375 dwarf_select_sections_by_letters (optarg
);
3378 case OPTION_DEBUG_DUMP
:
3385 dwarf_select_sections_by_names (optarg
);
3388 case OPTION_DYN_SYMS
:
3391 #ifdef SUPPORT_DISASSEMBLY
3393 request_dump (DISASS_DUMP
);
3397 print_version (program_name
);
3406 /* xgettext:c-format */
3407 error (_("Invalid option '-%c'\n"), c
);
3414 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
3415 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
3416 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
3417 && !do_section_groups
&& !do_archive_index
3422 warn (_("Nothing to do.\n"));
3428 get_elf_class (unsigned int elf_class
)
3430 static char buff
[32];
3434 case ELFCLASSNONE
: return _("none");
3435 case ELFCLASS32
: return "ELF32";
3436 case ELFCLASS64
: return "ELF64";
3438 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
3444 get_data_encoding (unsigned int encoding
)
3446 static char buff
[32];
3450 case ELFDATANONE
: return _("none");
3451 case ELFDATA2LSB
: return _("2's complement, little endian");
3452 case ELFDATA2MSB
: return _("2's complement, big endian");
3454 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
3459 /* Decode the data held in 'elf_header'. */
3462 process_file_header (void)
3464 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
3465 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
3466 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
3467 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
3470 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3474 init_dwarf_regnames (elf_header
.e_machine
);
3480 printf (_("ELF Header:\n"));
3481 printf (_(" Magic: "));
3482 for (i
= 0; i
< EI_NIDENT
; i
++)
3483 printf ("%2.2x ", elf_header
.e_ident
[i
]);
3485 printf (_(" Class: %s\n"),
3486 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
3487 printf (_(" Data: %s\n"),
3488 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
3489 printf (_(" Version: %d %s\n"),
3490 elf_header
.e_ident
[EI_VERSION
],
3491 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
3493 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
3494 ? _("<unknown: %lx>")
3496 printf (_(" OS/ABI: %s\n"),
3497 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
3498 printf (_(" ABI Version: %d\n"),
3499 elf_header
.e_ident
[EI_ABIVERSION
]);
3500 printf (_(" Type: %s\n"),
3501 get_file_type (elf_header
.e_type
));
3502 printf (_(" Machine: %s\n"),
3503 get_machine_name (elf_header
.e_machine
));
3504 printf (_(" Version: 0x%lx\n"),
3505 (unsigned long) elf_header
.e_version
);
3507 printf (_(" Entry point address: "));
3508 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3509 printf (_("\n Start of program headers: "));
3510 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3511 printf (_(" (bytes into file)\n Start of section headers: "));
3512 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
3513 printf (_(" (bytes into file)\n"));
3515 printf (_(" Flags: 0x%lx%s\n"),
3516 (unsigned long) elf_header
.e_flags
,
3517 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
3518 printf (_(" Size of this header: %ld (bytes)\n"),
3519 (long) elf_header
.e_ehsize
);
3520 printf (_(" Size of program headers: %ld (bytes)\n"),
3521 (long) elf_header
.e_phentsize
);
3522 printf (_(" Number of program headers: %ld"),
3523 (long) elf_header
.e_phnum
);
3524 if (section_headers
!= NULL
3525 && elf_header
.e_phnum
== PN_XNUM
3526 && section_headers
[0].sh_info
!= 0)
3527 printf (_(" (%ld)"), (long) section_headers
[0].sh_info
);
3528 putc ('\n', stdout
);
3529 printf (_(" Size of section headers: %ld (bytes)\n"),
3530 (long) elf_header
.e_shentsize
);
3531 printf (_(" Number of section headers: %ld"),
3532 (long) elf_header
.e_shnum
);
3533 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
3534 printf (" (%ld)", (long) section_headers
[0].sh_size
);
3535 putc ('\n', stdout
);
3536 printf (_(" Section header string table index: %ld"),
3537 (long) elf_header
.e_shstrndx
);
3538 if (section_headers
!= NULL
3539 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3540 printf (" (%u)", section_headers
[0].sh_link
);
3541 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
3542 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3543 printf (_(" <corrupt: out of range>"));
3544 putc ('\n', stdout
);
3547 if (section_headers
!= NULL
)
3549 if (elf_header
.e_phnum
== PN_XNUM
3550 && section_headers
[0].sh_info
!= 0)
3551 elf_header
.e_phnum
= section_headers
[0].sh_info
;
3552 if (elf_header
.e_shnum
== SHN_UNDEF
)
3553 elf_header
.e_shnum
= section_headers
[0].sh_size
;
3554 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
3555 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
3556 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
3557 elf_header
.e_shstrndx
= SHN_UNDEF
;
3558 free (section_headers
);
3559 section_headers
= NULL
;
3567 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3569 Elf32_External_Phdr
* phdrs
;
3570 Elf32_External_Phdr
* external
;
3571 Elf_Internal_Phdr
* internal
;
3574 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3575 elf_header
.e_phentsize
,
3577 _("program headers"));
3581 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3582 i
< elf_header
.e_phnum
;
3583 i
++, internal
++, external
++)
3585 internal
->p_type
= BYTE_GET (external
->p_type
);
3586 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3587 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3588 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3589 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3590 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3591 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3592 internal
->p_align
= BYTE_GET (external
->p_align
);
3601 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
3603 Elf64_External_Phdr
* phdrs
;
3604 Elf64_External_Phdr
* external
;
3605 Elf_Internal_Phdr
* internal
;
3608 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
3609 elf_header
.e_phentsize
,
3611 _("program headers"));
3615 for (i
= 0, internal
= pheaders
, external
= phdrs
;
3616 i
< elf_header
.e_phnum
;
3617 i
++, internal
++, external
++)
3619 internal
->p_type
= BYTE_GET (external
->p_type
);
3620 internal
->p_flags
= BYTE_GET (external
->p_flags
);
3621 internal
->p_offset
= BYTE_GET (external
->p_offset
);
3622 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
3623 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
3624 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
3625 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
3626 internal
->p_align
= BYTE_GET (external
->p_align
);
3634 /* Returns 1 if the program headers were read into `program_headers'. */
3637 get_program_headers (FILE * file
)
3639 Elf_Internal_Phdr
* phdrs
;
3641 /* Check cache of prior read. */
3642 if (program_headers
!= NULL
)
3645 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
3646 sizeof (Elf_Internal_Phdr
));
3650 error (_("Out of memory\n"));
3655 ? get_32bit_program_headers (file
, phdrs
)
3656 : get_64bit_program_headers (file
, phdrs
))
3658 program_headers
= phdrs
;
3666 /* Returns 1 if the program headers were loaded. */
3669 process_program_headers (FILE * file
)
3671 Elf_Internal_Phdr
* segment
;
3674 if (elf_header
.e_phnum
== 0)
3677 printf (_("\nThere are no program headers in this file.\n"));
3681 if (do_segments
&& !do_header
)
3683 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
3684 printf (_("Entry point "));
3685 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
3686 printf (_("\nThere are %d program headers, starting at offset "),
3687 elf_header
.e_phnum
);
3688 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
3692 if (! get_program_headers (file
))
3697 if (elf_header
.e_phnum
> 1)
3698 printf (_("\nProgram Headers:\n"));
3700 printf (_("\nProgram Headers:\n"));
3704 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3707 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3711 (_(" Type Offset VirtAddr PhysAddr\n"));
3713 (_(" FileSiz MemSiz Flags Align\n"));
3720 for (i
= 0, segment
= program_headers
;
3721 i
< elf_header
.e_phnum
;
3726 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
3730 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3731 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
3732 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
3733 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
3734 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
3736 (segment
->p_flags
& PF_R
? 'R' : ' '),
3737 (segment
->p_flags
& PF_W
? 'W' : ' '),
3738 (segment
->p_flags
& PF_X
? 'E' : ' '));
3739 printf ("%#lx", (unsigned long) segment
->p_align
);
3743 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
3744 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
3747 print_vma (segment
->p_offset
, FULL_HEX
);
3751 print_vma (segment
->p_vaddr
, FULL_HEX
);
3753 print_vma (segment
->p_paddr
, FULL_HEX
);
3756 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
3757 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
3760 print_vma (segment
->p_filesz
, FULL_HEX
);
3764 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
3765 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
3768 print_vma (segment
->p_offset
, FULL_HEX
);
3772 (segment
->p_flags
& PF_R
? 'R' : ' '),
3773 (segment
->p_flags
& PF_W
? 'W' : ' '),
3774 (segment
->p_flags
& PF_X
? 'E' : ' '));
3776 if ((unsigned long) segment
->p_align
== segment
->p_align
)
3777 printf ("%#lx", (unsigned long) segment
->p_align
);
3780 print_vma (segment
->p_align
, PREFIX_HEX
);
3785 print_vma (segment
->p_offset
, FULL_HEX
);
3787 print_vma (segment
->p_vaddr
, FULL_HEX
);
3789 print_vma (segment
->p_paddr
, FULL_HEX
);
3791 print_vma (segment
->p_filesz
, FULL_HEX
);
3793 print_vma (segment
->p_memsz
, FULL_HEX
);
3795 (segment
->p_flags
& PF_R
? 'R' : ' '),
3796 (segment
->p_flags
& PF_W
? 'W' : ' '),
3797 (segment
->p_flags
& PF_X
? 'E' : ' '));
3798 print_vma (segment
->p_align
, HEX
);
3802 switch (segment
->p_type
)
3806 error (_("more than one dynamic segment\n"));
3808 /* By default, assume that the .dynamic section is the first
3809 section in the DYNAMIC segment. */
3810 dynamic_addr
= segment
->p_offset
;
3811 dynamic_size
= segment
->p_filesz
;
3813 /* Try to locate the .dynamic section. If there is
3814 a section header table, we can easily locate it. */
3815 if (section_headers
!= NULL
)
3817 Elf_Internal_Shdr
* sec
;
3819 sec
= find_section (".dynamic");
3820 if (sec
== NULL
|| sec
->sh_size
== 0)
3822 /* A corresponding .dynamic section is expected, but on
3823 IA-64/OpenVMS it is OK for it to be missing. */
3824 if (!is_ia64_vms ())
3825 error (_("no .dynamic section in the dynamic segment\n"));
3829 if (sec
->sh_type
== SHT_NOBITS
)
3835 dynamic_addr
= sec
->sh_offset
;
3836 dynamic_size
= sec
->sh_size
;
3838 if (dynamic_addr
< segment
->p_offset
3839 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
3840 warn (_("the .dynamic section is not contained"
3841 " within the dynamic segment\n"));
3842 else if (dynamic_addr
> segment
->p_offset
)
3843 warn (_("the .dynamic section is not the first section"
3844 " in the dynamic segment.\n"));
3849 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
3851 error (_("Unable to find program interpreter name\n"));
3855 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
);
3857 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
3858 error (_("Internal error: failed to create format string to display program interpreter\n"));
3860 program_interpreter
[0] = 0;
3861 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
3862 error (_("Unable to read program interpreter name\n"));
3865 printf (_("\n [Requesting program interpreter: %s]"),
3866 program_interpreter
);
3872 putc ('\n', stdout
);
3875 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
3877 printf (_("\n Section to Segment mapping:\n"));
3878 printf (_(" Segment Sections...\n"));
3880 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
3883 Elf_Internal_Shdr
* section
;
3885 segment
= program_headers
+ i
;
3886 section
= section_headers
+ 1;
3888 printf (" %2.2d ", i
);
3890 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
3892 if (ELF_SECTION_SIZE (section
, segment
) != 0
3893 && ELF_SECTION_IN_SEGMENT (section
, segment
))
3894 printf ("%s ", SECTION_NAME (section
));
3905 /* Find the file offset corresponding to VMA by using the program headers. */
3908 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
3910 Elf_Internal_Phdr
* seg
;
3912 if (! get_program_headers (file
))
3914 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3918 for (seg
= program_headers
;
3919 seg
< program_headers
+ elf_header
.e_phnum
;
3922 if (seg
->p_type
!= PT_LOAD
)
3925 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
3926 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
3927 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
3930 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3931 (unsigned long) vma
);
3937 get_32bit_section_headers (FILE * file
, unsigned int num
)
3939 Elf32_External_Shdr
* shdrs
;
3940 Elf_Internal_Shdr
* internal
;
3943 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3944 elf_header
.e_shentsize
, num
,
3945 _("section headers"));
3949 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3950 sizeof (Elf_Internal_Shdr
));
3952 if (section_headers
== NULL
)
3954 error (_("Out of memory\n"));
3958 for (i
= 0, internal
= section_headers
;
3962 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
3963 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
3964 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
3965 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
3966 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
3967 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
3968 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
3969 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
3970 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
3971 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
3980 get_64bit_section_headers (FILE * file
, unsigned int num
)
3982 Elf64_External_Shdr
* shdrs
;
3983 Elf_Internal_Shdr
* internal
;
3986 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
3987 elf_header
.e_shentsize
, num
,
3988 _("section headers"));
3992 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
3993 sizeof (Elf_Internal_Shdr
));
3995 if (section_headers
== NULL
)
3997 error (_("Out of memory\n"));
4001 for (i
= 0, internal
= section_headers
;
4005 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4006 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4007 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4008 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4009 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4010 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4011 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4012 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4013 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4014 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4022 static Elf_Internal_Sym
*
4023 get_32bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4025 unsigned long number
;
4026 Elf32_External_Sym
* esyms
;
4027 Elf_External_Sym_Shndx
* shndx
;
4028 Elf_Internal_Sym
* isyms
;
4029 Elf_Internal_Sym
* psym
;
4032 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4033 section
->sh_size
, _("symbols"));
4038 if (symtab_shndx_hdr
!= NULL
4039 && (symtab_shndx_hdr
->sh_link
4040 == (unsigned long) (section
- section_headers
)))
4042 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4043 symtab_shndx_hdr
->sh_offset
,
4044 1, symtab_shndx_hdr
->sh_size
,
4053 number
= section
->sh_size
/ section
->sh_entsize
;
4054 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4058 error (_("Out of memory\n"));
4065 for (j
= 0, psym
= isyms
;
4069 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4070 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4071 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4072 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4073 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4075 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4076 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4077 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4078 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4079 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4089 static Elf_Internal_Sym
*
4090 get_64bit_elf_symbols (FILE * file
, Elf_Internal_Shdr
* section
)
4092 unsigned long number
;
4093 Elf64_External_Sym
* esyms
;
4094 Elf_External_Sym_Shndx
* shndx
;
4095 Elf_Internal_Sym
* isyms
;
4096 Elf_Internal_Sym
* psym
;
4099 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
4100 section
->sh_size
, _("symbols"));
4105 if (symtab_shndx_hdr
!= NULL
4106 && (symtab_shndx_hdr
->sh_link
4107 == (unsigned long) (section
- section_headers
)))
4109 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
4110 symtab_shndx_hdr
->sh_offset
,
4111 1, symtab_shndx_hdr
->sh_size
,
4120 number
= section
->sh_size
/ section
->sh_entsize
;
4121 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
4125 error (_("Out of memory\n"));
4132 for (j
= 0, psym
= isyms
;
4136 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
4137 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
4138 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
4139 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
4140 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
4142 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
4143 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
4144 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
4145 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
4146 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
4157 get_elf_section_flags (bfd_vma sh_flags
)
4159 static char buff
[1024];
4161 int field_size
= is_32bit_elf
? 8 : 16;
4163 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
4164 bfd_vma os_flags
= 0;
4165 bfd_vma proc_flags
= 0;
4166 bfd_vma unknown_flags
= 0;
4174 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4175 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4176 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4177 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4178 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4179 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4180 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4181 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4182 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4183 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4184 /* IA-64 specific. */
4185 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4186 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4187 /* IA-64 OpenVMS specific. */
4188 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4189 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4190 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4191 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4192 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4193 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4195 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4196 /* SPARC specific. */
4197 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4200 if (do_section_details
)
4202 sprintf (buff
, "[%*.*lx]: ",
4203 field_size
, field_size
, (unsigned long) sh_flags
);
4204 p
+= field_size
+ 4;
4211 flag
= sh_flags
& - sh_flags
;
4214 if (do_section_details
)
4218 case SHF_WRITE
: sindex
= 0; break;
4219 case SHF_ALLOC
: sindex
= 1; break;
4220 case SHF_EXECINSTR
: sindex
= 2; break;
4221 case SHF_MERGE
: sindex
= 3; break;
4222 case SHF_STRINGS
: sindex
= 4; break;
4223 case SHF_INFO_LINK
: sindex
= 5; break;
4224 case SHF_LINK_ORDER
: sindex
= 6; break;
4225 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
4226 case SHF_GROUP
: sindex
= 8; break;
4227 case SHF_TLS
: sindex
= 9; break;
4228 case SHF_EXCLUDE
: sindex
= 18; break;
4232 switch (elf_header
.e_machine
)
4235 if (flag
== SHF_IA_64_SHORT
)
4237 else if (flag
== SHF_IA_64_NORECOV
)
4240 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
4243 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
4244 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
4245 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
4246 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
4247 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
4248 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
4258 case EM_OLD_SPARCV9
:
4259 case EM_SPARC32PLUS
:
4262 if (flag
== SHF_ORDERED
)
4272 if (p
!= buff
+ field_size
+ 4)
4274 if (size
< (10 + 2))
4281 size
-= flags
[sindex
].len
;
4282 p
= stpcpy (p
, flags
[sindex
].str
);
4284 else if (flag
& SHF_MASKOS
)
4286 else if (flag
& SHF_MASKPROC
)
4289 unknown_flags
|= flag
;
4295 case SHF_WRITE
: *p
= 'W'; break;
4296 case SHF_ALLOC
: *p
= 'A'; break;
4297 case SHF_EXECINSTR
: *p
= 'X'; break;
4298 case SHF_MERGE
: *p
= 'M'; break;
4299 case SHF_STRINGS
: *p
= 'S'; break;
4300 case SHF_INFO_LINK
: *p
= 'I'; break;
4301 case SHF_LINK_ORDER
: *p
= 'L'; break;
4302 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
4303 case SHF_GROUP
: *p
= 'G'; break;
4304 case SHF_TLS
: *p
= 'T'; break;
4305 case SHF_EXCLUDE
: *p
= 'E'; break;
4308 if ((elf_header
.e_machine
== EM_X86_64
4309 || elf_header
.e_machine
== EM_L1OM
)
4310 && flag
== SHF_X86_64_LARGE
)
4312 else if (flag
& SHF_MASKOS
)
4315 sh_flags
&= ~ SHF_MASKOS
;
4317 else if (flag
& SHF_MASKPROC
)
4320 sh_flags
&= ~ SHF_MASKPROC
;
4330 if (do_section_details
)
4334 size
-= 5 + field_size
;
4335 if (p
!= buff
+ field_size
+ 4)
4343 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
4344 (unsigned long) os_flags
);
4345 p
+= 5 + field_size
;
4349 size
-= 7 + field_size
;
4350 if (p
!= buff
+ field_size
+ 4)
4358 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
4359 (unsigned long) proc_flags
);
4360 p
+= 7 + field_size
;
4364 size
-= 10 + field_size
;
4365 if (p
!= buff
+ field_size
+ 4)
4373 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
4374 (unsigned long) unknown_flags
);
4375 p
+= 10 + field_size
;
4384 process_section_headers (FILE * file
)
4386 Elf_Internal_Shdr
* section
;
4389 section_headers
= NULL
;
4391 if (elf_header
.e_shnum
== 0)
4394 printf (_("\nThere are no sections in this file.\n"));
4399 if (do_sections
&& !do_header
)
4400 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4401 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
4405 if (! get_32bit_section_headers (file
, elf_header
.e_shnum
))
4408 else if (! get_64bit_section_headers (file
, elf_header
.e_shnum
))
4411 /* Read in the string table, so that we have names to display. */
4412 if (elf_header
.e_shstrndx
!= SHN_UNDEF
4413 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
4415 section
= section_headers
+ elf_header
.e_shstrndx
;
4417 if (section
->sh_size
!= 0)
4419 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4420 1, section
->sh_size
,
4423 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
4427 /* Scan the sections for the dynamic symbol table
4428 and dynamic string table and debug sections. */
4429 dynamic_symbols
= NULL
;
4430 dynamic_strings
= NULL
;
4431 dynamic_syminfo
= NULL
;
4432 symtab_shndx_hdr
= NULL
;
4434 eh_addr_size
= is_32bit_elf
? 4 : 8;
4435 switch (elf_header
.e_machine
)
4438 case EM_MIPS_RS3_LE
:
4439 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4440 FDE addresses. However, the ABI also has a semi-official ILP32
4441 variant for which the normal FDE address size rules apply.
4443 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4444 section, where XX is the size of longs in bits. Unfortunately,
4445 earlier compilers provided no way of distinguishing ILP32 objects
4446 from LP64 objects, so if there's any doubt, we should assume that
4447 the official LP64 form is being used. */
4448 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
4449 && find_section (".gcc_compiled_long32") == NULL
)
4455 switch (elf_header
.e_flags
& EF_H8_MACH
)
4457 case E_H8_MACH_H8300
:
4458 case E_H8_MACH_H8300HN
:
4459 case E_H8_MACH_H8300SN
:
4460 case E_H8_MACH_H8300SXN
:
4463 case E_H8_MACH_H8300H
:
4464 case E_H8_MACH_H8300S
:
4465 case E_H8_MACH_H8300SX
:
4473 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
4475 case EF_M32C_CPU_M16C
:
4482 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4485 size_t expected_entsize \
4486 = is_32bit_elf ? size32 : size64; \
4487 if (section->sh_entsize != expected_entsize) \
4488 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4489 i, (unsigned long int) section->sh_entsize, \
4490 (unsigned long int) expected_entsize); \
4491 section->sh_entsize = expected_entsize; \
4494 #define CHECK_ENTSIZE(section, i, type) \
4495 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4496 sizeof (Elf64_External_##type))
4498 for (i
= 0, section
= section_headers
;
4499 i
< elf_header
.e_shnum
;
4502 char * name
= SECTION_NAME (section
);
4504 if (section
->sh_type
== SHT_DYNSYM
)
4506 if (dynamic_symbols
!= NULL
)
4508 error (_("File contains multiple dynamic symbol tables\n"));
4512 CHECK_ENTSIZE (section
, i
, Sym
);
4513 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
4514 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
);
4516 else if (section
->sh_type
== SHT_STRTAB
4517 && streq (name
, ".dynstr"))
4519 if (dynamic_strings
!= NULL
)
4521 error (_("File contains multiple dynamic string tables\n"));
4525 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
4526 1, section
->sh_size
,
4527 _("dynamic strings"));
4528 dynamic_strings_length
= section
->sh_size
;
4530 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
4532 if (symtab_shndx_hdr
!= NULL
)
4534 error (_("File contains multiple symtab shndx tables\n"));
4537 symtab_shndx_hdr
= section
;
4539 else if (section
->sh_type
== SHT_SYMTAB
)
4540 CHECK_ENTSIZE (section
, i
, Sym
);
4541 else if (section
->sh_type
== SHT_GROUP
)
4542 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
4543 else if (section
->sh_type
== SHT_REL
)
4544 CHECK_ENTSIZE (section
, i
, Rel
);
4545 else if (section
->sh_type
== SHT_RELA
)
4546 CHECK_ENTSIZE (section
, i
, Rela
);
4547 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
4548 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
4549 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
4550 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
)
4551 && (const_strneq (name
, ".debug_")
4552 || const_strneq (name
, ".zdebug_")))
4555 name
+= sizeof (".zdebug_") - 1;
4557 name
+= sizeof (".debug_") - 1;
4560 || (do_debug_info
&& streq (name
, "info"))
4561 || (do_debug_info
&& streq (name
, "types"))
4562 || (do_debug_abbrevs
&& streq (name
, "abbrev"))
4563 || (do_debug_lines
&& streq (name
, "line"))
4564 || (do_debug_pubnames
&& streq (name
, "pubnames"))
4565 || (do_debug_pubtypes
&& streq (name
, "pubtypes"))
4566 || (do_debug_aranges
&& streq (name
, "aranges"))
4567 || (do_debug_ranges
&& streq (name
, "ranges"))
4568 || (do_debug_frames
&& streq (name
, "frame"))
4569 || (do_debug_macinfo
&& streq (name
, "macinfo"))
4570 || (do_debug_str
&& streq (name
, "str"))
4571 || (do_debug_loc
&& streq (name
, "loc"))
4573 request_dump_bynumber (i
, DEBUG_DUMP
);
4575 /* Linkonce section to be combined with .debug_info at link time. */
4576 else if ((do_debugging
|| do_debug_info
)
4577 && const_strneq (name
, ".gnu.linkonce.wi."))
4578 request_dump_bynumber (i
, DEBUG_DUMP
);
4579 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
4580 request_dump_bynumber (i
, DEBUG_DUMP
);
4581 /* Trace sections for Itanium VMS. */
4582 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
4583 || do_trace_aranges
)
4584 && const_strneq (name
, ".trace_"))
4586 name
+= sizeof (".trace_") - 1;
4589 || (do_trace_info
&& streq (name
, "info"))
4590 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
4591 || (do_trace_aranges
&& streq (name
, "aranges"))
4593 request_dump_bynumber (i
, DEBUG_DUMP
);
4601 if (elf_header
.e_shnum
> 1)
4602 printf (_("\nSection Headers:\n"));
4604 printf (_("\nSection Header:\n"));
4608 if (do_section_details
)
4610 printf (_(" [Nr] Name\n"));
4611 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4615 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4619 if (do_section_details
)
4621 printf (_(" [Nr] Name\n"));
4622 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4626 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4630 if (do_section_details
)
4632 printf (_(" [Nr] Name\n"));
4633 printf (_(" Type Address Offset Link\n"));
4634 printf (_(" Size EntSize Info Align\n"));
4638 printf (_(" [Nr] Name Type Address Offset\n"));
4639 printf (_(" Size EntSize Flags Link Info Align\n"));
4643 if (do_section_details
)
4644 printf (_(" Flags\n"));
4646 for (i
= 0, section
= section_headers
;
4647 i
< elf_header
.e_shnum
;
4650 if (do_section_details
)
4652 printf (" [%2u] %s\n",
4654 SECTION_NAME (section
));
4655 if (is_32bit_elf
|| do_wide
)
4656 printf (" %-15.15s ",
4657 get_section_type_name (section
->sh_type
));
4660 printf ((do_wide
? " [%2u] %-17s %-15s "
4661 : " [%2u] %-17.17s %-15.15s "),
4663 SECTION_NAME (section
),
4664 get_section_type_name (section
->sh_type
));
4668 const char * link_too_big
= NULL
;
4670 print_vma (section
->sh_addr
, LONG_HEX
);
4672 printf ( " %6.6lx %6.6lx %2.2lx",
4673 (unsigned long) section
->sh_offset
,
4674 (unsigned long) section
->sh_size
,
4675 (unsigned long) section
->sh_entsize
);
4677 if (do_section_details
)
4678 fputs (" ", stdout
);
4680 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4682 if (section
->sh_link
>= elf_header
.e_shnum
)
4685 /* The sh_link value is out of range. Normally this indicates
4686 an error but it can have special values in Solaris binaries. */
4687 switch (elf_header
.e_machine
)
4693 case EM_OLD_SPARCV9
:
4694 case EM_SPARC32PLUS
:
4697 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
4698 link_too_big
= "BEFORE";
4699 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
4700 link_too_big
= "AFTER";
4707 if (do_section_details
)
4709 if (link_too_big
!= NULL
&& * link_too_big
)
4710 printf ("<%s> ", link_too_big
);
4712 printf ("%2u ", section
->sh_link
);
4713 printf ("%3u %2lu\n", section
->sh_info
,
4714 (unsigned long) section
->sh_addralign
);
4717 printf ("%2u %3u %2lu\n",
4720 (unsigned long) section
->sh_addralign
);
4722 if (link_too_big
&& ! * link_too_big
)
4723 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4724 i
, section
->sh_link
);
4728 print_vma (section
->sh_addr
, LONG_HEX
);
4730 if ((long) section
->sh_offset
== section
->sh_offset
)
4731 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
4735 print_vma (section
->sh_offset
, LONG_HEX
);
4738 if ((unsigned long) section
->sh_size
== section
->sh_size
)
4739 printf (" %6.6lx", (unsigned long) section
->sh_size
);
4743 print_vma (section
->sh_size
, LONG_HEX
);
4746 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
4747 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
4751 print_vma (section
->sh_entsize
, LONG_HEX
);
4754 if (do_section_details
)
4755 fputs (" ", stdout
);
4757 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4759 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
4761 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
4762 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
4765 print_vma (section
->sh_addralign
, DEC
);
4769 else if (do_section_details
)
4771 printf (" %-15.15s ",
4772 get_section_type_name (section
->sh_type
));
4773 print_vma (section
->sh_addr
, LONG_HEX
);
4774 if ((long) section
->sh_offset
== section
->sh_offset
)
4775 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
4779 print_vma (section
->sh_offset
, LONG_HEX
);
4781 printf (" %u\n ", section
->sh_link
);
4782 print_vma (section
->sh_size
, LONG_HEX
);
4784 print_vma (section
->sh_entsize
, LONG_HEX
);
4786 printf (" %-16u %lu\n",
4788 (unsigned long) section
->sh_addralign
);
4793 print_vma (section
->sh_addr
, LONG_HEX
);
4794 if ((long) section
->sh_offset
== section
->sh_offset
)
4795 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
4799 print_vma (section
->sh_offset
, LONG_HEX
);
4802 print_vma (section
->sh_size
, LONG_HEX
);
4804 print_vma (section
->sh_entsize
, LONG_HEX
);
4806 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
4808 printf (" %2u %3u %lu\n",
4811 (unsigned long) section
->sh_addralign
);
4814 if (do_section_details
)
4815 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
4818 if (!do_section_details
)
4819 printf (_("Key to Flags:\n\
4820 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4821 I (info), L (link order), G (group), x (unknown)\n\
4822 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4828 get_group_flags (unsigned int flags
)
4830 static char buff
[32];
4840 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
4847 process_section_groups (FILE * file
)
4849 Elf_Internal_Shdr
* section
;
4851 struct group
* group
;
4852 Elf_Internal_Shdr
* symtab_sec
;
4853 Elf_Internal_Shdr
* strtab_sec
;
4854 Elf_Internal_Sym
* symtab
;
4858 /* Don't process section groups unless needed. */
4859 if (!do_unwind
&& !do_section_groups
)
4862 if (elf_header
.e_shnum
== 0)
4864 if (do_section_groups
)
4865 printf (_("\nThere are no sections in this file.\n"));
4870 if (section_headers
== NULL
)
4872 error (_("Section headers are not available!\n"));
4876 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
4877 sizeof (struct group
*));
4879 if (section_headers_groups
== NULL
)
4881 error (_("Out of memory\n"));
4885 /* Scan the sections for the group section. */
4887 for (i
= 0, section
= section_headers
;
4888 i
< elf_header
.e_shnum
;
4890 if (section
->sh_type
== SHT_GROUP
)
4893 if (group_count
== 0)
4895 if (do_section_groups
)
4896 printf (_("\nThere are no section groups in this file.\n"));
4901 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
4903 if (section_groups
== NULL
)
4905 error (_("Out of memory\n"));
4914 for (i
= 0, section
= section_headers
, group
= section_groups
;
4915 i
< elf_header
.e_shnum
;
4918 if (section
->sh_type
== SHT_GROUP
)
4920 char * name
= SECTION_NAME (section
);
4922 unsigned char * start
;
4923 unsigned char * indices
;
4924 unsigned int entry
, j
, size
;
4925 Elf_Internal_Shdr
* sec
;
4926 Elf_Internal_Sym
* sym
;
4928 /* Get the symbol table. */
4929 if (section
->sh_link
>= elf_header
.e_shnum
4930 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
4933 error (_("Bad sh_link in group section `%s'\n"), name
);
4937 if (symtab_sec
!= sec
)
4942 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
);
4945 sym
= symtab
+ section
->sh_info
;
4947 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4949 if (sym
->st_shndx
== 0
4950 || sym
->st_shndx
>= elf_header
.e_shnum
)
4952 error (_("Bad sh_info in group section `%s'\n"), name
);
4956 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
4965 /* Get the string table. */
4966 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
4975 != (sec
= section_headers
+ symtab_sec
->sh_link
))
4980 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
4981 1, strtab_sec
->sh_size
,
4983 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
4985 group_name
= sym
->st_name
< strtab_size
4986 ? strtab
+ sym
->st_name
: _("<corrupt>");
4989 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
4990 1, section
->sh_size
,
4994 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
4995 entry
= byte_get (indices
, 4);
4998 if (do_section_groups
)
5000 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5001 get_group_flags (entry
), i
, name
, group_name
, size
);
5003 printf (_(" [Index] Name\n"));
5006 group
->group_index
= i
;
5008 for (j
= 0; j
< size
; j
++)
5010 struct group_list
* g
;
5012 entry
= byte_get (indices
, 4);
5015 if (entry
>= elf_header
.e_shnum
)
5017 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5018 entry
, i
, elf_header
.e_shnum
- 1);
5022 if (section_headers_groups
[entry
] != NULL
)
5026 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5028 section_headers_groups
[entry
]->group_index
);
5033 /* Intel C/C++ compiler may put section 0 in a
5034 section group. We just warn it the first time
5035 and ignore it afterwards. */
5036 static int warned
= 0;
5039 error (_("section 0 in group section [%5u]\n"),
5040 section_headers_groups
[entry
]->group_index
);
5046 section_headers_groups
[entry
] = group
;
5048 if (do_section_groups
)
5050 sec
= section_headers
+ entry
;
5051 printf (" [%5u] %s\n", entry
, SECTION_NAME (sec
));
5054 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
5055 g
->section_index
= entry
;
5056 g
->next
= group
->root
;
5074 /* Data used to display dynamic fixups. */
5076 struct ia64_vms_dynfixup
5078 bfd_vma needed_ident
; /* Library ident number. */
5079 bfd_vma needed
; /* Index in the dstrtab of the library name. */
5080 bfd_vma fixup_needed
; /* Index of the library. */
5081 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
5082 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
5085 /* Data used to display dynamic relocations. */
5087 struct ia64_vms_dynimgrela
5089 bfd_vma img_rela_cnt
; /* Number of relocations. */
5090 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
5093 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5097 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
5098 const char *strtab
, unsigned int strtab_sz
)
5100 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
5102 const char *lib_name
;
5104 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
5105 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
5106 _("dynamic section image fixups"));
5110 if (fixup
->needed
< strtab_sz
)
5111 lib_name
= strtab
+ fixup
->needed
;
5114 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5115 (unsigned long) fixup
->needed
);
5118 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5119 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
5121 (_("Seg Offset Type SymVec DataType\n"));
5123 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
5128 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
5129 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
5130 type
= BYTE_GET (imfs
[i
].type
);
5131 rtype
= elf_ia64_reloc_type (type
);
5133 printf (" 0x%08x ", type
);
5135 printf (" %-32s ", rtype
);
5136 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
5137 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
5143 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5146 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
5148 Elf64_External_VMS_IMAGE_RELA
*imrs
;
5151 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
5152 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
5153 _("dynamic section image relas"));
5157 printf (_("\nImage relocs\n"));
5159 (_("Seg Offset Type Addend Seg Sym Off\n"));
5161 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
5166 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
5167 printf ("%08" BFD_VMA_FMT
"x ",
5168 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
5169 type
= BYTE_GET (imrs
[i
].type
);
5170 rtype
= elf_ia64_reloc_type (type
);
5172 printf ("0x%08x ", type
);
5174 printf ("%-31s ", rtype
);
5175 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
5176 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
5177 printf ("%08" BFD_VMA_FMT
"x\n",
5178 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
5184 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5187 process_ia64_vms_dynamic_relocs (FILE *file
)
5189 struct ia64_vms_dynfixup fixup
;
5190 struct ia64_vms_dynimgrela imgrela
;
5191 Elf_Internal_Dyn
*entry
;
5193 bfd_vma strtab_off
= 0;
5194 bfd_vma strtab_sz
= 0;
5195 char *strtab
= NULL
;
5197 memset (&fixup
, 0, sizeof (fixup
));
5198 memset (&imgrela
, 0, sizeof (imgrela
));
5200 /* Note: the order of the entries is specified by the OpenVMS specs. */
5201 for (entry
= dynamic_section
;
5202 entry
< dynamic_section
+ dynamic_nent
;
5205 switch (entry
->d_tag
)
5207 case DT_IA_64_VMS_STRTAB_OFFSET
:
5208 strtab_off
= entry
->d_un
.d_val
;
5211 strtab_sz
= entry
->d_un
.d_val
;
5213 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
5214 1, strtab_sz
, _("dynamic string section"));
5217 case DT_IA_64_VMS_NEEDED_IDENT
:
5218 fixup
.needed_ident
= entry
->d_un
.d_val
;
5221 fixup
.needed
= entry
->d_un
.d_val
;
5223 case DT_IA_64_VMS_FIXUP_NEEDED
:
5224 fixup
.fixup_needed
= entry
->d_un
.d_val
;
5226 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
5227 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
5229 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
5230 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
5232 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
5235 case DT_IA_64_VMS_IMG_RELA_CNT
:
5236 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
5238 case DT_IA_64_VMS_IMG_RELA_OFF
:
5239 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
5241 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
5261 } dynamic_relocations
[] =
5263 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
5264 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
5265 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
5268 /* Process the reloc section. */
5271 process_relocs (FILE * file
)
5273 unsigned long rel_size
;
5274 unsigned long rel_offset
;
5280 if (do_using_dynamic
)
5284 int has_dynamic_reloc
;
5287 has_dynamic_reloc
= 0;
5289 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
5291 is_rela
= dynamic_relocations
[i
].rela
;
5292 name
= dynamic_relocations
[i
].name
;
5293 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
5294 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
5296 has_dynamic_reloc
|= rel_size
;
5298 if (is_rela
== UNKNOWN
)
5300 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
5301 switch (dynamic_info
[DT_PLTREL
])
5315 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5316 name
, rel_offset
, rel_size
);
5318 dump_relocations (file
,
5319 offset_from_vma (file
, rel_offset
, rel_size
),
5321 dynamic_symbols
, num_dynamic_syms
,
5322 dynamic_strings
, dynamic_strings_length
, is_rela
);
5327 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
5329 if (! has_dynamic_reloc
)
5330 printf (_("\nThere are no dynamic relocations in this file.\n"));
5334 Elf_Internal_Shdr
* section
;
5338 for (i
= 0, section
= section_headers
;
5339 i
< elf_header
.e_shnum
;
5342 if ( section
->sh_type
!= SHT_RELA
5343 && section
->sh_type
!= SHT_REL
)
5346 rel_offset
= section
->sh_offset
;
5347 rel_size
= section
->sh_size
;
5351 Elf_Internal_Shdr
* strsec
;
5354 printf (_("\nRelocation section "));
5356 if (string_table
== NULL
)
5357 printf ("%d", section
->sh_name
);
5359 printf (_("'%s'"), SECTION_NAME (section
));
5361 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5362 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
5364 is_rela
= section
->sh_type
== SHT_RELA
;
5366 if (section
->sh_link
!= 0
5367 && section
->sh_link
< elf_header
.e_shnum
)
5369 Elf_Internal_Shdr
* symsec
;
5370 Elf_Internal_Sym
* symtab
;
5371 unsigned long nsyms
;
5372 unsigned long strtablen
= 0;
5373 char * strtab
= NULL
;
5375 symsec
= section_headers
+ section
->sh_link
;
5376 if (symsec
->sh_type
!= SHT_SYMTAB
5377 && symsec
->sh_type
!= SHT_DYNSYM
)
5380 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
5381 symtab
= GET_ELF_SYMBOLS (file
, symsec
);
5386 if (symsec
->sh_link
!= 0
5387 && symsec
->sh_link
< elf_header
.e_shnum
)
5389 strsec
= section_headers
+ symsec
->sh_link
;
5391 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5394 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
5397 dump_relocations (file
, rel_offset
, rel_size
,
5398 symtab
, nsyms
, strtab
, strtablen
, is_rela
);
5404 dump_relocations (file
, rel_offset
, rel_size
,
5405 NULL
, 0, NULL
, 0, is_rela
);
5412 printf (_("\nThere are no relocations in this file.\n"));
5418 /* Process the unwind section. */
5420 #include "unwind-ia64.h"
5422 /* An absolute address consists of a section and an offset. If the
5423 section is NULL, the offset itself is the address, otherwise, the
5424 address equals to LOAD_ADDRESS(section) + offset. */
5428 unsigned short section
;
5432 #define ABSADDR(a) \
5434 ? section_headers [(a).section].sh_addr + (a).offset \
5437 struct ia64_unw_table_entry
5439 struct absaddr start
;
5441 struct absaddr info
;
5444 struct ia64_unw_aux_info
5447 struct ia64_unw_table_entry
*table
; /* Unwind table. */
5448 unsigned long table_len
; /* Length of unwind table. */
5449 unsigned char * info
; /* Unwind info. */
5450 unsigned long info_size
; /* Size of unwind info. */
5451 bfd_vma info_addr
; /* starting address of unwind info. */
5452 bfd_vma seg_base
; /* Starting address of segment. */
5453 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5454 unsigned long nsyms
; /* Number of symbols. */
5455 char * strtab
; /* The string table. */
5456 unsigned long strtab_size
; /* Size of string table. */
5460 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
5461 unsigned long nsyms
,
5462 const char * strtab
,
5463 unsigned long strtab_size
,
5464 struct absaddr addr
,
5465 const char ** symname
,
5468 bfd_vma dist
= 0x100000;
5469 Elf_Internal_Sym
* sym
;
5470 Elf_Internal_Sym
* best
= NULL
;
5473 REMOVE_ARCH_BITS (addr
.offset
);
5475 for (i
= 0, sym
= symtab
; i
< nsyms
; ++i
, ++sym
)
5477 bfd_vma value
= sym
->st_value
;
5479 REMOVE_ARCH_BITS (value
);
5481 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
5482 && sym
->st_name
!= 0
5483 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
5484 && addr
.offset
>= value
5485 && addr
.offset
- value
< dist
)
5488 dist
= addr
.offset
- value
;
5495 *symname
= (best
->st_name
>= strtab_size
5496 ? _("<corrupt>") : strtab
+ best
->st_name
);
5501 *offset
= addr
.offset
;
5505 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
5507 struct ia64_unw_table_entry
* tp
;
5510 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5514 const unsigned char * dp
;
5515 const unsigned char * head
;
5516 const char * procname
;
5518 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5519 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
5521 fputs ("\n<", stdout
);
5525 fputs (procname
, stdout
);
5528 printf ("+%lx", (unsigned long) offset
);
5531 fputs (">: [", stdout
);
5532 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5533 fputc ('-', stdout
);
5534 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5535 printf ("], info at +0x%lx\n",
5536 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
5538 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
5539 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
5541 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5542 (unsigned) UNW_VER (stamp
),
5543 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
5544 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
5545 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
5546 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
5548 if (UNW_VER (stamp
) != 1)
5550 printf (_("\tUnknown version.\n"));
5555 for (dp
= head
+ 8; dp
< head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);)
5556 dp
= unw_decode (dp
, in_body
, & in_body
);
5561 slurp_ia64_unwind_table (FILE * file
,
5562 struct ia64_unw_aux_info
* aux
,
5563 Elf_Internal_Shdr
* sec
)
5565 unsigned long size
, nrelas
, i
;
5566 Elf_Internal_Phdr
* seg
;
5567 struct ia64_unw_table_entry
* tep
;
5568 Elf_Internal_Shdr
* relsec
;
5569 Elf_Internal_Rela
* rela
;
5570 Elf_Internal_Rela
* rp
;
5571 unsigned char * table
;
5573 Elf_Internal_Sym
* sym
;
5574 const char * relname
;
5576 /* First, find the starting address of the segment that includes
5579 if (elf_header
.e_phnum
)
5581 if (! get_program_headers (file
))
5584 for (seg
= program_headers
;
5585 seg
< program_headers
+ elf_header
.e_phnum
;
5588 if (seg
->p_type
!= PT_LOAD
)
5591 if (sec
->sh_addr
>= seg
->p_vaddr
5592 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5594 aux
->seg_base
= seg
->p_vaddr
;
5600 /* Second, build the unwind table from the contents of the unwind section: */
5601 size
= sec
->sh_size
;
5602 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5607 aux
->table
= (struct ia64_unw_table_entry
*)
5608 xcmalloc (size
/ (3 * eh_addr_size
), sizeof (aux
->table
[0]));
5610 for (tp
= table
; tp
< table
+ size
; ++tep
)
5612 tep
->start
.section
= SHN_UNDEF
;
5613 tep
->end
.section
= SHN_UNDEF
;
5614 tep
->info
.section
= SHN_UNDEF
;
5615 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5616 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5617 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
5618 tep
->start
.offset
+= aux
->seg_base
;
5619 tep
->end
.offset
+= aux
->seg_base
;
5620 tep
->info
.offset
+= aux
->seg_base
;
5624 /* Third, apply any relocations to the unwind table: */
5625 for (relsec
= section_headers
;
5626 relsec
< section_headers
+ elf_header
.e_shnum
;
5629 if (relsec
->sh_type
!= SHT_RELA
5630 || relsec
->sh_info
>= elf_header
.e_shnum
5631 || section_headers
+ relsec
->sh_info
!= sec
)
5634 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
5638 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
5640 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
5641 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
5643 if (! const_strneq (relname
, "R_IA64_SEGREL"))
5645 warn (_("Skipping unexpected relocation type %s\n"), relname
);
5649 i
= rp
->r_offset
/ (3 * eh_addr_size
);
5651 switch (rp
->r_offset
/eh_addr_size
% 3)
5654 aux
->table
[i
].start
.section
= sym
->st_shndx
;
5655 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
5658 aux
->table
[i
].end
.section
= sym
->st_shndx
;
5659 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
5662 aux
->table
[i
].info
.section
= sym
->st_shndx
;
5663 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
5673 aux
->table_len
= size
/ (3 * eh_addr_size
);
5678 ia64_process_unwind (FILE * file
)
5680 Elf_Internal_Shdr
* sec
;
5681 Elf_Internal_Shdr
* unwsec
= NULL
;
5682 Elf_Internal_Shdr
* strsec
;
5683 unsigned long i
, unwcount
= 0, unwstart
= 0;
5684 struct ia64_unw_aux_info aux
;
5686 memset (& aux
, 0, sizeof (aux
));
5688 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
5690 if (sec
->sh_type
== SHT_SYMTAB
5691 && sec
->sh_link
< elf_header
.e_shnum
)
5693 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
5694 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
5696 strsec
= section_headers
+ sec
->sh_link
;
5697 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
5700 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
5702 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5707 printf (_("\nThere are no unwind sections in this file.\n"));
5709 while (unwcount
-- > 0)
5714 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
5715 i
< elf_header
.e_shnum
; ++i
, ++sec
)
5716 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
5723 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
5725 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
5727 /* We need to find which section group it is in. */
5728 struct group_list
* g
= section_headers_groups
[i
]->root
;
5730 for (; g
!= NULL
; g
= g
->next
)
5732 sec
= section_headers
+ g
->section_index
;
5734 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
5739 i
= elf_header
.e_shnum
;
5741 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
5743 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5744 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
5745 suffix
= SECTION_NAME (unwsec
) + len
;
5746 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5748 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
5749 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5754 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5755 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5756 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
5757 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
5759 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
5760 suffix
= SECTION_NAME (unwsec
) + len
;
5761 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
5763 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
5764 && streq (SECTION_NAME (sec
) + len2
, suffix
))
5768 if (i
== elf_header
.e_shnum
)
5770 printf (_("\nCould not find unwind info section for "));
5772 if (string_table
== NULL
)
5773 printf ("%d", unwsec
->sh_name
);
5775 printf (_("'%s'"), SECTION_NAME (unwsec
));
5779 aux
.info_size
= sec
->sh_size
;
5780 aux
.info_addr
= sec
->sh_addr
;
5781 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
5785 printf (_("\nUnwind section "));
5787 if (string_table
== NULL
)
5788 printf ("%d", unwsec
->sh_name
);
5790 printf (_("'%s'"), SECTION_NAME (unwsec
));
5792 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5793 (unsigned long) unwsec
->sh_offset
,
5794 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
5796 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
5798 if (aux
.table_len
> 0)
5799 dump_ia64_unwind (& aux
);
5802 free ((char *) aux
.table
);
5804 free ((char *) aux
.info
);
5813 free ((char *) aux
.strtab
);
5818 struct hppa_unw_table_entry
5820 struct absaddr start
;
5822 unsigned int Cannot_unwind
:1; /* 0 */
5823 unsigned int Millicode
:1; /* 1 */
5824 unsigned int Millicode_save_sr0
:1; /* 2 */
5825 unsigned int Region_description
:2; /* 3..4 */
5826 unsigned int reserved1
:1; /* 5 */
5827 unsigned int Entry_SR
:1; /* 6 */
5828 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
5829 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
5830 unsigned int Args_stored
:1; /* 16 */
5831 unsigned int Variable_Frame
:1; /* 17 */
5832 unsigned int Separate_Package_Body
:1; /* 18 */
5833 unsigned int Frame_Extension_Millicode
:1; /* 19 */
5834 unsigned int Stack_Overflow_Check
:1; /* 20 */
5835 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
5836 unsigned int Ada_Region
:1; /* 22 */
5837 unsigned int cxx_info
:1; /* 23 */
5838 unsigned int cxx_try_catch
:1; /* 24 */
5839 unsigned int sched_entry_seq
:1; /* 25 */
5840 unsigned int reserved2
:1; /* 26 */
5841 unsigned int Save_SP
:1; /* 27 */
5842 unsigned int Save_RP
:1; /* 28 */
5843 unsigned int Save_MRP_in_frame
:1; /* 29 */
5844 unsigned int extn_ptr_defined
:1; /* 30 */
5845 unsigned int Cleanup_defined
:1; /* 31 */
5847 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
5848 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
5849 unsigned int Large_frame
:1; /* 2 */
5850 unsigned int Pseudo_SP_Set
:1; /* 3 */
5851 unsigned int reserved4
:1; /* 4 */
5852 unsigned int Total_frame_size
:27; /* 5..31 */
5855 struct hppa_unw_aux_info
5857 struct hppa_unw_table_entry
*table
; /* Unwind table. */
5858 unsigned long table_len
; /* Length of unwind table. */
5859 bfd_vma seg_base
; /* Starting address of segment. */
5860 Elf_Internal_Sym
* symtab
; /* The symbol table. */
5861 unsigned long nsyms
; /* Number of symbols. */
5862 char * strtab
; /* The string table. */
5863 unsigned long strtab_size
; /* Size of string table. */
5867 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
5869 struct hppa_unw_table_entry
* tp
;
5871 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
5874 const char * procname
;
5876 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
5877 aux
->strtab_size
, tp
->start
, &procname
,
5880 fputs ("\n<", stdout
);
5884 fputs (procname
, stdout
);
5887 printf ("+%lx", (unsigned long) offset
);
5890 fputs (">: [", stdout
);
5891 print_vma (tp
->start
.offset
, PREFIX_HEX
);
5892 fputc ('-', stdout
);
5893 print_vma (tp
->end
.offset
, PREFIX_HEX
);
5896 #define PF(_m) if (tp->_m) printf (#_m " ");
5897 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5900 PF(Millicode_save_sr0
);
5901 /* PV(Region_description); */
5907 PF(Separate_Package_Body
);
5908 PF(Frame_Extension_Millicode
);
5909 PF(Stack_Overflow_Check
);
5910 PF(Two_Instruction_SP_Increment
);
5914 PF(sched_entry_seq
);
5917 PF(Save_MRP_in_frame
);
5918 PF(extn_ptr_defined
);
5919 PF(Cleanup_defined
);
5920 PF(MPE_XL_interrupt_marker
);
5921 PF(HP_UX_interrupt_marker
);
5924 PV(Total_frame_size
);
5933 slurp_hppa_unwind_table (FILE * file
,
5934 struct hppa_unw_aux_info
* aux
,
5935 Elf_Internal_Shdr
* sec
)
5937 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
5938 Elf_Internal_Phdr
* seg
;
5939 struct hppa_unw_table_entry
* tep
;
5940 Elf_Internal_Shdr
* relsec
;
5941 Elf_Internal_Rela
* rela
;
5942 Elf_Internal_Rela
* rp
;
5943 unsigned char * table
;
5945 Elf_Internal_Sym
* sym
;
5946 const char * relname
;
5948 /* First, find the starting address of the segment that includes
5951 if (elf_header
.e_phnum
)
5953 if (! get_program_headers (file
))
5956 for (seg
= program_headers
;
5957 seg
< program_headers
+ elf_header
.e_phnum
;
5960 if (seg
->p_type
!= PT_LOAD
)
5963 if (sec
->sh_addr
>= seg
->p_vaddr
5964 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
5966 aux
->seg_base
= seg
->p_vaddr
;
5972 /* Second, build the unwind table from the contents of the unwind
5974 size
= sec
->sh_size
;
5975 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
5981 nentries
= size
/ unw_ent_size
;
5982 size
= unw_ent_size
* nentries
;
5984 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
5985 xcmalloc (nentries
, sizeof (aux
->table
[0]));
5987 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
5989 unsigned int tmp1
, tmp2
;
5991 tep
->start
.section
= SHN_UNDEF
;
5992 tep
->end
.section
= SHN_UNDEF
;
5994 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
5995 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
5996 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
5997 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
5999 tep
->start
.offset
+= aux
->seg_base
;
6000 tep
->end
.offset
+= aux
->seg_base
;
6002 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
6003 tep
->Millicode
= (tmp1
>> 30) & 0x1;
6004 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
6005 tep
->Region_description
= (tmp1
>> 27) & 0x3;
6006 tep
->reserved1
= (tmp1
>> 26) & 0x1;
6007 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
6008 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
6009 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
6010 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
6011 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
6012 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
6013 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
6014 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
6015 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
6016 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
6017 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
6018 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
6019 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
6020 tep
->reserved2
= (tmp1
>> 5) & 0x1;
6021 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
6022 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
6023 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
6024 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
6025 tep
->Cleanup_defined
= tmp1
& 0x1;
6027 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
6028 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
6029 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
6030 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
6031 tep
->reserved4
= (tmp2
>> 27) & 0x1;
6032 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
6036 /* Third, apply any relocations to the unwind table. */
6037 for (relsec
= section_headers
;
6038 relsec
< section_headers
+ elf_header
.e_shnum
;
6041 if (relsec
->sh_type
!= SHT_RELA
6042 || relsec
->sh_info
>= elf_header
.e_shnum
6043 || section_headers
+ relsec
->sh_info
!= sec
)
6046 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6050 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6052 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
6053 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6055 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6056 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
6058 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6062 i
= rp
->r_offset
/ unw_ent_size
;
6064 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
6067 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6068 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
6071 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6072 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
6082 aux
->table_len
= nentries
;
6088 hppa_process_unwind (FILE * file
)
6090 struct hppa_unw_aux_info aux
;
6091 Elf_Internal_Shdr
* unwsec
= NULL
;
6092 Elf_Internal_Shdr
* strsec
;
6093 Elf_Internal_Shdr
* sec
;
6096 memset (& aux
, 0, sizeof (aux
));
6098 if (string_table
== NULL
)
6101 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6103 if (sec
->sh_type
== SHT_SYMTAB
6104 && sec
->sh_link
< elf_header
.e_shnum
)
6106 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6107 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6109 strsec
= section_headers
+ sec
->sh_link
;
6110 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6113 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6115 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6120 printf (_("\nThere are no unwind sections in this file.\n"));
6122 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6124 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
6126 printf (_("\nUnwind section "));
6127 printf (_("'%s'"), SECTION_NAME (sec
));
6129 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6130 (unsigned long) sec
->sh_offset
,
6131 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
6133 slurp_hppa_unwind_table (file
, &aux
, sec
);
6134 if (aux
.table_len
> 0)
6135 dump_hppa_unwind (&aux
);
6138 free ((char *) aux
.table
);
6146 free ((char *) aux
.strtab
);
6153 unsigned char *data
;
6155 Elf_Internal_Shdr
*sec
;
6156 Elf_Internal_Rela
*rela
;
6157 unsigned long nrelas
;
6158 unsigned int rel_type
;
6160 Elf_Internal_Rela
*next_rela
;
6163 struct arm_unw_aux_info
6167 Elf_Internal_Sym
*symtab
; /* The symbol table. */
6168 unsigned long nsyms
; /* Number of symbols. */
6169 char *strtab
; /* The string table. */
6170 unsigned long strtab_size
; /* Size of string table. */
6174 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
6175 bfd_vma fn
, struct absaddr addr
)
6177 const char *procname
;
6180 if (addr
.section
== SHN_UNDEF
)
6183 find_symbol_for_address (aux
->symtab
, aux
->nsyms
, aux
->strtab
,
6184 aux
->strtab_size
, addr
, &procname
,
6187 print_vma (fn
, PREFIX_HEX
);
6191 fputs (" <", stdout
);
6192 fputs (procname
, stdout
);
6195 printf ("+0x%lx", (unsigned long) sym_offset
);
6196 fputc ('>', stdout
);
6203 arm_free_section (struct arm_section
*arm_sec
)
6205 if (arm_sec
->data
!= NULL
)
6206 free (arm_sec
->data
);
6208 if (arm_sec
->rela
!= NULL
)
6209 free (arm_sec
->rela
);
6213 arm_section_get_word (struct arm_unw_aux_info
*aux
,
6214 struct arm_section
*arm_sec
,
6215 Elf_Internal_Shdr
*sec
, bfd_vma word_offset
,
6216 unsigned int *wordp
, struct absaddr
*addr
)
6218 Elf_Internal_Rela
*rp
;
6219 Elf_Internal_Sym
*sym
;
6220 const char * relname
;
6222 bfd_boolean wrapped
;
6224 addr
->section
= SHN_UNDEF
;
6227 if (sec
!= arm_sec
->sec
)
6229 Elf_Internal_Shdr
*relsec
;
6231 arm_free_section (arm_sec
);
6234 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
6235 sec
->sh_size
, _("unwind data"));
6237 arm_sec
->rela
= NULL
;
6238 arm_sec
->nrelas
= 0;
6240 for (relsec
= section_headers
;
6241 relsec
< section_headers
+ elf_header
.e_shnum
;
6244 if (relsec
->sh_info
>= elf_header
.e_shnum
6245 || section_headers
+ relsec
->sh_info
!= sec
)
6248 if (relsec
->sh_type
== SHT_REL
)
6250 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
6252 & arm_sec
->rela
, & arm_sec
->nrelas
))
6256 else if (relsec
->sh_type
== SHT_RELA
)
6258 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
6260 & arm_sec
->rela
, & arm_sec
->nrelas
))
6266 arm_sec
->next_rela
= arm_sec
->rela
;
6269 if (arm_sec
->data
== NULL
)
6272 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
6275 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
6277 bfd_vma prelval
, offset
;
6279 if (rp
->r_offset
> word_offset
&& !wrapped
)
6284 if (rp
->r_offset
> word_offset
)
6287 if (rp
->r_offset
& 3)
6289 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6290 (unsigned long) rp
->r_offset
);
6294 if (rp
->r_offset
< word_offset
)
6297 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
6299 if (streq (relname
, "R_ARM_NONE"))
6302 if (! streq (relname
, "R_ARM_PREL31"))
6304 warn (_("Skipping unexpected relocation type %s\n"), relname
);
6308 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
6310 if (arm_sec
->rel_type
== SHT_REL
)
6312 offset
= word
& 0x7fffffff;
6313 if (offset
& 0x40000000)
6314 offset
|= ~ (bfd_vma
) 0x7fffffff;
6317 offset
= rp
->r_addend
;
6319 offset
+= sym
->st_value
;
6320 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
6322 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
6323 addr
->section
= sym
->st_shndx
;
6324 addr
->offset
= offset
;
6329 arm_sec
->next_rela
= rp
;
6335 decode_arm_unwind (struct arm_unw_aux_info
*aux
,
6336 unsigned int word
, unsigned int remaining
,
6337 bfd_vma data_offset
, Elf_Internal_Shdr
*data_sec
,
6338 struct arm_section
*data_arm_sec
)
6341 unsigned int more_words
;
6342 struct absaddr addr
;
6345 if (remaining == 0 && more_words) \
6348 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6349 data_offset, &word, &addr)) \
6355 #define GET_OP(OP) \
6360 (OP) = word >> 24; \
6365 printf (_("[Truncated opcode]\n")); \
6368 printf (_("0x%02x "), OP)
6372 /* Fetch the first word. */
6373 if (!arm_section_get_word (aux
, data_arm_sec
, data_sec
, data_offset
,
6379 if ((word
& 0x80000000) == 0)
6381 /* Expand prel31 for personality routine. */
6383 const char *procname
;
6386 if (fn
& 0x40000000)
6387 fn
|= ~ (bfd_vma
) 0x7fffffff;
6388 fn
= fn
+ data_sec
->sh_addr
+ data_offset
;
6390 printf (_(" Personality routine: "));
6391 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
6392 fputc ('\n', stdout
);
6394 /* The GCC personality routines use the standard compact
6395 encoding, starting with one byte giving the number of
6397 if (procname
!= NULL
6398 && (const_strneq (procname
, "__gcc_personality_v0")
6399 || const_strneq (procname
, "__gxx_personality_v0")
6400 || const_strneq (procname
, "__gcj_personality_v0")
6401 || const_strneq (procname
, "__gnu_objc_personality_v0")))
6408 printf (_(" [Truncated data]\n"));
6411 more_words
= word
>> 24;
6421 per_index
= (word
>> 24) & 0x7f;
6422 if (per_index
!= 0 && per_index
!= 1 && per_index
!= 2)
6424 printf (_(" [reserved compact index %d]\n"), per_index
);
6428 printf (_(" Compact model %d\n"), per_index
);
6437 more_words
= (word
>> 16) & 0xff;
6443 /* Decode the unwinding instructions. */
6446 unsigned int op
, op2
;
6455 printf (_(" 0x%02x "), op
);
6457 if ((op
& 0xc0) == 0x00)
6459 int offset
= ((op
& 0x3f) << 2) + 4;
6460 printf (_(" vsp = vsp + %d"), offset
);
6462 else if ((op
& 0xc0) == 0x40)
6464 int offset
= ((op
& 0x3f) << 2) + 4;
6465 printf (_(" vsp = vsp - %d"), offset
);
6467 else if ((op
& 0xf0) == 0x80)
6470 if (op
== 0x80 && op2
== 0)
6471 printf (_("Refuse to unwind"));
6474 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
6479 for (i
= 0; i
< 12; i
++)
6480 if (mask
& (1 << i
))
6486 printf ("r%d", 4 + i
);
6491 else if ((op
& 0xf0) == 0x90)
6493 if (op
== 0x9d || op
== 0x9f)
6494 printf (_(" [Reserved]"));
6496 printf (_(" vsp = r%d"), op
& 0x0f);
6498 else if ((op
& 0xf0) == 0xa0)
6500 int end
= 4 + (op
& 0x07);
6504 for (i
= 4; i
<= end
; i
++)
6520 else if (op
== 0xb0)
6521 printf (_(" finish"));
6522 else if (op
== 0xb1)
6525 if (op2
== 0 || (op2
& 0xf0) != 0)
6526 printf (_("[Spare]"));
6529 unsigned int mask
= op2
& 0x0f;
6533 for (i
= 0; i
< 12; i
++)
6534 if (mask
& (1 << i
))
6545 else if (op
== 0xb2)
6547 unsigned char buf
[9];
6548 unsigned int i
, len
;
6549 unsigned long offset
;
6550 for (i
= 0; i
< sizeof (buf
); i
++)
6553 if ((buf
[i
] & 0x80) == 0)
6556 assert (i
< sizeof (buf
));
6557 offset
= read_uleb128 (buf
, &len
);
6558 assert (len
== i
+ 1);
6559 offset
= offset
* 4 + 0x204;
6560 printf (_("vsp = vsp + %ld"), offset
);
6564 if (op
== 0xb3 || op
== 0xc6 || op
== 0xc7 || op
== 0xc8 || op
== 0xc9)
6567 printf (_("[unsupported two-byte opcode]"));
6571 printf (_(" [unsupported opcode]"));
6577 /* Decode the descriptors. Not implemented. */
6581 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
6583 struct arm_section exidx_arm_sec
, extab_arm_sec
;
6584 unsigned int i
, exidx_len
;
6586 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
6587 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
6588 exidx_len
= exidx_sec
->sh_size
/ 8;
6590 for (i
= 0; i
< exidx_len
; i
++)
6592 unsigned int exidx_fn
, exidx_entry
;
6593 struct absaddr fn_addr
, entry_addr
;
6596 fputc ('\n', stdout
);
6598 if (!arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6599 8 * i
, &exidx_fn
, &fn_addr
)
6600 || !arm_section_get_word (aux
, &exidx_arm_sec
, exidx_sec
,
6601 8 * i
+ 4, &exidx_entry
, &entry_addr
))
6603 arm_free_section (&exidx_arm_sec
);
6604 arm_free_section (&extab_arm_sec
);
6608 fn
= exidx_fn
& 0x7fffffff;
6609 if (fn
& 0x40000000)
6610 fn
|= ~ (bfd_vma
) 0x7fffffff;
6611 fn
= fn
+ exidx_sec
->sh_addr
+ 8 * i
;
6613 arm_print_vma_and_name (aux
, fn
, entry_addr
);
6614 fputs (": ", stdout
);
6616 if (exidx_entry
== 1)
6618 print_vma (exidx_entry
, PREFIX_HEX
);
6619 fputs (" [cantunwind]\n", stdout
);
6621 else if (exidx_entry
& 0x80000000)
6623 print_vma (exidx_entry
, PREFIX_HEX
);
6624 fputc ('\n', stdout
);
6625 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
6629 bfd_vma table
, table_offset
= 0;
6630 Elf_Internal_Shdr
*table_sec
;
6632 fputs ("@", stdout
);
6633 table
= exidx_entry
;
6634 if (table
& 0x40000000)
6635 table
|= ~ (bfd_vma
) 0x7fffffff;
6636 table
= table
+ exidx_sec
->sh_addr
+ 8 * i
+ 4;
6637 print_vma (table
, PREFIX_HEX
);
6640 /* Locate the matching .ARM.extab. */
6641 if (entry_addr
.section
!= SHN_UNDEF
6642 && entry_addr
.section
< elf_header
.e_shnum
)
6644 table_sec
= section_headers
+ entry_addr
.section
;
6645 table_offset
= entry_addr
.offset
;
6649 table_sec
= find_section_by_address (table
);
6650 if (table_sec
!= NULL
)
6651 table_offset
= table
- table_sec
->sh_addr
;
6653 if (table_sec
== NULL
)
6655 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6656 (unsigned long) table
);
6659 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
6666 arm_free_section (&exidx_arm_sec
);
6667 arm_free_section (&extab_arm_sec
);
6671 arm_process_unwind (FILE *file
)
6673 struct arm_unw_aux_info aux
;
6674 Elf_Internal_Shdr
*unwsec
= NULL
;
6675 Elf_Internal_Shdr
*strsec
;
6676 Elf_Internal_Shdr
*sec
;
6679 memset (& aux
, 0, sizeof (aux
));
6682 if (string_table
== NULL
)
6685 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6687 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
6689 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
6690 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
);
6692 strsec
= section_headers
+ sec
->sh_link
;
6693 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
6694 1, strsec
->sh_size
, _("string table"));
6695 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6697 else if (sec
->sh_type
== SHT_ARM_EXIDX
)
6702 printf (_("\nThere are no unwind sections in this file.\n"));
6704 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6706 if (sec
->sh_type
== SHT_ARM_EXIDX
)
6708 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6710 (unsigned long) sec
->sh_offset
,
6711 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
6713 dump_arm_unwind (&aux
, sec
);
6720 free ((char *) aux
.strtab
);
6726 process_unwind (FILE * file
)
6728 struct unwind_handler
6731 int (* handler
)(FILE *);
6734 { EM_ARM
, arm_process_unwind
},
6735 { EM_IA_64
, ia64_process_unwind
},
6736 { EM_PARISC
, hppa_process_unwind
},
6744 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
6745 if (elf_header
.e_machine
== handlers
[i
].machtype
)
6746 return handlers
[i
].handler (file
);
6748 printf (_("\nThere are no unwind sections in this file.\n"));
6753 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
6755 switch (entry
->d_tag
)
6758 if (entry
->d_un
.d_val
== 0)
6759 printf (_("NONE\n"));
6762 static const char * opts
[] =
6764 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6765 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6766 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6767 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6773 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
6774 if (entry
->d_un
.d_val
& (1 << cnt
))
6776 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
6783 case DT_MIPS_IVERSION
:
6784 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
6785 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
6787 printf (_("<corrupt: %ld>\n"), (long) entry
->d_un
.d_ptr
);
6790 case DT_MIPS_TIME_STAMP
:
6795 time_t atime
= entry
->d_un
.d_val
;
6796 tmp
= gmtime (&atime
);
6797 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
6798 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6799 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6800 printf (_("Time Stamp: %s\n"), timebuf
);
6804 case DT_MIPS_RLD_VERSION
:
6805 case DT_MIPS_LOCAL_GOTNO
:
6806 case DT_MIPS_CONFLICTNO
:
6807 case DT_MIPS_LIBLISTNO
:
6808 case DT_MIPS_SYMTABNO
:
6809 case DT_MIPS_UNREFEXTNO
:
6810 case DT_MIPS_HIPAGENO
:
6811 case DT_MIPS_DELTA_CLASS_NO
:
6812 case DT_MIPS_DELTA_INSTANCE_NO
:
6813 case DT_MIPS_DELTA_RELOC_NO
:
6814 case DT_MIPS_DELTA_SYM_NO
:
6815 case DT_MIPS_DELTA_CLASSSYM_NO
:
6816 case DT_MIPS_COMPACT_SIZE
:
6817 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
6821 printf ("%#lx\n", (unsigned long) entry
->d_un
.d_ptr
);
6826 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
6828 switch (entry
->d_tag
)
6830 case DT_HP_DLD_FLAGS
:
6839 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
6840 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
6841 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
6842 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
6843 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
6844 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
6845 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
6846 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
6847 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
6848 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
6849 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
6850 { DT_HP_GST
, "HP_GST" },
6851 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
6852 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
6853 { DT_HP_NODELETE
, "HP_NODELETE" },
6854 { DT_HP_GROUP
, "HP_GROUP" },
6855 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
6859 bfd_vma val
= entry
->d_un
.d_val
;
6861 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
6862 if (val
& flags
[cnt
].bit
)
6866 fputs (flags
[cnt
].str
, stdout
);
6868 val
^= flags
[cnt
].bit
;
6871 if (val
!= 0 || first
)
6875 print_vma (val
, HEX
);
6881 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6889 /* VMS vs Unix time offset and factor. */
6891 #define VMS_EPOCH_OFFSET 35067168000000000LL
6892 #define VMS_GRANULARITY_FACTOR 10000000
6894 /* Display a VMS time in a human readable format. */
6897 print_vms_time (bfd_int64_t vmstime
)
6902 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
6903 tm
= gmtime (&unxtime
);
6904 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6905 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
6906 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
6911 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
6913 switch (entry
->d_tag
)
6915 case DT_IA_64_PLT_RESERVE
:
6916 /* First 3 slots reserved. */
6917 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6919 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
6922 case DT_IA_64_VMS_LINKTIME
:
6924 print_vms_time (entry
->d_un
.d_val
);
6928 case DT_IA_64_VMS_LNKFLAGS
:
6929 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6930 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
6931 printf (" CALL_DEBUG");
6932 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
6933 printf (" NOP0BUFS");
6934 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
6935 printf (" P0IMAGE");
6936 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
6937 printf (" MKTHREADS");
6938 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
6939 printf (" UPCALLS");
6940 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
6942 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
6943 printf (" INITIALIZE");
6944 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
6946 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
6947 printf (" EXE_INIT");
6948 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
6949 printf (" TBK_IN_IMG");
6950 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
6951 printf (" DBG_IN_IMG");
6952 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
6953 printf (" TBK_IN_DSF");
6954 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
6955 printf (" DBG_IN_DSF");
6956 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
6957 printf (" SIGNATURES");
6958 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
6959 printf (" REL_SEG_OFF");
6963 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
6970 get_32bit_dynamic_section (FILE * file
)
6972 Elf32_External_Dyn
* edyn
;
6973 Elf32_External_Dyn
* ext
;
6974 Elf_Internal_Dyn
* entry
;
6976 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
6977 dynamic_size
, _("dynamic section"));
6981 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6982 might not have the luxury of section headers. Look for the DT_NULL
6983 terminator to determine the number of entries. */
6984 for (ext
= edyn
, dynamic_nent
= 0;
6985 (char *) ext
< (char *) edyn
+ dynamic_size
;
6989 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
6993 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
6995 if (dynamic_section
== NULL
)
6997 error (_("Out of memory\n"));
7002 for (ext
= edyn
, entry
= dynamic_section
;
7003 entry
< dynamic_section
+ dynamic_nent
;
7006 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7007 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7016 get_64bit_dynamic_section (FILE * file
)
7018 Elf64_External_Dyn
* edyn
;
7019 Elf64_External_Dyn
* ext
;
7020 Elf_Internal_Dyn
* entry
;
7022 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
7023 dynamic_size
, _("dynamic section"));
7027 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7028 might not have the luxury of section headers. Look for the DT_NULL
7029 terminator to determine the number of entries. */
7030 for (ext
= edyn
, dynamic_nent
= 0;
7031 (char *) ext
< (char *) edyn
+ dynamic_size
;
7035 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
7039 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
7041 if (dynamic_section
== NULL
)
7043 error (_("Out of memory\n"));
7048 for (ext
= edyn
, entry
= dynamic_section
;
7049 entry
< dynamic_section
+ dynamic_nent
;
7052 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
7053 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
7062 print_dynamic_flags (bfd_vma flags
)
7070 flag
= flags
& - flags
;
7080 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
7081 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
7082 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
7083 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
7084 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
7085 default: fputs (_("unknown"), stdout
); break;
7091 /* Parse and display the contents of the dynamic section. */
7094 process_dynamic_section (FILE * file
)
7096 Elf_Internal_Dyn
* entry
;
7098 if (dynamic_size
== 0)
7101 printf (_("\nThere is no dynamic section in this file.\n"));
7108 if (! get_32bit_dynamic_section (file
))
7111 else if (! get_64bit_dynamic_section (file
))
7114 /* Find the appropriate symbol table. */
7115 if (dynamic_symbols
== NULL
)
7117 for (entry
= dynamic_section
;
7118 entry
< dynamic_section
+ dynamic_nent
;
7121 Elf_Internal_Shdr section
;
7123 if (entry
->d_tag
!= DT_SYMTAB
)
7126 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
7128 /* Since we do not know how big the symbol table is,
7129 we default to reading in the entire file (!) and
7130 processing that. This is overkill, I know, but it
7132 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7134 if (archive_file_offset
!= 0)
7135 section
.sh_size
= archive_file_size
- section
.sh_offset
;
7138 if (fseek (file
, 0, SEEK_END
))
7139 error (_("Unable to seek to end of file!\n"));
7141 section
.sh_size
= ftell (file
) - section
.sh_offset
;
7145 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
7147 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
7149 num_dynamic_syms
= section
.sh_size
/ section
.sh_entsize
;
7150 if (num_dynamic_syms
< 1)
7152 error (_("Unable to determine the number of symbols to load\n"));
7156 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
);
7160 /* Similarly find a string table. */
7161 if (dynamic_strings
== NULL
)
7163 for (entry
= dynamic_section
;
7164 entry
< dynamic_section
+ dynamic_nent
;
7167 unsigned long offset
;
7170 if (entry
->d_tag
!= DT_STRTAB
)
7173 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
7175 /* Since we do not know how big the string table is,
7176 we default to reading in the entire file (!) and
7177 processing that. This is overkill, I know, but it
7180 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
7182 if (archive_file_offset
!= 0)
7183 str_tab_len
= archive_file_size
- offset
;
7186 if (fseek (file
, 0, SEEK_END
))
7187 error (_("Unable to seek to end of file\n"));
7188 str_tab_len
= ftell (file
) - offset
;
7191 if (str_tab_len
< 1)
7194 (_("Unable to determine the length of the dynamic string table\n"));
7198 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
7200 _("dynamic string table"));
7201 dynamic_strings_length
= str_tab_len
;
7206 /* And find the syminfo section if available. */
7207 if (dynamic_syminfo
== NULL
)
7209 unsigned long syminsz
= 0;
7211 for (entry
= dynamic_section
;
7212 entry
< dynamic_section
+ dynamic_nent
;
7215 if (entry
->d_tag
== DT_SYMINENT
)
7217 /* Note: these braces are necessary to avoid a syntax
7218 error from the SunOS4 C compiler. */
7219 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
7221 else if (entry
->d_tag
== DT_SYMINSZ
)
7222 syminsz
= entry
->d_un
.d_val
;
7223 else if (entry
->d_tag
== DT_SYMINFO
)
7224 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
7228 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
7230 Elf_External_Syminfo
* extsyminfo
;
7231 Elf_External_Syminfo
* extsym
;
7232 Elf_Internal_Syminfo
* syminfo
;
7234 /* There is a syminfo section. Read the data. */
7235 extsyminfo
= (Elf_External_Syminfo
*)
7236 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
7237 _("symbol information"));
7241 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
7242 if (dynamic_syminfo
== NULL
)
7244 error (_("Out of memory\n"));
7248 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
7249 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
7250 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
7251 ++syminfo
, ++extsym
)
7253 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
7254 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
7261 if (do_dynamic
&& dynamic_addr
)
7262 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7263 dynamic_addr
, dynamic_nent
);
7265 printf (_(" Tag Type Name/Value\n"));
7267 for (entry
= dynamic_section
;
7268 entry
< dynamic_section
+ dynamic_nent
;
7276 print_vma (entry
->d_tag
, FULL_HEX
);
7277 dtype
= get_dynamic_type (entry
->d_tag
);
7278 printf (" (%s)%*s", dtype
,
7279 ((is_32bit_elf
? 27 : 19)
7280 - (int) strlen (dtype
)),
7284 switch (entry
->d_tag
)
7288 print_dynamic_flags (entry
->d_un
.d_val
);
7298 switch (entry
->d_tag
)
7301 printf (_("Auxiliary library"));
7305 printf (_("Filter library"));
7309 printf (_("Configuration file"));
7313 printf (_("Dependency audit library"));
7317 printf (_("Audit library"));
7321 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7322 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
7326 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7335 printf (_("Flags:"));
7337 if (entry
->d_un
.d_val
== 0)
7338 printf (_(" None\n"));
7341 unsigned long int val
= entry
->d_un
.d_val
;
7343 if (val
& DTF_1_PARINIT
)
7345 printf (" PARINIT");
7346 val
^= DTF_1_PARINIT
;
7348 if (val
& DTF_1_CONFEXP
)
7350 printf (" CONFEXP");
7351 val
^= DTF_1_CONFEXP
;
7354 printf (" %lx", val
);
7363 printf (_("Flags:"));
7365 if (entry
->d_un
.d_val
== 0)
7366 printf (_(" None\n"));
7369 unsigned long int val
= entry
->d_un
.d_val
;
7371 if (val
& DF_P1_LAZYLOAD
)
7373 printf (" LAZYLOAD");
7374 val
^= DF_P1_LAZYLOAD
;
7376 if (val
& DF_P1_GROUPPERM
)
7378 printf (" GROUPPERM");
7379 val
^= DF_P1_GROUPPERM
;
7382 printf (" %lx", val
);
7391 printf (_("Flags:"));
7392 if (entry
->d_un
.d_val
== 0)
7393 printf (_(" None\n"));
7396 unsigned long int val
= entry
->d_un
.d_val
;
7403 if (val
& DF_1_GLOBAL
)
7408 if (val
& DF_1_GROUP
)
7413 if (val
& DF_1_NODELETE
)
7415 printf (" NODELETE");
7416 val
^= DF_1_NODELETE
;
7418 if (val
& DF_1_LOADFLTR
)
7420 printf (" LOADFLTR");
7421 val
^= DF_1_LOADFLTR
;
7423 if (val
& DF_1_INITFIRST
)
7425 printf (" INITFIRST");
7426 val
^= DF_1_INITFIRST
;
7428 if (val
& DF_1_NOOPEN
)
7433 if (val
& DF_1_ORIGIN
)
7438 if (val
& DF_1_DIRECT
)
7443 if (val
& DF_1_TRANS
)
7448 if (val
& DF_1_INTERPOSE
)
7450 printf (" INTERPOSE");
7451 val
^= DF_1_INTERPOSE
;
7453 if (val
& DF_1_NODEFLIB
)
7455 printf (" NODEFLIB");
7456 val
^= DF_1_NODEFLIB
;
7458 if (val
& DF_1_NODUMP
)
7463 if (val
& DF_1_CONLFAT
)
7465 printf (" CONLFAT");
7466 val
^= DF_1_CONLFAT
;
7469 printf (" %lx", val
);
7476 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7478 puts (get_dynamic_type (entry
->d_un
.d_val
));
7498 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7504 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7505 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7511 switch (entry
->d_tag
)
7514 printf (_("Shared library: [%s]"), name
);
7516 if (streq (name
, program_interpreter
))
7517 printf (_(" program interpreter"));
7521 printf (_("Library soname: [%s]"), name
);
7525 printf (_("Library rpath: [%s]"), name
);
7529 printf (_("Library runpath: [%s]"), name
);
7533 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7538 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7551 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
7555 case DT_INIT_ARRAYSZ
:
7556 case DT_FINI_ARRAYSZ
:
7557 case DT_GNU_CONFLICTSZ
:
7558 case DT_GNU_LIBLISTSZ
:
7561 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7562 printf (_(" (bytes)\n"));
7572 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
7585 if (entry
->d_tag
== DT_USED
7586 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
7588 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
7592 printf (_("Not needed object: [%s]\n"), name
);
7597 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7603 /* The value of this entry is ignored. */
7608 case DT_GNU_PRELINKED
:
7612 time_t atime
= entry
->d_un
.d_val
;
7614 tmp
= gmtime (&atime
);
7615 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7616 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7617 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7623 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
7626 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7632 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
7633 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
7638 switch (elf_header
.e_machine
)
7641 case EM_MIPS_RS3_LE
:
7642 dynamic_section_mips_val (entry
);
7645 dynamic_section_parisc_val (entry
);
7648 dynamic_section_ia64_val (entry
);
7651 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
7663 get_ver_flags (unsigned int flags
)
7665 static char buff
[32];
7672 if (flags
& VER_FLG_BASE
)
7673 strcat (buff
, "BASE ");
7675 if (flags
& VER_FLG_WEAK
)
7677 if (flags
& VER_FLG_BASE
)
7678 strcat (buff
, "| ");
7680 strcat (buff
, "WEAK ");
7683 if (flags
& VER_FLG_INFO
)
7685 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
7686 strcat (buff
, "| ");
7688 strcat (buff
, "INFO ");
7691 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
7692 strcat (buff
, _("| <unknown>"));
7697 /* Display the contents of the version sections. */
7700 process_version_sections (FILE * file
)
7702 Elf_Internal_Shdr
* section
;
7709 for (i
= 0, section
= section_headers
;
7710 i
< elf_header
.e_shnum
;
7713 switch (section
->sh_type
)
7715 case SHT_GNU_verdef
:
7717 Elf_External_Verdef
* edefs
;
7725 (_("\nVersion definition section '%s' contains %u entries:\n"),
7726 SECTION_NAME (section
), section
->sh_info
);
7728 printf (_(" Addr: 0x"));
7729 printf_vma (section
->sh_addr
);
7730 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7731 (unsigned long) section
->sh_offset
, section
->sh_link
,
7732 section
->sh_link
< elf_header
.e_shnum
7733 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7736 edefs
= (Elf_External_Verdef
*)
7737 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
7738 _("version definition section"));
7739 endbuf
= (char *) edefs
+ section
->sh_size
;
7743 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7746 Elf_External_Verdef
* edef
;
7747 Elf_Internal_Verdef ent
;
7748 Elf_External_Verdaux
* eaux
;
7749 Elf_Internal_Verdaux aux
;
7753 vstart
= ((char *) edefs
) + idx
;
7754 if (vstart
+ sizeof (*edef
) > endbuf
)
7757 edef
= (Elf_External_Verdef
*) vstart
;
7759 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
7760 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
7761 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
7762 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
7763 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
7764 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
7765 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
7767 printf (_(" %#06x: Rev: %d Flags: %s"),
7768 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
7770 printf (_(" Index: %d Cnt: %d "),
7771 ent
.vd_ndx
, ent
.vd_cnt
);
7773 vstart
+= ent
.vd_aux
;
7775 eaux
= (Elf_External_Verdaux
*) vstart
;
7777 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7778 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7780 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7781 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
7783 printf (_("Name index: %ld\n"), aux
.vda_name
);
7785 isum
= idx
+ ent
.vd_aux
;
7787 for (j
= 1; j
< ent
.vd_cnt
; j
++)
7789 isum
+= aux
.vda_next
;
7790 vstart
+= aux
.vda_next
;
7792 eaux
= (Elf_External_Verdaux
*) vstart
;
7793 if (vstart
+ sizeof (*eaux
) > endbuf
)
7796 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
7797 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
7799 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
7800 printf (_(" %#06x: Parent %d: %s\n"),
7801 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
7803 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7804 isum
, j
, aux
.vda_name
);
7807 printf (_(" Version def aux past end of section\n"));
7811 if (cnt
< section
->sh_info
)
7812 printf (_(" Version definition past end of section\n"));
7818 case SHT_GNU_verneed
:
7820 Elf_External_Verneed
* eneed
;
7827 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7828 SECTION_NAME (section
), section
->sh_info
);
7830 printf (_(" Addr: 0x"));
7831 printf_vma (section
->sh_addr
);
7832 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7833 (unsigned long) section
->sh_offset
, section
->sh_link
,
7834 section
->sh_link
< elf_header
.e_shnum
7835 ? SECTION_NAME (section_headers
+ section
->sh_link
)
7838 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
7839 section
->sh_offset
, 1,
7841 _("version need section"));
7842 endbuf
= (char *) eneed
+ section
->sh_size
;
7846 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
7848 Elf_External_Verneed
* entry
;
7849 Elf_Internal_Verneed ent
;
7854 vstart
= ((char *) eneed
) + idx
;
7855 if (vstart
+ sizeof (*entry
) > endbuf
)
7858 entry
= (Elf_External_Verneed
*) vstart
;
7860 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
7861 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
7862 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
7863 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
7864 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
7866 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
7868 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
7869 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
7871 printf (_(" File: %lx"), ent
.vn_file
);
7873 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
7875 vstart
+= ent
.vn_aux
;
7877 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
7879 Elf_External_Vernaux
* eaux
;
7880 Elf_Internal_Vernaux aux
;
7882 if (vstart
+ sizeof (*eaux
) > endbuf
)
7884 eaux
= (Elf_External_Vernaux
*) vstart
;
7886 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
7887 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
7888 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
7889 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
7890 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
7892 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
7893 printf (_(" %#06x: Name: %s"),
7894 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
7896 printf (_(" %#06x: Name index: %lx"),
7897 isum
, aux
.vna_name
);
7899 printf (_(" Flags: %s Version: %d\n"),
7900 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
7902 isum
+= aux
.vna_next
;
7903 vstart
+= aux
.vna_next
;
7906 printf (_(" Version need aux past end of section\n"));
7910 if (cnt
< section
->sh_info
)
7911 printf (_(" Version need past end of section\n"));
7917 case SHT_GNU_versym
:
7919 Elf_Internal_Shdr
* link_section
;
7922 unsigned char * edata
;
7923 unsigned short * data
;
7925 Elf_Internal_Sym
* symbols
;
7926 Elf_Internal_Shdr
* string_sec
;
7929 if (section
->sh_link
>= elf_header
.e_shnum
)
7932 link_section
= section_headers
+ section
->sh_link
;
7933 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
7935 if (link_section
->sh_link
>= elf_header
.e_shnum
)
7940 symbols
= GET_ELF_SYMBOLS (file
, link_section
);
7942 string_sec
= section_headers
+ link_section
->sh_link
;
7944 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
7945 string_sec
->sh_size
,
7946 _("version string table"));
7950 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7951 SECTION_NAME (section
), total
);
7953 printf (_(" Addr: "));
7954 printf_vma (section
->sh_addr
);
7955 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7956 (unsigned long) section
->sh_offset
, section
->sh_link
,
7957 SECTION_NAME (link_section
));
7959 off
= offset_from_vma (file
,
7960 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
7961 total
* sizeof (short));
7962 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
7964 _("version symbol data"));
7971 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
7973 for (cnt
= total
; cnt
--;)
7974 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
7979 for (cnt
= 0; cnt
< total
; cnt
+= 4)
7982 int check_def
, check_need
;
7985 printf (" %03x:", cnt
);
7987 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
7988 switch (data
[cnt
+ j
])
7991 fputs (_(" 0 (*local*) "), stdout
);
7995 fputs (_(" 1 (*global*) "), stdout
);
7999 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
8000 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
8004 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
8005 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
8008 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
8015 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
8017 Elf_Internal_Verneed ivn
;
8018 unsigned long offset
;
8020 offset
= offset_from_vma
8021 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8022 sizeof (Elf_External_Verneed
));
8026 Elf_Internal_Vernaux ivna
;
8027 Elf_External_Verneed evn
;
8028 Elf_External_Vernaux evna
;
8029 unsigned long a_off
;
8031 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8034 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8035 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8037 a_off
= offset
+ ivn
.vn_aux
;
8041 get_data (&evna
, file
, a_off
, sizeof (evna
),
8042 1, _("version need aux (2)"));
8044 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8045 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8047 a_off
+= ivna
.vna_next
;
8049 while (ivna
.vna_other
!= data
[cnt
+ j
]
8050 && ivna
.vna_next
!= 0);
8052 if (ivna
.vna_other
== data
[cnt
+ j
])
8054 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8056 if (ivna
.vna_name
>= string_sec
->sh_size
)
8057 name
= _("*invalid*");
8059 name
= strtab
+ ivna
.vna_name
;
8060 nn
+= printf ("(%s%-*s",
8062 12 - (int) strlen (name
),
8068 offset
+= ivn
.vn_next
;
8070 while (ivn
.vn_next
);
8073 if (check_def
&& data
[cnt
+ j
] != 0x8001
8074 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8076 Elf_Internal_Verdef ivd
;
8077 Elf_External_Verdef evd
;
8078 unsigned long offset
;
8080 offset
= offset_from_vma
8081 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8086 get_data (&evd
, file
, offset
, sizeof (evd
), 1,
8089 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8090 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8092 offset
+= ivd
.vd_next
;
8094 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
8095 && ivd
.vd_next
!= 0);
8097 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
8099 Elf_External_Verdaux evda
;
8100 Elf_Internal_Verdaux ivda
;
8102 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8104 get_data (&evda
, file
,
8105 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
8107 _("version def aux"));
8109 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8111 if (ivda
.vda_name
>= string_sec
->sh_size
)
8112 name
= _("*invalid*");
8114 name
= strtab
+ ivda
.vda_name
;
8115 nn
+= printf ("(%s%-*s",
8117 12 - (int) strlen (name
),
8123 printf ("%*c", 18 - nn
, ' ');
8141 printf (_("\nNo version information found in this file.\n"));
8147 get_symbol_binding (unsigned int binding
)
8149 static char buff
[32];
8153 case STB_LOCAL
: return "LOCAL";
8154 case STB_GLOBAL
: return "GLOBAL";
8155 case STB_WEAK
: return "WEAK";
8157 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
8158 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
8160 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
8162 if (binding
== STB_GNU_UNIQUE
8163 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8164 /* GNU/Linux is still using the default value 0. */
8165 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8167 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
8170 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
8176 get_symbol_type (unsigned int type
)
8178 static char buff
[32];
8182 case STT_NOTYPE
: return "NOTYPE";
8183 case STT_OBJECT
: return "OBJECT";
8184 case STT_FUNC
: return "FUNC";
8185 case STT_SECTION
: return "SECTION";
8186 case STT_FILE
: return "FILE";
8187 case STT_COMMON
: return "COMMON";
8188 case STT_TLS
: return "TLS";
8189 case STT_RELC
: return "RELC";
8190 case STT_SRELC
: return "SRELC";
8192 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
8194 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
8195 return "THUMB_FUNC";
8197 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
8200 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
8201 return "PARISC_MILLI";
8203 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
8205 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
8207 if (elf_header
.e_machine
== EM_PARISC
)
8209 if (type
== STT_HP_OPAQUE
)
8211 if (type
== STT_HP_STUB
)
8215 if (type
== STT_GNU_IFUNC
8216 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_LINUX
8217 /* GNU/Linux is still using the default value 0. */
8218 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
8221 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
8224 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
8230 get_symbol_visibility (unsigned int visibility
)
8234 case STV_DEFAULT
: return "DEFAULT";
8235 case STV_INTERNAL
: return "INTERNAL";
8236 case STV_HIDDEN
: return "HIDDEN";
8237 case STV_PROTECTED
: return "PROTECTED";
8243 get_mips_symbol_other (unsigned int other
)
8247 case STO_OPTIONAL
: return "OPTIONAL";
8248 case STO_MIPS16
: return "MIPS16";
8249 case STO_MIPS_PLT
: return "MIPS PLT";
8250 case STO_MIPS_PIC
: return "MIPS PIC";
8251 default: return NULL
;
8256 get_ia64_symbol_other (unsigned int other
)
8260 static char res
[32];
8264 /* Function types is for images and .STB files only. */
8265 switch (elf_header
.e_type
)
8269 switch (VMS_ST_FUNC_TYPE (other
))
8271 case VMS_SFT_CODE_ADDR
:
8272 strcat (res
, " CA");
8274 case VMS_SFT_SYMV_IDX
:
8275 strcat (res
, " VEC");
8278 strcat (res
, " FD");
8280 case VMS_SFT_RESERVE
:
8281 strcat (res
, " RSV");
8290 switch (VMS_ST_LINKAGE (other
))
8292 case VMS_STL_IGNORE
:
8293 strcat (res
, " IGN");
8295 case VMS_STL_RESERVE
:
8296 strcat (res
, " RSV");
8299 strcat (res
, " STD");
8302 strcat (res
, " LNK");
8317 get_symbol_other (unsigned int other
)
8319 const char * result
= NULL
;
8320 static char buff
[32];
8325 switch (elf_header
.e_machine
)
8328 result
= get_mips_symbol_other (other
);
8331 result
= get_ia64_symbol_other (other
);
8340 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
8345 get_symbol_index_type (unsigned int type
)
8347 static char buff
[32];
8351 case SHN_UNDEF
: return "UND";
8352 case SHN_ABS
: return "ABS";
8353 case SHN_COMMON
: return "COM";
8355 if (type
== SHN_IA_64_ANSI_COMMON
8356 && elf_header
.e_machine
== EM_IA_64
8357 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
8359 else if ((elf_header
.e_machine
== EM_X86_64
8360 || elf_header
.e_machine
== EM_L1OM
)
8361 && type
== SHN_X86_64_LCOMMON
)
8363 else if (type
== SHN_MIPS_SCOMMON
8364 && elf_header
.e_machine
== EM_MIPS
)
8366 else if (type
== SHN_MIPS_SUNDEFINED
8367 && elf_header
.e_machine
== EM_MIPS
)
8369 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
8370 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
8371 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
8372 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
8373 else if (type
>= SHN_LORESERVE
)
8374 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
8376 sprintf (buff
, "%3d", type
);
8384 get_dynamic_data (FILE * file
, unsigned int number
, unsigned int ent_size
)
8386 unsigned char * e_data
;
8389 e_data
= (unsigned char *) cmalloc (number
, ent_size
);
8393 error (_("Out of memory\n"));
8397 if (fread (e_data
, ent_size
, number
, file
) != number
)
8399 error (_("Unable to read in dynamic data\n"));
8403 i_data
= (bfd_vma
*) cmalloc (number
, sizeof (*i_data
));
8407 error (_("Out of memory\n"));
8413 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
8421 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
8423 Elf_Internal_Sym
* psym
;
8426 psym
= dynamic_symbols
+ si
;
8428 n
= print_vma (si
, DEC_5
);
8430 fputs (" " + n
, stdout
);
8431 printf (" %3lu: ", hn
);
8432 print_vma (psym
->st_value
, LONG_HEX
);
8434 print_vma (psym
->st_size
, DEC_5
);
8436 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8437 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8438 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8439 /* Check to see if any other bits in the st_other field are set.
8440 Note - displaying this information disrupts the layout of the
8441 table being generated, but for the moment this case is very
8443 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8444 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8445 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
8446 if (VALID_DYNAMIC_NAME (psym
->st_name
))
8447 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
8449 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
8453 /* Dump the symbol table. */
8455 process_symbol_table (FILE * file
)
8457 Elf_Internal_Shdr
* section
;
8458 bfd_vma nbuckets
= 0;
8459 bfd_vma nchains
= 0;
8460 bfd_vma
* buckets
= NULL
;
8461 bfd_vma
* chains
= NULL
;
8462 bfd_vma ngnubuckets
= 0;
8463 bfd_vma
* gnubuckets
= NULL
;
8464 bfd_vma
* gnuchains
= NULL
;
8465 bfd_vma gnusymidx
= 0;
8467 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
8470 if (dynamic_info
[DT_HASH
]
8472 || (do_using_dynamic
8474 && dynamic_strings
!= NULL
)))
8476 unsigned char nb
[8];
8477 unsigned char nc
[8];
8478 int hash_ent_size
= 4;
8480 if ((elf_header
.e_machine
== EM_ALPHA
8481 || elf_header
.e_machine
== EM_S390
8482 || elf_header
.e_machine
== EM_S390_OLD
)
8483 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
8487 (archive_file_offset
8488 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
8489 sizeof nb
+ sizeof nc
)),
8492 error (_("Unable to seek to start of dynamic information\n"));
8496 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
8498 error (_("Failed to read in number of buckets\n"));
8502 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
8504 error (_("Failed to read in number of chains\n"));
8508 nbuckets
= byte_get (nb
, hash_ent_size
);
8509 nchains
= byte_get (nc
, hash_ent_size
);
8511 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
8512 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
8515 if (buckets
== NULL
|| chains
== NULL
)
8517 if (do_using_dynamic
)
8528 if (dynamic_info_DT_GNU_HASH
8530 || (do_using_dynamic
8532 && dynamic_strings
!= NULL
)))
8534 unsigned char nb
[16];
8535 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
8536 bfd_vma buckets_vma
;
8539 (archive_file_offset
8540 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
8544 error (_("Unable to seek to start of dynamic information\n"));
8548 if (fread (nb
, 16, 1, file
) != 1)
8550 error (_("Failed to read in number of buckets\n"));
8554 ngnubuckets
= byte_get (nb
, 4);
8555 gnusymidx
= byte_get (nb
+ 4, 4);
8556 bitmaskwords
= byte_get (nb
+ 8, 4);
8557 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
8559 buckets_vma
+= bitmaskwords
* 4;
8561 buckets_vma
+= bitmaskwords
* 8;
8564 (archive_file_offset
8565 + offset_from_vma (file
, buckets_vma
, 4)),
8568 error (_("Unable to seek to start of dynamic information\n"));
8572 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
8574 if (gnubuckets
== NULL
)
8577 for (i
= 0; i
< ngnubuckets
; i
++)
8578 if (gnubuckets
[i
] != 0)
8580 if (gnubuckets
[i
] < gnusymidx
)
8583 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
8584 maxchain
= gnubuckets
[i
];
8587 if (maxchain
== 0xffffffff)
8590 maxchain
-= gnusymidx
;
8593 (archive_file_offset
8594 + offset_from_vma (file
, buckets_vma
8595 + 4 * (ngnubuckets
+ maxchain
), 4)),
8598 error (_("Unable to seek to start of dynamic information\n"));
8604 if (fread (nb
, 4, 1, file
) != 1)
8606 error (_("Failed to determine last chain length\n"));
8610 if (maxchain
+ 1 == 0)
8615 while ((byte_get (nb
, 4) & 1) == 0);
8618 (archive_file_offset
8619 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
8622 error (_("Unable to seek to start of dynamic information\n"));
8626 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
8629 if (gnuchains
== NULL
)
8634 if (do_using_dynamic
)
8639 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
8642 && dynamic_strings
!= NULL
)
8646 if (dynamic_info
[DT_HASH
])
8650 printf (_("\nSymbol table for image:\n"));
8652 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8654 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8656 for (hn
= 0; hn
< nbuckets
; hn
++)
8661 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
8662 print_dynamic_symbol (si
, hn
);
8666 if (dynamic_info_DT_GNU_HASH
)
8668 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8670 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8672 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8674 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8675 if (gnubuckets
[hn
] != 0)
8677 bfd_vma si
= gnubuckets
[hn
];
8678 bfd_vma off
= si
- gnusymidx
;
8682 print_dynamic_symbol (si
, hn
);
8685 while ((gnuchains
[off
++] & 1) == 0);
8689 else if (do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
8693 for (i
= 0, section
= section_headers
;
8694 i
< elf_header
.e_shnum
;
8698 char * strtab
= NULL
;
8699 unsigned long int strtab_size
= 0;
8700 Elf_Internal_Sym
* symtab
;
8701 Elf_Internal_Sym
* psym
;
8703 if ((section
->sh_type
!= SHT_SYMTAB
8704 && section
->sh_type
!= SHT_DYNSYM
)
8706 && section
->sh_type
== SHT_SYMTAB
))
8709 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8710 SECTION_NAME (section
),
8711 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
8713 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8715 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8717 symtab
= GET_ELF_SYMBOLS (file
, section
);
8721 if (section
->sh_link
== elf_header
.e_shstrndx
)
8723 strtab
= string_table
;
8724 strtab_size
= string_table_length
;
8726 else if (section
->sh_link
< elf_header
.e_shnum
)
8728 Elf_Internal_Shdr
* string_sec
;
8730 string_sec
= section_headers
+ section
->sh_link
;
8732 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
8733 1, string_sec
->sh_size
,
8735 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
8738 for (si
= 0, psym
= symtab
;
8739 si
< section
->sh_size
/ section
->sh_entsize
;
8742 printf ("%6d: ", si
);
8743 print_vma (psym
->st_value
, LONG_HEX
);
8745 print_vma (psym
->st_size
, DEC_5
);
8746 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
8747 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
8748 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
8749 /* Check to see if any other bits in the st_other field are set.
8750 Note - displaying this information disrupts the layout of the
8751 table being generated, but for the moment this case is very rare. */
8752 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
8753 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
8754 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
8755 print_symbol (25, psym
->st_name
< strtab_size
8756 ? strtab
+ psym
->st_name
: _("<corrupt>"));
8758 if (section
->sh_type
== SHT_DYNSYM
&&
8759 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
8761 unsigned char data
[2];
8762 unsigned short vers_data
;
8763 unsigned long offset
;
8767 offset
= offset_from_vma
8768 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
8769 sizeof data
+ si
* sizeof (vers_data
));
8771 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
8772 sizeof (data
), 1, _("version data"));
8774 vers_data
= byte_get (data
, 2);
8776 is_nobits
= (psym
->st_shndx
< elf_header
.e_shnum
8777 && section_headers
[psym
->st_shndx
].sh_type
8780 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
8782 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
8784 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
8785 && (is_nobits
|| ! check_def
))
8787 Elf_External_Verneed evn
;
8788 Elf_Internal_Verneed ivn
;
8789 Elf_Internal_Vernaux ivna
;
8791 /* We must test both. */
8792 offset
= offset_from_vma
8793 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
8798 unsigned long vna_off
;
8800 get_data (&evn
, file
, offset
, sizeof (evn
), 1,
8803 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
8804 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
8806 vna_off
= offset
+ ivn
.vn_aux
;
8810 Elf_External_Vernaux evna
;
8812 get_data (&evna
, file
, vna_off
,
8814 _("version need aux (3)"));
8816 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
8817 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
8818 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
8820 vna_off
+= ivna
.vna_next
;
8822 while (ivna
.vna_other
!= vers_data
8823 && ivna
.vna_next
!= 0);
8825 if (ivna
.vna_other
== vers_data
)
8828 offset
+= ivn
.vn_next
;
8830 while (ivn
.vn_next
!= 0);
8832 if (ivna
.vna_other
== vers_data
)
8835 ivna
.vna_name
< strtab_size
8836 ? strtab
+ ivna
.vna_name
: _("<corrupt>"),
8840 else if (! is_nobits
)
8841 error (_("bad dynamic symbol\n"));
8848 if (vers_data
!= 0x8001
8849 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
8851 Elf_Internal_Verdef ivd
;
8852 Elf_Internal_Verdaux ivda
;
8853 Elf_External_Verdaux evda
;
8856 off
= offset_from_vma
8858 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
8859 sizeof (Elf_External_Verdef
));
8863 Elf_External_Verdef evd
;
8865 get_data (&evd
, file
, off
, sizeof (evd
),
8866 1, _("version def"));
8868 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
8869 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
8870 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
8874 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
8875 && ivd
.vd_next
!= 0);
8880 get_data (&evda
, file
, off
, sizeof (evda
),
8881 1, _("version def aux"));
8883 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
8885 if (psym
->st_name
!= ivda
.vda_name
)
8886 printf ((vers_data
& VERSYM_HIDDEN
)
8888 ivda
.vda_name
< strtab_size
8889 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
8899 if (strtab
!= string_table
)
8905 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8907 if (do_histogram
&& buckets
!= NULL
)
8909 unsigned long * lengths
;
8910 unsigned long * counts
;
8913 unsigned long maxlength
= 0;
8914 unsigned long nzero_counts
= 0;
8915 unsigned long nsyms
= 0;
8917 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8918 (unsigned long) nbuckets
);
8919 printf (_(" Length Number %% of total Coverage\n"));
8921 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
8922 if (lengths
== NULL
)
8924 error (_("Out of memory\n"));
8927 for (hn
= 0; hn
< nbuckets
; ++hn
)
8929 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
8932 if (maxlength
< ++lengths
[hn
])
8937 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
8940 error (_("Out of memory\n"));
8944 for (hn
= 0; hn
< nbuckets
; ++hn
)
8945 ++counts
[lengths
[hn
]];
8950 printf (" 0 %-10lu (%5.1f%%)\n",
8951 counts
[0], (counts
[0] * 100.0) / nbuckets
);
8952 for (i
= 1; i
<= maxlength
; ++i
)
8954 nzero_counts
+= counts
[i
] * i
;
8955 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8956 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
8957 (nzero_counts
* 100.0) / nsyms
);
8965 if (buckets
!= NULL
)
8971 if (do_histogram
&& gnubuckets
!= NULL
)
8973 unsigned long * lengths
;
8974 unsigned long * counts
;
8976 unsigned long maxlength
= 0;
8977 unsigned long nzero_counts
= 0;
8978 unsigned long nsyms
= 0;
8980 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
8981 if (lengths
== NULL
)
8983 error (_("Out of memory\n"));
8987 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
8988 (unsigned long) ngnubuckets
);
8989 printf (_(" Length Number %% of total Coverage\n"));
8991 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
8992 if (gnubuckets
[hn
] != 0)
8994 bfd_vma off
, length
= 1;
8996 for (off
= gnubuckets
[hn
] - gnusymidx
;
8997 (gnuchains
[off
] & 1) == 0; ++off
)
8999 lengths
[hn
] = length
;
9000 if (length
> maxlength
)
9005 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
9008 error (_("Out of memory\n"));
9012 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
9013 ++counts
[lengths
[hn
]];
9015 if (ngnubuckets
> 0)
9018 printf (" 0 %-10lu (%5.1f%%)\n",
9019 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
9020 for (j
= 1; j
<= maxlength
; ++j
)
9022 nzero_counts
+= counts
[j
] * j
;
9023 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9024 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
9025 (nzero_counts
* 100.0) / nsyms
);
9039 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
9043 if (dynamic_syminfo
== NULL
9045 /* No syminfo, this is ok. */
9048 /* There better should be a dynamic symbol section. */
9049 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
9053 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9054 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
9056 printf (_(" Num: Name BoundTo Flags\n"));
9057 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
9059 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
9061 printf ("%4d: ", i
);
9062 if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
9063 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
9065 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
9068 switch (dynamic_syminfo
[i
].si_boundto
)
9070 case SYMINFO_BT_SELF
:
9071 fputs ("SELF ", stdout
);
9073 case SYMINFO_BT_PARENT
:
9074 fputs ("PARENT ", stdout
);
9077 if (dynamic_syminfo
[i
].si_boundto
> 0
9078 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
9079 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
9081 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
9085 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
9089 if (flags
& SYMINFO_FLG_DIRECT
)
9091 if (flags
& SYMINFO_FLG_PASSTHRU
)
9092 printf (" PASSTHRU");
9093 if (flags
& SYMINFO_FLG_COPY
)
9095 if (flags
& SYMINFO_FLG_LAZYLOAD
)
9096 printf (" LAZYLOAD");
9104 /* Check to see if the given reloc needs to be handled in a target specific
9105 manner. If so then process the reloc and return TRUE otherwise return
9109 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
9110 unsigned char * start
,
9111 Elf_Internal_Sym
* symtab
)
9113 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
9115 switch (elf_header
.e_machine
)
9118 case EM_CYGNUS_MN10300
:
9120 static Elf_Internal_Sym
* saved_sym
= NULL
;
9124 case 34: /* R_MN10300_ALIGN */
9126 case 33: /* R_MN10300_SYM_DIFF */
9127 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
9129 case 1: /* R_MN10300_32 */
9130 case 2: /* R_MN10300_16 */
9131 if (saved_sym
!= NULL
)
9135 value
= reloc
->r_addend
9136 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
9137 - saved_sym
->st_value
);
9139 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
9146 if (saved_sym
!= NULL
)
9147 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9157 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9158 DWARF debug sections. This is a target specific test. Note - we do not
9159 go through the whole including-target-headers-multiple-times route, (as
9160 we have already done with <elf/h8.h>) because this would become very
9161 messy and even then this function would have to contain target specific
9162 information (the names of the relocs instead of their numeric values).
9163 FIXME: This is not the correct way to solve this problem. The proper way
9164 is to have target specific reloc sizing and typing functions created by
9165 the reloc-macros.h header, in the same way that it already creates the
9166 reloc naming functions. */
9169 is_32bit_abs_reloc (unsigned int reloc_type
)
9171 switch (elf_header
.e_machine
)
9175 return reloc_type
== 1; /* R_386_32. */
9177 return reloc_type
== 1; /* R_68K_32. */
9179 return reloc_type
== 1; /* R_860_32. */
9181 return reloc_type
== 1; /* XXX Is this right ? */
9183 return reloc_type
== 1; /* R_ARC_32. */
9185 return reloc_type
== 2; /* R_ARM_ABS32 */
9188 return reloc_type
== 1;
9190 return reloc_type
== 0x12; /* R_byte4_data. */
9192 return reloc_type
== 3; /* R_CRIS_32. */
9195 return reloc_type
== 3; /* R_CR16_NUM32. */
9197 return reloc_type
== 15; /* R_CRX_NUM32. */
9199 return reloc_type
== 1;
9200 case EM_CYGNUS_D10V
:
9202 return reloc_type
== 6; /* R_D10V_32. */
9203 case EM_CYGNUS_D30V
:
9205 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
9207 return reloc_type
== 3; /* R_DLX_RELOC_32. */
9208 case EM_CYGNUS_FR30
:
9210 return reloc_type
== 3; /* R_FR30_32. */
9214 return reloc_type
== 1; /* R_H8_DIR32. */
9216 return reloc_type
== 0x65; /* R_IA64_SECREL32LSB. */
9219 return reloc_type
== 2; /* R_IP2K_32. */
9221 return reloc_type
== 2; /* R_IQ2000_32. */
9222 case EM_LATTICEMICO32
:
9223 return reloc_type
== 3; /* R_LM32_32. */
9226 return reloc_type
== 3; /* R_M32C_32. */
9228 return reloc_type
== 34; /* R_M32R_32_RELA. */
9230 return reloc_type
== 1; /* R_MCORE_ADDR32. */
9232 return reloc_type
== 4; /* R_MEP_32. */
9234 return reloc_type
== 2; /* R_MIPS_32. */
9236 return reloc_type
== 4; /* R_MMIX_32. */
9237 case EM_CYGNUS_MN10200
:
9239 return reloc_type
== 1; /* R_MN10200_32. */
9240 case EM_CYGNUS_MN10300
:
9242 return reloc_type
== 1; /* R_MN10300_32. */
9245 return reloc_type
== 1; /* R_MSP43_32. */
9247 return reloc_type
== 2; /* R_MT_32. */
9248 case EM_ALTERA_NIOS2
:
9250 return reloc_type
== 1; /* R_NIOS_32. */
9253 return reloc_type
== 1; /* R_OR32_32. */
9255 return (reloc_type
== 1 /* R_PARISC_DIR32. */
9256 || reloc_type
== 41); /* R_PARISC_SECREL32. */
9259 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
9261 return reloc_type
== 1; /* R_PPC64_ADDR32. */
9263 return reloc_type
== 1; /* R_PPC_ADDR32. */
9265 return reloc_type
== 1; /* R_RX_DIR32. */
9267 return reloc_type
== 1; /* R_I370_ADDR31. */
9270 return reloc_type
== 4; /* R_S390_32. */
9272 return reloc_type
== 8; /* R_SCORE_ABS32. */
9274 return reloc_type
== 1; /* R_SH_DIR32. */
9275 case EM_SPARC32PLUS
:
9278 return reloc_type
== 3 /* R_SPARC_32. */
9279 || reloc_type
== 23; /* R_SPARC_UA32. */
9281 return reloc_type
== 6; /* R_SPU_ADDR32 */
9283 return reloc_type
== 1; /* R_C6000_ABS32. */
9284 case EM_CYGNUS_V850
:
9286 return reloc_type
== 6; /* R_V850_ABS32. */
9288 return reloc_type
== 1; /* R_VAX_32. */
9291 return reloc_type
== 10; /* R_X86_64_32. */
9294 return reloc_type
== 3; /* R_XC16C_ABS_32. */
9296 return reloc_type
== 1; /* R_XSTROMY16_32. */
9299 return reloc_type
== 1; /* R_XTENSA_32. */
9301 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9302 elf_header
.e_machine
);
9307 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9308 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9311 is_32bit_pcrel_reloc (unsigned int reloc_type
)
9313 switch (elf_header
.e_machine
)
9317 return reloc_type
== 2; /* R_386_PC32. */
9319 return reloc_type
== 4; /* R_68K_PC32. */
9321 return reloc_type
== 10; /* R_ALPHA_SREL32. */
9323 return reloc_type
== 3; /* R_ARM_REL32 */
9325 return reloc_type
== 9; /* R_PARISC_PCREL32. */
9327 return reloc_type
== 26; /* R_PPC_REL32. */
9329 return reloc_type
== 26; /* R_PPC64_REL32. */
9332 return reloc_type
== 5; /* R_390_PC32. */
9334 return reloc_type
== 2; /* R_SH_REL32. */
9335 case EM_SPARC32PLUS
:
9338 return reloc_type
== 6; /* R_SPARC_DISP32. */
9340 return reloc_type
== 13; /* R_SPU_REL32. */
9343 return reloc_type
== 2; /* R_X86_64_PC32. */
9346 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
9348 /* Do not abort or issue an error message here. Not all targets use
9349 pc-relative 32-bit relocs in their DWARF debug information and we
9350 have already tested for target coverage in is_32bit_abs_reloc. A
9351 more helpful warning message will be generated by apply_relocations
9352 anyway, so just return. */
9357 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9358 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9361 is_64bit_abs_reloc (unsigned int reloc_type
)
9363 switch (elf_header
.e_machine
)
9366 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
9368 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
9370 return reloc_type
== 80; /* R_PARISC_DIR64. */
9372 return reloc_type
== 38; /* R_PPC64_ADDR64. */
9373 case EM_SPARC32PLUS
:
9376 return reloc_type
== 54; /* R_SPARC_UA64. */
9379 return reloc_type
== 1; /* R_X86_64_64. */
9382 return reloc_type
== 22; /* R_S390_64 */
9384 return reloc_type
== 18; /* R_MIPS_64 */
9390 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9391 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9394 is_64bit_pcrel_reloc (unsigned int reloc_type
)
9396 switch (elf_header
.e_machine
)
9399 return reloc_type
== 11; /* R_ALPHA_SREL64 */
9401 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB */
9403 return reloc_type
== 72; /* R_PARISC_PCREL64 */
9405 return reloc_type
== 44; /* R_PPC64_REL64 */
9406 case EM_SPARC32PLUS
:
9409 return reloc_type
== 46; /* R_SPARC_DISP64 */
9412 return reloc_type
== 24; /* R_X86_64_PC64 */
9415 return reloc_type
== 23; /* R_S390_PC64 */
9421 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9422 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9425 is_24bit_abs_reloc (unsigned int reloc_type
)
9427 switch (elf_header
.e_machine
)
9429 case EM_CYGNUS_MN10200
:
9431 return reloc_type
== 4; /* R_MN10200_24. */
9437 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9438 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9441 is_16bit_abs_reloc (unsigned int reloc_type
)
9443 switch (elf_header
.e_machine
)
9447 return reloc_type
== 4; /* R_AVR_16. */
9448 case EM_CYGNUS_D10V
:
9450 return reloc_type
== 3; /* R_D10V_16. */
9454 return reloc_type
== R_H8_DIR16
;
9457 return reloc_type
== 1; /* R_IP2K_16. */
9460 return reloc_type
== 1; /* R_M32C_16 */
9463 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
9464 case EM_ALTERA_NIOS2
:
9466 return reloc_type
== 9; /* R_NIOS_16. */
9468 return reloc_type
== 2; /* R_C6000_ABS16. */
9471 return reloc_type
== 2; /* R_XC16C_ABS_16. */
9477 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9478 relocation entries (possibly formerly used for SHT_GROUP sections). */
9481 is_none_reloc (unsigned int reloc_type
)
9483 switch (elf_header
.e_machine
)
9485 case EM_68K
: /* R_68K_NONE. */
9486 case EM_386
: /* R_386_NONE. */
9487 case EM_SPARC32PLUS
:
9489 case EM_SPARC
: /* R_SPARC_NONE. */
9490 case EM_MIPS
: /* R_MIPS_NONE. */
9491 case EM_PARISC
: /* R_PARISC_NONE. */
9492 case EM_ALPHA
: /* R_ALPHA_NONE. */
9493 case EM_PPC
: /* R_PPC_NONE. */
9494 case EM_PPC64
: /* R_PPC64_NONE. */
9495 case EM_ARM
: /* R_ARM_NONE. */
9496 case EM_IA_64
: /* R_IA64_NONE. */
9497 case EM_SH
: /* R_SH_NONE. */
9499 case EM_S390
: /* R_390_NONE. */
9500 case EM_CRIS
: /* R_CRIS_NONE. */
9501 case EM_X86_64
: /* R_X86_64_NONE. */
9502 case EM_L1OM
: /* R_X86_64_NONE. */
9503 case EM_MN10300
: /* R_MN10300_NONE. */
9504 case EM_M32R
: /* R_M32R_NONE. */
9505 case EM_TI_C6000
:/* R_C6000_NONE. */
9507 case EM_C166
: /* R_XC16X_NONE. */
9508 return reloc_type
== 0;
9511 return (reloc_type
== 0 /* R_XTENSA_NONE. */
9512 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
9513 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
9514 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
9519 /* Apply relocations to a section.
9520 Note: So far support has been added only for those relocations
9521 which can be found in debug sections.
9522 FIXME: Add support for more relocations ? */
9525 apply_relocations (void * file
,
9526 Elf_Internal_Shdr
* section
,
9527 unsigned char * start
)
9529 Elf_Internal_Shdr
* relsec
;
9530 unsigned char * end
= start
+ section
->sh_size
;
9532 if (elf_header
.e_type
!= ET_REL
)
9535 /* Find the reloc section associated with the section. */
9536 for (relsec
= section_headers
;
9537 relsec
< section_headers
+ elf_header
.e_shnum
;
9540 bfd_boolean is_rela
;
9541 unsigned long num_relocs
;
9542 Elf_Internal_Rela
* relocs
;
9543 Elf_Internal_Rela
* rp
;
9544 Elf_Internal_Shdr
* symsec
;
9545 Elf_Internal_Sym
* symtab
;
9546 Elf_Internal_Sym
* sym
;
9548 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9549 || relsec
->sh_info
>= elf_header
.e_shnum
9550 || section_headers
+ relsec
->sh_info
!= section
9551 || relsec
->sh_size
== 0
9552 || relsec
->sh_link
>= elf_header
.e_shnum
)
9555 is_rela
= relsec
->sh_type
== SHT_RELA
;
9559 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
9560 relsec
->sh_size
, & relocs
, & num_relocs
))
9565 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
9566 relsec
->sh_size
, & relocs
, & num_relocs
))
9570 /* SH uses RELA but uses in place value instead of the addend field. */
9571 if (elf_header
.e_machine
== EM_SH
)
9574 symsec
= section_headers
+ relsec
->sh_link
;
9575 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
);
9577 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
9580 unsigned int reloc_type
;
9581 unsigned int reloc_size
;
9582 unsigned char * rloc
;
9584 reloc_type
= get_reloc_type (rp
->r_info
);
9586 if (target_specific_reloc_handling (rp
, start
, symtab
))
9588 else if (is_none_reloc (reloc_type
))
9590 else if (is_32bit_abs_reloc (reloc_type
)
9591 || is_32bit_pcrel_reloc (reloc_type
))
9593 else if (is_64bit_abs_reloc (reloc_type
)
9594 || is_64bit_pcrel_reloc (reloc_type
))
9596 else if (is_24bit_abs_reloc (reloc_type
))
9598 else if (is_16bit_abs_reloc (reloc_type
))
9602 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9603 reloc_type
, SECTION_NAME (section
));
9607 rloc
= start
+ rp
->r_offset
;
9608 if ((rloc
+ reloc_size
) > end
)
9610 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9611 (unsigned long) rp
->r_offset
,
9612 SECTION_NAME (section
));
9616 sym
= symtab
+ get_reloc_symindex (rp
->r_info
);
9618 /* If the reloc has a symbol associated with it,
9619 make sure that it is of an appropriate type.
9621 Relocations against symbols without type can happen.
9622 Gcc -feliminate-dwarf2-dups may generate symbols
9623 without type for debug info.
9625 Icc generates relocations against function symbols
9626 instead of local labels.
9628 Relocations against object symbols can happen, eg when
9629 referencing a global array. For an example of this see
9630 the _clz.o binary in libgcc.a. */
9632 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
9634 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9635 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
9636 (long int)(rp
- relocs
),
9637 SECTION_NAME (relsec
));
9643 addend
+= rp
->r_addend
;
9644 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
9646 || (elf_header
.e_machine
== EM_XTENSA
9648 || ((elf_header
.e_machine
== EM_PJ
9649 || elf_header
.e_machine
== EM_PJ_OLD
)
9650 && reloc_type
== 1))
9651 addend
+= byte_get (rloc
, reloc_size
);
9653 if (is_32bit_pcrel_reloc (reloc_type
)
9654 || is_64bit_pcrel_reloc (reloc_type
))
9656 /* On HPPA, all pc-relative relocations are biased by 8. */
9657 if (elf_header
.e_machine
== EM_PARISC
)
9659 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
9663 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
9672 #ifdef SUPPORT_DISASSEMBLY
9674 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
9676 printf (_("\nAssembly dump of section %s\n"),
9677 SECTION_NAME (section
));
9679 /* XXX -- to be done --- XXX */
9685 /* Reads in the contents of SECTION from FILE, returning a pointer
9686 to a malloc'ed buffer or NULL if something went wrong. */
9689 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
9691 bfd_size_type num_bytes
;
9693 num_bytes
= section
->sh_size
;
9695 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
9697 printf (_("\nSection '%s' has no data to dump.\n"),
9698 SECTION_NAME (section
));
9702 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
9703 _("section contents"));
9708 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
9710 Elf_Internal_Shdr
* relsec
;
9711 bfd_size_type num_bytes
;
9715 char * name
= SECTION_NAME (section
);
9716 bfd_boolean some_strings_shown
;
9718 start
= get_section_contents (section
, file
);
9722 printf (_("\nString dump of section '%s':\n"), name
);
9724 /* If the section being dumped has relocations against it the user might
9725 be expecting these relocations to have been applied. Check for this
9726 case and issue a warning message in order to avoid confusion.
9727 FIXME: Maybe we ought to have an option that dumps a section with
9729 for (relsec
= section_headers
;
9730 relsec
< section_headers
+ elf_header
.e_shnum
;
9733 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9734 || relsec
->sh_info
>= elf_header
.e_shnum
9735 || section_headers
+ relsec
->sh_info
!= section
9736 || relsec
->sh_size
== 0
9737 || relsec
->sh_link
>= elf_header
.e_shnum
)
9740 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9744 num_bytes
= section
->sh_size
;
9746 end
= start
+ num_bytes
;
9747 some_strings_shown
= FALSE
;
9751 while (!ISPRINT (* data
))
9758 /* PR 11128: Use two separate invocations in order to work
9759 around bugs in the Solaris 8 implementation of printf. */
9760 printf (" [%6tx] ", data
- start
);
9761 printf ("%s\n", data
);
9763 printf (" [%6Ix] %s\n", (size_t) (data
- start
), data
);
9765 data
+= strlen (data
);
9766 some_strings_shown
= TRUE
;
9770 if (! some_strings_shown
)
9771 printf (_(" No strings found in this section."));
9779 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
9781 bfd_boolean relocate
)
9783 Elf_Internal_Shdr
* relsec
;
9784 bfd_size_type bytes
;
9786 unsigned char * data
;
9787 unsigned char * start
;
9789 start
= (unsigned char *) get_section_contents (section
, file
);
9793 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
9797 apply_relocations (file
, section
, start
);
9801 /* If the section being dumped has relocations against it the user might
9802 be expecting these relocations to have been applied. Check for this
9803 case and issue a warning message in order to avoid confusion.
9804 FIXME: Maybe we ought to have an option that dumps a section with
9806 for (relsec
= section_headers
;
9807 relsec
< section_headers
+ elf_header
.e_shnum
;
9810 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
9811 || relsec
->sh_info
>= elf_header
.e_shnum
9812 || section_headers
+ relsec
->sh_info
!= section
9813 || relsec
->sh_size
== 0
9814 || relsec
->sh_link
>= elf_header
.e_shnum
)
9817 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9822 addr
= section
->sh_addr
;
9823 bytes
= section
->sh_size
;
9832 lbytes
= (bytes
> 16 ? 16 : bytes
);
9834 printf (" 0x%8.8lx ", (unsigned long) addr
);
9836 for (j
= 0; j
< 16; j
++)
9839 printf ("%2.2x", data
[j
]);
9847 for (j
= 0; j
< lbytes
; j
++)
9850 if (k
>= ' ' && k
< 0x7f)
9868 /* Uncompresses a section that was compressed using zlib, in place.
9869 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
9872 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED
,
9873 dwarf_size_type
*size ATTRIBUTE_UNUSED
)
9878 dwarf_size_type compressed_size
= *size
;
9879 unsigned char * compressed_buffer
= *buffer
;
9880 dwarf_size_type uncompressed_size
;
9881 unsigned char * uncompressed_buffer
;
9884 dwarf_size_type header_size
= 12;
9886 /* Read the zlib header. In this case, it should be "ZLIB" followed
9887 by the uncompressed section size, 8 bytes in big-endian order. */
9888 if (compressed_size
< header_size
9889 || ! streq ((char *) compressed_buffer
, "ZLIB"))
9892 uncompressed_size
= compressed_buffer
[4]; uncompressed_size
<<= 8;
9893 uncompressed_size
+= compressed_buffer
[5]; uncompressed_size
<<= 8;
9894 uncompressed_size
+= compressed_buffer
[6]; uncompressed_size
<<= 8;
9895 uncompressed_size
+= compressed_buffer
[7]; uncompressed_size
<<= 8;
9896 uncompressed_size
+= compressed_buffer
[8]; uncompressed_size
<<= 8;
9897 uncompressed_size
+= compressed_buffer
[9]; uncompressed_size
<<= 8;
9898 uncompressed_size
+= compressed_buffer
[10]; uncompressed_size
<<= 8;
9899 uncompressed_size
+= compressed_buffer
[11];
9901 /* It is possible the section consists of several compressed
9902 buffers concatenated together, so we uncompress in a loop. */
9906 strm
.avail_in
= compressed_size
- header_size
;
9907 strm
.next_in
= (Bytef
*) compressed_buffer
+ header_size
;
9908 strm
.avail_out
= uncompressed_size
;
9909 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
9911 rc
= inflateInit (& strm
);
9912 while (strm
.avail_in
> 0)
9916 strm
.next_out
= ((Bytef
*) uncompressed_buffer
9917 + (uncompressed_size
- strm
.avail_out
));
9918 rc
= inflate (&strm
, Z_FINISH
);
9919 if (rc
!= Z_STREAM_END
)
9921 rc
= inflateReset (& strm
);
9923 rc
= inflateEnd (& strm
);
9925 || strm
.avail_out
!= 0)
9928 free (compressed_buffer
);
9929 *buffer
= uncompressed_buffer
;
9930 *size
= uncompressed_size
;
9934 free (uncompressed_buffer
);
9936 #endif /* HAVE_ZLIB_H */
9940 load_specific_debug_section (enum dwarf_section_display_enum debug
,
9941 Elf_Internal_Shdr
* sec
, void * file
)
9943 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9945 int section_is_compressed
;
9947 /* If it is already loaded, do nothing. */
9948 if (section
->start
!= NULL
)
9951 section_is_compressed
= section
->name
== section
->compressed_name
;
9953 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
9954 section
->address
= sec
->sh_addr
;
9955 section
->size
= sec
->sh_size
;
9956 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
9959 if (section
->start
== NULL
)
9962 if (section_is_compressed
)
9964 if (! uncompress_section_contents (§ion
->start
, §ion
->size
))
9966 sec
->sh_size
= section
->size
;
9969 if (debug_displays
[debug
].relocate
)
9970 apply_relocations ((FILE *) file
, sec
, section
->start
);
9976 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
9978 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
9979 Elf_Internal_Shdr
* sec
;
9981 /* Locate the debug section. */
9982 sec
= find_section (section
->uncompressed_name
);
9984 section
->name
= section
->uncompressed_name
;
9987 sec
= find_section (section
->compressed_name
);
9989 section
->name
= section
->compressed_name
;
9994 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
9998 free_debug_section (enum dwarf_section_display_enum debug
)
10000 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
10002 if (section
->start
== NULL
)
10005 free ((char *) section
->start
);
10006 section
->start
= NULL
;
10007 section
->address
= 0;
10012 display_debug_section (Elf_Internal_Shdr
* section
, FILE * file
)
10014 char * name
= SECTION_NAME (section
);
10015 bfd_size_type length
;
10019 length
= section
->sh_size
;
10022 printf (_("\nSection '%s' has no debugging data.\n"), name
);
10025 if (section
->sh_type
== SHT_NOBITS
)
10027 /* There is no point in dumping the contents of a debugging section
10028 which has the NOBITS type - the bits in the file will be random.
10029 This can happen when a file containing a .eh_frame section is
10030 stripped with the --only-keep-debug command line option. */
10031 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name
);
10035 if (const_strneq (name
, ".gnu.linkonce.wi."))
10036 name
= ".debug_info";
10038 /* See if we know how to display the contents of this section. */
10039 for (i
= 0; i
< max
; i
++)
10040 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
10041 || streq (debug_displays
[i
].section
.compressed_name
, name
))
10043 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
10044 int secondary
= (section
!= find_section (name
));
10047 free_debug_section ((enum dwarf_section_display_enum
) i
);
10049 if (streq (sec
->uncompressed_name
, name
))
10050 sec
->name
= sec
->uncompressed_name
;
10052 sec
->name
= sec
->compressed_name
;
10053 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
10056 result
&= debug_displays
[i
].display (sec
, file
);
10058 if (secondary
|| (i
!= info
&& i
!= abbrev
))
10059 free_debug_section ((enum dwarf_section_display_enum
) i
);
10067 printf (_("Unrecognized debug section: %s\n"), name
);
10074 /* Set DUMP_SECTS for all sections where dumps were requested
10075 based on section name. */
10078 initialise_dumps_byname (void)
10080 struct dump_list_entry
* cur
;
10082 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
10087 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
10088 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
10090 request_dump_bynumber (i
, cur
->type
);
10095 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10101 process_section_contents (FILE * file
)
10103 Elf_Internal_Shdr
* section
;
10109 initialise_dumps_byname ();
10111 for (i
= 0, section
= section_headers
;
10112 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
10115 #ifdef SUPPORT_DISASSEMBLY
10116 if (dump_sects
[i
] & DISASS_DUMP
)
10117 disassemble_section (section
, file
);
10119 if (dump_sects
[i
] & HEX_DUMP
)
10120 dump_section_as_bytes (section
, file
, FALSE
);
10122 if (dump_sects
[i
] & RELOC_DUMP
)
10123 dump_section_as_bytes (section
, file
, TRUE
);
10125 if (dump_sects
[i
] & STRING_DUMP
)
10126 dump_section_as_strings (section
, file
);
10128 if (dump_sects
[i
] & DEBUG_DUMP
)
10129 display_debug_section (section
, file
);
10132 /* Check to see if the user requested a
10133 dump of a section that does not exist. */
10134 while (i
++ < num_dump_sects
)
10136 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
10140 process_mips_fpe_exception (int mask
)
10145 if (mask
& OEX_FPU_INEX
)
10146 fputs ("INEX", stdout
), first
= 0;
10147 if (mask
& OEX_FPU_UFLO
)
10148 printf ("%sUFLO", first
? "" : "|"), first
= 0;
10149 if (mask
& OEX_FPU_OFLO
)
10150 printf ("%sOFLO", first
? "" : "|"), first
= 0;
10151 if (mask
& OEX_FPU_DIV0
)
10152 printf ("%sDIV0", first
? "" : "|"), first
= 0;
10153 if (mask
& OEX_FPU_INVAL
)
10154 printf ("%sINVAL", first
? "" : "|");
10157 fputs ("0", stdout
);
10160 /* ARM EABI attributes section. */
10165 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10167 const char ** table
;
10168 } arm_attr_public_tag
;
10170 static const char * arm_attr_tag_CPU_arch
[] =
10171 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10172 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10173 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
10174 static const char * arm_attr_tag_THUMB_ISA_use
[] =
10175 {"No", "Thumb-1", "Thumb-2"};
10176 static const char * arm_attr_tag_FP_arch
[] =
10177 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10178 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
10179 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
10180 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10181 static const char * arm_attr_tag_PCS_config
[] =
10182 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10183 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10184 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
10185 {"V6", "SB", "TLS", "Unused"};
10186 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
10187 {"Absolute", "PC-relative", "SB-relative", "None"};
10188 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
10189 {"Absolute", "PC-relative", "None"};
10190 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
10191 {"None", "direct", "GOT-indirect"};
10192 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
10193 {"None", "??? 1", "2", "??? 3", "4"};
10194 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
10195 static const char * arm_attr_tag_ABI_FP_denormal
[] =
10196 {"Unused", "Needed", "Sign only"};
10197 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
10198 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
10199 static const char * arm_attr_tag_ABI_FP_number_model
[] =
10200 {"Unused", "Finite", "RTABI", "IEEE 754"};
10201 static const char * arm_attr_tag_ABI_enum_size
[] =
10202 {"Unused", "small", "int", "forced to int"};
10203 static const char * arm_attr_tag_ABI_HardFP_use
[] =
10204 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10205 static const char * arm_attr_tag_ABI_VFP_args
[] =
10206 {"AAPCS", "VFP registers", "custom"};
10207 static const char * arm_attr_tag_ABI_WMMX_args
[] =
10208 {"AAPCS", "WMMX registers", "custom"};
10209 static const char * arm_attr_tag_ABI_optimization_goals
[] =
10210 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10211 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10212 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
10213 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10214 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10215 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
10216 static const char * arm_attr_tag_FP_HP_extension
[] =
10217 {"Not Allowed", "Allowed"};
10218 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
10219 {"None", "IEEE 754", "Alternative Format"};
10220 static const char * arm_attr_tag_MPextension_use
[] =
10221 {"Not Allowed", "Allowed"};
10222 static const char * arm_attr_tag_DIV_use
[] =
10223 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10224 "Allowed in v7-A with integer division extension"};
10225 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
10226 static const char * arm_attr_tag_Virtualization_use
[] =
10227 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10228 "TrustZone and Virtualization Extensions"};
10229 static const char * arm_attr_tag_MPextension_use_legacy
[] =
10230 {"Not Allowed", "Allowed"};
10232 #define LOOKUP(id, name) \
10233 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10234 static arm_attr_public_tag arm_attr_public_tags
[] =
10236 {4, "CPU_raw_name", 1, NULL
},
10237 {5, "CPU_name", 1, NULL
},
10238 LOOKUP(6, CPU_arch
),
10239 {7, "CPU_arch_profile", 0, NULL
},
10240 LOOKUP(8, ARM_ISA_use
),
10241 LOOKUP(9, THUMB_ISA_use
),
10242 LOOKUP(10, FP_arch
),
10243 LOOKUP(11, WMMX_arch
),
10244 LOOKUP(12, Advanced_SIMD_arch
),
10245 LOOKUP(13, PCS_config
),
10246 LOOKUP(14, ABI_PCS_R9_use
),
10247 LOOKUP(15, ABI_PCS_RW_data
),
10248 LOOKUP(16, ABI_PCS_RO_data
),
10249 LOOKUP(17, ABI_PCS_GOT_use
),
10250 LOOKUP(18, ABI_PCS_wchar_t
),
10251 LOOKUP(19, ABI_FP_rounding
),
10252 LOOKUP(20, ABI_FP_denormal
),
10253 LOOKUP(21, ABI_FP_exceptions
),
10254 LOOKUP(22, ABI_FP_user_exceptions
),
10255 LOOKUP(23, ABI_FP_number_model
),
10256 {24, "ABI_align_needed", 0, NULL
},
10257 {25, "ABI_align_preserved", 0, NULL
},
10258 LOOKUP(26, ABI_enum_size
),
10259 LOOKUP(27, ABI_HardFP_use
),
10260 LOOKUP(28, ABI_VFP_args
),
10261 LOOKUP(29, ABI_WMMX_args
),
10262 LOOKUP(30, ABI_optimization_goals
),
10263 LOOKUP(31, ABI_FP_optimization_goals
),
10264 {32, "compatibility", 0, NULL
},
10265 LOOKUP(34, CPU_unaligned_access
),
10266 LOOKUP(36, FP_HP_extension
),
10267 LOOKUP(38, ABI_FP_16bit_format
),
10268 LOOKUP(42, MPextension_use
),
10269 LOOKUP(44, DIV_use
),
10270 {64, "nodefaults", 0, NULL
},
10271 {65, "also_compatible_with", 0, NULL
},
10272 LOOKUP(66, T2EE_use
),
10273 {67, "conformance", 1, NULL
},
10274 LOOKUP(68, Virtualization_use
),
10275 LOOKUP(70, MPextension_use_legacy
)
10279 static unsigned char *
10280 display_arm_attribute (unsigned char * p
)
10285 arm_attr_public_tag
* attr
;
10289 tag
= read_uleb128 (p
, &len
);
10292 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
10294 if (arm_attr_public_tags
[i
].tag
== tag
)
10296 attr
= &arm_attr_public_tags
[i
];
10303 printf (" Tag_%s: ", attr
->name
);
10304 switch (attr
->type
)
10309 case 7: /* Tag_CPU_arch_profile. */
10310 val
= read_uleb128 (p
, &len
);
10314 case 0: printf (_("None\n")); break;
10315 case 'A': printf (_("Application\n")); break;
10316 case 'R': printf (_("Realtime\n")); break;
10317 case 'M': printf (_("Microcontroller\n")); break;
10318 case 'S': printf (_("Application or Realtime\n")); break;
10319 default: printf ("??? (%d)\n", val
); break;
10323 case 24: /* Tag_align_needed. */
10324 val
= read_uleb128 (p
, &len
);
10328 case 0: printf (_("None\n")); break;
10329 case 1: printf (_("8-byte\n")); break;
10330 case 2: printf (_("4-byte\n")); break;
10331 case 3: printf ("??? 3\n"); break;
10334 printf (_("8-byte and up to %d-byte extended\n"),
10337 printf ("??? (%d)\n", val
);
10342 case 25: /* Tag_align_preserved. */
10343 val
= read_uleb128 (p
, &len
);
10347 case 0: printf (_("None\n")); break;
10348 case 1: printf (_("8-byte, except leaf SP\n")); break;
10349 case 2: printf (_("8-byte\n")); break;
10350 case 3: printf ("??? 3\n"); break;
10353 printf (_("8-byte and up to %d-byte extended\n"),
10356 printf ("??? (%d)\n", val
);
10361 case 32: /* Tag_compatibility. */
10362 val
= read_uleb128 (p
, &len
);
10364 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10365 p
+= strlen ((char *) p
) + 1;
10368 case 64: /* Tag_nodefaults. */
10370 printf (_("True\n"));
10373 case 65: /* Tag_also_compatible_with. */
10374 val
= read_uleb128 (p
, &len
);
10376 if (val
== 6 /* Tag_CPU_arch. */)
10378 val
= read_uleb128 (p
, &len
);
10380 if ((unsigned int)val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
10381 printf ("??? (%d)\n", val
);
10383 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
10387 while (*(p
++) != '\0' /* NUL terminator. */);
10401 assert (attr
->type
& 0x80);
10402 val
= read_uleb128 (p
, &len
);
10404 type
= attr
->type
& 0x7f;
10406 printf ("??? (%d)\n", val
);
10408 printf ("%s\n", attr
->table
[val
]);
10415 type
= 1; /* String. */
10417 type
= 2; /* uleb128. */
10418 printf (" Tag_unknown_%d: ", tag
);
10423 printf ("\"%s\"\n", p
);
10424 p
+= strlen ((char *) p
) + 1;
10428 val
= read_uleb128 (p
, &len
);
10430 printf ("%d (0x%x)\n", val
, val
);
10436 static unsigned char *
10437 display_gnu_attribute (unsigned char * p
,
10438 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10445 tag
= read_uleb128 (p
, &len
);
10448 /* Tag_compatibility is the only generic GNU attribute defined at
10452 val
= read_uleb128 (p
, &len
);
10454 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10455 p
+= strlen ((char *) p
) + 1;
10459 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
10460 return display_proc_gnu_attribute (p
, tag
);
10463 type
= 1; /* String. */
10465 type
= 2; /* uleb128. */
10466 printf (" Tag_unknown_%d: ", tag
);
10470 printf ("\"%s\"\n", p
);
10471 p
+= strlen ((char *) p
) + 1;
10475 val
= read_uleb128 (p
, &len
);
10477 printf ("%d (0x%x)\n", val
, val
);
10483 static unsigned char *
10484 display_power_gnu_attribute (unsigned char * p
, int tag
)
10490 if (tag
== Tag_GNU_Power_ABI_FP
)
10492 val
= read_uleb128 (p
, &len
);
10494 printf (" Tag_GNU_Power_ABI_FP: ");
10499 printf (_("Hard or soft float\n"));
10502 printf (_("Hard float\n"));
10505 printf (_("Soft float\n"));
10508 printf (_("Single-precision hard float\n"));
10511 printf ("??? (%d)\n", val
);
10517 if (tag
== Tag_GNU_Power_ABI_Vector
)
10519 val
= read_uleb128 (p
, &len
);
10521 printf (" Tag_GNU_Power_ABI_Vector: ");
10525 printf (_("Any\n"));
10528 printf (_("Generic\n"));
10531 printf ("AltiVec\n");
10537 printf ("??? (%d)\n", val
);
10543 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
10545 val
= read_uleb128 (p
, &len
);
10547 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10551 printf (_("Any\n"));
10554 printf ("r3/r4\n");
10557 printf (_("Memory\n"));
10560 printf ("??? (%d)\n", val
);
10567 type
= 1; /* String. */
10569 type
= 2; /* uleb128. */
10570 printf (" Tag_unknown_%d: ", tag
);
10574 printf ("\"%s\"\n", p
);
10575 p
+= strlen ((char *) p
) + 1;
10579 val
= read_uleb128 (p
, &len
);
10581 printf ("%d (0x%x)\n", val
, val
);
10587 static unsigned char *
10588 display_mips_gnu_attribute (unsigned char * p
, int tag
)
10594 if (tag
== Tag_GNU_MIPS_ABI_FP
)
10596 val
= read_uleb128 (p
, &len
);
10598 printf (" Tag_GNU_MIPS_ABI_FP: ");
10603 printf (_("Hard or soft float\n"));
10606 printf (_("Hard float (double precision)\n"));
10609 printf (_("Hard float (single precision)\n"));
10612 printf (_("Soft float\n"));
10615 printf (_("64-bit float (-mips32r2 -mfp64)\n"));
10618 printf ("??? (%d)\n", val
);
10625 type
= 1; /* String. */
10627 type
= 2; /* uleb128. */
10628 printf (" Tag_unknown_%d: ", tag
);
10632 printf ("\"%s\"\n", p
);
10633 p
+= strlen ((char *) p
) + 1;
10637 val
= read_uleb128 (p
, &len
);
10639 printf ("%d (0x%x)\n", val
, val
);
10645 static unsigned char *
10646 display_tic6x_attribute (unsigned char * p
)
10652 tag
= read_uleb128 (p
, &len
);
10657 case Tag_C6XABI_Tag_CPU_arch
:
10658 val
= read_uleb128 (p
, &len
);
10660 printf (" Tag_C6XABI_Tag_CPU_arch: ");
10664 case C6XABI_Tag_CPU_arch_none
:
10665 printf (_("None\n"));
10667 case C6XABI_Tag_CPU_arch_C62X
:
10670 case C6XABI_Tag_CPU_arch_C67X
:
10673 case C6XABI_Tag_CPU_arch_C67XP
:
10674 printf ("C67x+\n");
10676 case C6XABI_Tag_CPU_arch_C64X
:
10679 case C6XABI_Tag_CPU_arch_C64XP
:
10680 printf ("C64x+\n");
10682 case C6XABI_Tag_CPU_arch_C674X
:
10683 printf ("C674x\n");
10686 printf ("??? (%d)\n", val
);
10692 /* Tag_compatibility - treated as generic by binutils for now
10693 although not currently specified for C6X. */
10694 val
= read_uleb128 (p
, &len
);
10696 printf (_("flag = %d, vendor = %s\n"), val
, p
);
10697 p
+= strlen ((char *) p
) + 1;
10701 printf (" Tag_unknown_%d: ", tag
);
10703 /* No general documentation of handling unknown attributes, treat as
10704 ULEB128 for now. */
10705 val
= read_uleb128 (p
, &len
);
10707 printf ("%d (0x%x)\n", val
, val
);
10713 process_attributes (FILE * file
,
10714 const char * public_name
,
10715 unsigned int proc_type
,
10716 unsigned char * (* display_pub_attribute
) (unsigned char *),
10717 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int))
10719 Elf_Internal_Shdr
* sect
;
10720 unsigned char * contents
;
10722 unsigned char * end
;
10723 bfd_vma section_len
;
10727 /* Find the section header so that we get the size. */
10728 for (i
= 0, sect
= section_headers
;
10729 i
< elf_header
.e_shnum
;
10732 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
10735 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
10736 sect
->sh_size
, _("attributes"));
10737 if (contents
== NULL
)
10743 len
= sect
->sh_size
- 1;
10749 bfd_boolean public_section
;
10750 bfd_boolean gnu_section
;
10752 section_len
= byte_get (p
, 4);
10755 if (section_len
> len
)
10757 printf (_("ERROR: Bad section length (%d > %d)\n"),
10758 (int) section_len
, (int) len
);
10762 len
-= section_len
;
10763 printf (_("Attribute Section: %s\n"), p
);
10765 if (public_name
&& streq ((char *) p
, public_name
))
10766 public_section
= TRUE
;
10768 public_section
= FALSE
;
10770 if (streq ((char *) p
, "gnu"))
10771 gnu_section
= TRUE
;
10773 gnu_section
= FALSE
;
10775 namelen
= strlen ((char *) p
) + 1;
10777 section_len
-= namelen
+ 4;
10779 while (section_len
> 0)
10785 size
= byte_get (p
, 4);
10786 if (size
> section_len
)
10788 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10789 (int) size
, (int) section_len
);
10790 size
= section_len
;
10793 section_len
-= size
;
10794 end
= p
+ size
- 1;
10800 printf (_("File Attributes\n"));
10803 printf (_("Section Attributes:"));
10806 printf (_("Symbol Attributes:"));
10812 val
= read_uleb128 (p
, &j
);
10816 printf (" %d", val
);
10821 printf (_("Unknown tag: %d\n"), tag
);
10822 public_section
= FALSE
;
10826 if (public_section
)
10829 p
= display_pub_attribute (p
);
10831 else if (gnu_section
)
10834 p
= display_gnu_attribute (p
,
10835 display_proc_gnu_attribute
);
10839 /* ??? Do something sensible, like dump hex. */
10840 printf (_(" Unknown section contexts\n"));
10847 printf (_("Unknown format '%c'\n"), *p
);
10855 process_arm_specific (FILE * file
)
10857 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
10858 display_arm_attribute
, NULL
);
10862 process_power_specific (FILE * file
)
10864 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10865 display_power_gnu_attribute
);
10869 process_tic6x_specific (FILE * file
)
10871 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
10872 display_tic6x_attribute
, NULL
);
10875 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
10876 Print the Address, Access and Initial fields of an entry at VMA ADDR
10877 and return the VMA of the next entry. */
10880 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10883 print_vma (addr
, LONG_HEX
);
10885 if (addr
< pltgot
+ 0xfff0)
10886 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
10888 printf ("%10s", "");
10891 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10896 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10897 print_vma (entry
, LONG_HEX
);
10899 return addr
+ (is_32bit_elf
? 4 : 8);
10902 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
10903 PLTGOT. Print the Address and Initial fields of an entry at VMA
10904 ADDR and return the VMA of the next entry. */
10907 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
10910 print_vma (addr
, LONG_HEX
);
10913 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
10918 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
10919 print_vma (entry
, LONG_HEX
);
10921 return addr
+ (is_32bit_elf
? 4 : 8);
10925 process_mips_specific (FILE * file
)
10927 Elf_Internal_Dyn
* entry
;
10928 size_t liblist_offset
= 0;
10929 size_t liblistno
= 0;
10930 size_t conflictsno
= 0;
10931 size_t options_offset
= 0;
10932 size_t conflicts_offset
= 0;
10933 size_t pltrelsz
= 0;
10935 bfd_vma pltgot
= 0;
10936 bfd_vma mips_pltgot
= 0;
10937 bfd_vma jmprel
= 0;
10938 bfd_vma local_gotno
= 0;
10939 bfd_vma gotsym
= 0;
10940 bfd_vma symtabno
= 0;
10942 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
10943 display_mips_gnu_attribute
);
10945 /* We have a lot of special sections. Thanks SGI! */
10946 if (dynamic_section
== NULL
)
10947 /* No information available. */
10950 for (entry
= dynamic_section
; entry
->d_tag
!= DT_NULL
; ++entry
)
10951 switch (entry
->d_tag
)
10953 case DT_MIPS_LIBLIST
:
10955 = offset_from_vma (file
, entry
->d_un
.d_val
,
10956 liblistno
* sizeof (Elf32_External_Lib
));
10958 case DT_MIPS_LIBLISTNO
:
10959 liblistno
= entry
->d_un
.d_val
;
10961 case DT_MIPS_OPTIONS
:
10962 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
10964 case DT_MIPS_CONFLICT
:
10966 = offset_from_vma (file
, entry
->d_un
.d_val
,
10967 conflictsno
* sizeof (Elf32_External_Conflict
));
10969 case DT_MIPS_CONFLICTNO
:
10970 conflictsno
= entry
->d_un
.d_val
;
10973 pltgot
= entry
->d_un
.d_ptr
;
10975 case DT_MIPS_LOCAL_GOTNO
:
10976 local_gotno
= entry
->d_un
.d_val
;
10978 case DT_MIPS_GOTSYM
:
10979 gotsym
= entry
->d_un
.d_val
;
10981 case DT_MIPS_SYMTABNO
:
10982 symtabno
= entry
->d_un
.d_val
;
10984 case DT_MIPS_PLTGOT
:
10985 mips_pltgot
= entry
->d_un
.d_ptr
;
10988 pltrel
= entry
->d_un
.d_val
;
10991 pltrelsz
= entry
->d_un
.d_val
;
10994 jmprel
= entry
->d_un
.d_ptr
;
11000 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
11002 Elf32_External_Lib
* elib
;
11005 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
11007 sizeof (Elf32_External_Lib
),
11011 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11012 (unsigned long) liblistno
);
11013 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11016 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
11023 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11024 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11025 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11026 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11027 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11029 tmp
= gmtime (&atime
);
11030 snprintf (timebuf
, sizeof (timebuf
),
11031 "%04u-%02u-%02uT%02u:%02u:%02u",
11032 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11033 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11035 printf ("%3lu: ", (unsigned long) cnt
);
11036 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
11037 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
11039 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
11040 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
11041 liblist
.l_version
);
11043 if (liblist
.l_flags
== 0)
11047 static const struct
11054 { " EXACT_MATCH", LL_EXACT_MATCH
},
11055 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
11056 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
11057 { " EXPORTS", LL_EXPORTS
},
11058 { " DELAY_LOAD", LL_DELAY_LOAD
},
11059 { " DELTA", LL_DELTA
}
11061 int flags
= liblist
.l_flags
;
11064 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
11065 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
11067 fputs (l_flags_vals
[fcnt
].name
, stdout
);
11068 flags
^= l_flags_vals
[fcnt
].bit
;
11071 printf (" %#x", (unsigned int) flags
);
11081 if (options_offset
!= 0)
11083 Elf_External_Options
* eopt
;
11084 Elf_Internal_Shdr
* sect
= section_headers
;
11085 Elf_Internal_Options
* iopt
;
11086 Elf_Internal_Options
* option
;
11090 /* Find the section header so that we get the size. */
11091 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
11094 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
11095 sect
->sh_size
, _("options"));
11098 iopt
= (Elf_Internal_Options
*)
11099 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
11102 error (_("Out of memory\n"));
11109 while (offset
< sect
->sh_size
)
11111 Elf_External_Options
* eoption
;
11113 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
11115 option
->kind
= BYTE_GET (eoption
->kind
);
11116 option
->size
= BYTE_GET (eoption
->size
);
11117 option
->section
= BYTE_GET (eoption
->section
);
11118 option
->info
= BYTE_GET (eoption
->info
);
11120 offset
+= option
->size
;
11126 printf (_("\nSection '%s' contains %d entries:\n"),
11127 SECTION_NAME (sect
), cnt
);
11135 switch (option
->kind
)
11138 /* This shouldn't happen. */
11139 printf (" NULL %d %lx", option
->section
, option
->info
);
11142 printf (" REGINFO ");
11143 if (elf_header
.e_machine
== EM_MIPS
)
11146 Elf32_External_RegInfo
* ereg
;
11147 Elf32_RegInfo reginfo
;
11149 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
11150 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11151 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11152 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11153 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11154 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11155 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11157 printf ("GPR %08lx GP 0x%lx\n",
11158 reginfo
.ri_gprmask
,
11159 (unsigned long) reginfo
.ri_gp_value
);
11160 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11161 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11162 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11167 Elf64_External_RegInfo
* ereg
;
11168 Elf64_Internal_RegInfo reginfo
;
11170 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
11171 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
11172 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
11173 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
11174 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
11175 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
11176 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
11178 printf ("GPR %08lx GP 0x",
11179 reginfo
.ri_gprmask
);
11180 printf_vma (reginfo
.ri_gp_value
);
11183 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11184 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
11185 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
11189 case ODK_EXCEPTIONS
:
11190 fputs (" EXCEPTIONS fpe_min(", stdout
);
11191 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
11192 fputs (") fpe_max(", stdout
);
11193 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
11194 fputs (")", stdout
);
11196 if (option
->info
& OEX_PAGE0
)
11197 fputs (" PAGE0", stdout
);
11198 if (option
->info
& OEX_SMM
)
11199 fputs (" SMM", stdout
);
11200 if (option
->info
& OEX_FPDBUG
)
11201 fputs (" FPDBUG", stdout
);
11202 if (option
->info
& OEX_DISMISS
)
11203 fputs (" DISMISS", stdout
);
11206 fputs (" PAD ", stdout
);
11207 if (option
->info
& OPAD_PREFIX
)
11208 fputs (" PREFIX", stdout
);
11209 if (option
->info
& OPAD_POSTFIX
)
11210 fputs (" POSTFIX", stdout
);
11211 if (option
->info
& OPAD_SYMBOL
)
11212 fputs (" SYMBOL", stdout
);
11215 fputs (" HWPATCH ", stdout
);
11216 if (option
->info
& OHW_R4KEOP
)
11217 fputs (" R4KEOP", stdout
);
11218 if (option
->info
& OHW_R8KPFETCH
)
11219 fputs (" R8KPFETCH", stdout
);
11220 if (option
->info
& OHW_R5KEOP
)
11221 fputs (" R5KEOP", stdout
);
11222 if (option
->info
& OHW_R5KCVTL
)
11223 fputs (" R5KCVTL", stdout
);
11226 fputs (" FILL ", stdout
);
11227 /* XXX Print content of info word? */
11230 fputs (" TAGS ", stdout
);
11231 /* XXX Print content of info word? */
11234 fputs (" HWAND ", stdout
);
11235 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11236 fputs (" R4KEOP_CHECKED", stdout
);
11237 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11238 fputs (" R4KEOP_CLEAN", stdout
);
11241 fputs (" HWOR ", stdout
);
11242 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
11243 fputs (" R4KEOP_CHECKED", stdout
);
11244 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
11245 fputs (" R4KEOP_CLEAN", stdout
);
11248 printf (" GP_GROUP %#06lx self-contained %#06lx",
11249 option
->info
& OGP_GROUP
,
11250 (option
->info
& OGP_SELF
) >> 16);
11253 printf (" IDENT %#06lx self-contained %#06lx",
11254 option
->info
& OGP_GROUP
,
11255 (option
->info
& OGP_SELF
) >> 16);
11258 /* This shouldn't happen. */
11259 printf (" %3d ??? %d %lx",
11260 option
->kind
, option
->section
, option
->info
);
11264 len
= sizeof (* eopt
);
11265 while (len
< option
->size
)
11266 if (((char *) option
)[len
] >= ' '
11267 && ((char *) option
)[len
] < 0x7f)
11268 printf ("%c", ((char *) option
)[len
++]);
11270 printf ("\\%03o", ((char *) option
)[len
++]);
11272 fputs ("\n", stdout
);
11280 if (conflicts_offset
!= 0 && conflictsno
!= 0)
11282 Elf32_Conflict
* iconf
;
11285 if (dynamic_symbols
== NULL
)
11287 error (_("conflict list found without a dynamic symbol table\n"));
11291 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
11294 error (_("Out of memory\n"));
11300 Elf32_External_Conflict
* econf32
;
11302 econf32
= (Elf32_External_Conflict
*)
11303 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11304 sizeof (* econf32
), _("conflict"));
11308 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11309 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
11315 Elf64_External_Conflict
* econf64
;
11317 econf64
= (Elf64_External_Conflict
*)
11318 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
11319 sizeof (* econf64
), _("conflict"));
11323 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11324 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
11329 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11330 (unsigned long) conflictsno
);
11331 puts (_(" Num: Index Value Name"));
11333 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
11335 Elf_Internal_Sym
* psym
= & dynamic_symbols
[iconf
[cnt
]];
11337 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
11338 print_vma (psym
->st_value
, FULL_HEX
);
11340 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11341 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11343 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11350 if (pltgot
!= 0 && local_gotno
!= 0)
11352 bfd_vma ent
, local_end
, global_end
;
11354 unsigned char * data
;
11358 addr_size
= (is_32bit_elf
? 4 : 8);
11359 local_end
= pltgot
+ local_gotno
* addr_size
;
11360 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
11362 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
11363 data
= (unsigned char *) get_data (NULL
, file
, offset
,
11364 global_end
- pltgot
, 1, _("GOT"));
11365 printf (_("\nPrimary GOT:\n"));
11366 printf (_(" Canonical gp value: "));
11367 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
11370 printf (_(" Reserved entries:\n"));
11371 printf (_(" %*s %10s %*s Purpose\n"),
11372 addr_size
* 2, _("Address"), _("Access"),
11373 addr_size
* 2, _("Initial"));
11374 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11375 printf (_(" Lazy resolver\n"));
11377 && (byte_get (data
+ ent
- pltgot
, addr_size
)
11378 >> (addr_size
* 8 - 1)) != 0)
11380 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11381 printf (_(" Module pointer (GNU extension)\n"));
11385 if (ent
< local_end
)
11387 printf (_(" Local entries:\n"));
11388 printf (_(" %*s %10s %*s\n"),
11389 addr_size
* 2, _("Address"), _("Access"),
11390 addr_size
* 2, _("Initial"));
11391 while (ent
< local_end
)
11393 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11399 if (gotsym
< symtabno
)
11403 printf (_(" Global entries:\n"));
11404 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
11405 addr_size
* 2, _("Address"), _("Access"),
11406 addr_size
* 2, _("Initial"),
11407 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11408 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
11409 for (i
= gotsym
; i
< symtabno
; i
++)
11411 Elf_Internal_Sym
* psym
;
11413 psym
= dynamic_symbols
+ i
;
11414 ent
= print_mips_got_entry (data
, pltgot
, ent
);
11416 print_vma (psym
->st_value
, LONG_HEX
);
11417 printf (" %-7s %3s ",
11418 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11419 get_symbol_index_type (psym
->st_shndx
));
11420 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11421 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11423 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11433 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
11436 size_t offset
, rel_offset
;
11437 unsigned long count
, i
;
11438 unsigned char * data
;
11439 int addr_size
, sym_width
;
11440 Elf_Internal_Rela
* rels
;
11442 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
11443 if (pltrel
== DT_RELA
)
11445 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11450 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
11455 addr_size
= (is_32bit_elf
? 4 : 8);
11456 end
= mips_pltgot
+ (2 + count
) * addr_size
;
11458 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
11459 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
11461 printf (_("\nPLT GOT:\n\n"));
11462 printf (_(" Reserved entries:\n"));
11463 printf (_(" %*s %*s Purpose\n"),
11464 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
11465 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11466 printf (_(" PLT lazy resolver\n"));
11467 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11468 printf (_(" Module pointer\n"));
11471 printf (_(" Entries:\n"));
11472 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
11473 addr_size
* 2, _("Address"),
11474 addr_size
* 2, _("Initial"),
11475 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11476 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
11477 for (i
= 0; i
< count
; i
++)
11479 Elf_Internal_Sym
* psym
;
11481 psym
= dynamic_symbols
+ get_reloc_symindex (rels
[i
].r_info
);
11482 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
11484 print_vma (psym
->st_value
, LONG_HEX
);
11485 printf (" %-7s %3s ",
11486 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
11487 get_symbol_index_type (psym
->st_shndx
));
11488 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11489 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
11491 printf (_("<corrupt: %14ld>"), psym
->st_name
);
11505 process_gnu_liblist (FILE * file
)
11507 Elf_Internal_Shdr
* section
;
11508 Elf_Internal_Shdr
* string_sec
;
11509 Elf32_External_Lib
* elib
;
11511 size_t strtab_size
;
11518 for (i
= 0, section
= section_headers
;
11519 i
< elf_header
.e_shnum
;
11522 switch (section
->sh_type
)
11524 case SHT_GNU_LIBLIST
:
11525 if (section
->sh_link
>= elf_header
.e_shnum
)
11528 elib
= (Elf32_External_Lib
*)
11529 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
11534 string_sec
= section_headers
+ section
->sh_link
;
11536 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
11537 string_sec
->sh_size
,
11538 _("liblist string table"));
11539 strtab_size
= string_sec
->sh_size
;
11542 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
11548 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11549 SECTION_NAME (section
),
11550 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
11552 puts (_(" Library Time Stamp Checksum Version Flags"));
11554 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
11562 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
11563 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
11564 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
11565 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
11566 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
11568 tmp
= gmtime (&atime
);
11569 snprintf (timebuf
, sizeof (timebuf
),
11570 "%04u-%02u-%02uT%02u:%02u:%02u",
11571 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11572 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11574 printf ("%3lu: ", (unsigned long) cnt
);
11576 printf ("%-20s", liblist
.l_name
< strtab_size
11577 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11579 printf ("%-20.20s", liblist
.l_name
< strtab_size
11580 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
11581 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
11582 liblist
.l_version
, liblist
.l_flags
);
11592 static const char *
11593 get_note_type (unsigned e_type
)
11595 static char buff
[64];
11597 if (elf_header
.e_type
== ET_CORE
)
11601 return _("NT_AUXV (auxiliary vector)");
11603 return _("NT_PRSTATUS (prstatus structure)");
11605 return _("NT_FPREGSET (floating point registers)");
11607 return _("NT_PRPSINFO (prpsinfo structure)");
11608 case NT_TASKSTRUCT
:
11609 return _("NT_TASKSTRUCT (task structure)");
11611 return _("NT_PRXFPREG (user_xfpregs structure)");
11613 return _("NT_PPC_VMX (ppc Altivec registers)");
11615 return _("NT_PPC_VSX (ppc VSX registers)");
11616 case NT_X86_XSTATE
:
11617 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11618 case NT_S390_HIGH_GPRS
:
11619 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11620 case NT_S390_TIMER
:
11621 return _("NT_S390_TIMER (s390 timer register)");
11622 case NT_S390_TODCMP
:
11623 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11624 case NT_S390_TODPREG
:
11625 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11627 return _("NT_S390_CTRS (s390 control registers)");
11628 case NT_S390_PREFIX
:
11629 return _("NT_S390_PREFIX (s390 prefix register)");
11631 return _("NT_PSTATUS (pstatus structure)");
11633 return _("NT_FPREGS (floating point registers)");
11635 return _("NT_PSINFO (psinfo structure)");
11637 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11639 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11640 case NT_WIN32PSTATUS
:
11641 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11649 return _("NT_VERSION (version)");
11651 return _("NT_ARCH (architecture)");
11656 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11660 static const char *
11661 get_gnu_elf_note_type (unsigned e_type
)
11663 static char buff
[64];
11667 case NT_GNU_ABI_TAG
:
11668 return _("NT_GNU_ABI_TAG (ABI version tag)");
11670 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11671 case NT_GNU_BUILD_ID
:
11672 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11673 case NT_GNU_GOLD_VERSION
:
11674 return _("NT_GNU_GOLD_VERSION (gold version)");
11679 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11683 static const char *
11684 get_netbsd_elfcore_note_type (unsigned e_type
)
11686 static char buff
[64];
11688 if (e_type
== NT_NETBSDCORE_PROCINFO
)
11690 /* NetBSD core "procinfo" structure. */
11691 return _("NetBSD procinfo structure");
11694 /* As of Jan 2002 there are no other machine-independent notes
11695 defined for NetBSD core files. If the note type is less
11696 than the start of the machine-dependent note types, we don't
11699 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
11701 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
11705 switch (elf_header
.e_machine
)
11707 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11708 and PT_GETFPREGS == mach+2. */
11713 case EM_SPARC32PLUS
:
11717 case NT_NETBSDCORE_FIRSTMACH
+ 0:
11718 return _("PT_GETREGS (reg structure)");
11719 case NT_NETBSDCORE_FIRSTMACH
+ 2:
11720 return _("PT_GETFPREGS (fpreg structure)");
11726 /* On all other arch's, PT_GETREGS == mach+1 and
11727 PT_GETFPREGS == mach+3. */
11731 case NT_NETBSDCORE_FIRSTMACH
+ 1:
11732 return _("PT_GETREGS (reg structure)");
11733 case NT_NETBSDCORE_FIRSTMACH
+ 3:
11734 return _("PT_GETFPREGS (fpreg structure)");
11740 snprintf (buff
, sizeof (buff
), _("PT_FIRSTMACH+%d"),
11741 e_type
- NT_NETBSDCORE_FIRSTMACH
);
11745 /* Note that by the ELF standard, the name field is already null byte
11746 terminated, and namesz includes the terminating null byte.
11747 I.E. the value of namesz for the name "FSF" is 4.
11749 If the value of namesz is zero, there is no name present. */
11751 process_note (Elf_Internal_Note
* pnote
)
11753 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
11756 if (pnote
->namesz
== 0)
11757 /* If there is no note name, then use the default set of
11758 note type strings. */
11759 nt
= get_note_type (pnote
->type
);
11761 else if (const_strneq (pnote
->namedata
, "GNU"))
11762 /* GNU-specific object file notes. */
11763 nt
= get_gnu_elf_note_type (pnote
->type
);
11765 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
11766 /* NetBSD-specific core file notes. */
11767 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
11769 else if (strneq (pnote
->namedata
, "SPU/", 4))
11771 /* SPU-specific core file notes. */
11772 nt
= pnote
->namedata
+ 4;
11777 /* Don't recognize this note name; just use the default set of
11778 note type strings. */
11779 nt
= get_note_type (pnote
->type
);
11781 printf (" %s\t\t0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
11787 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
11789 Elf_External_Note
* pnotes
;
11790 Elf_External_Note
* external
;
11796 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
11803 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
11804 (unsigned long) offset
, (unsigned long) length
);
11805 printf (_(" Owner\t\tData size\tDescription\n"));
11807 while (external
< (Elf_External_Note
*) ((char *) pnotes
+ length
))
11809 Elf_External_Note
* next
;
11810 Elf_Internal_Note inote
;
11811 char * temp
= NULL
;
11813 inote
.type
= BYTE_GET (external
->type
);
11814 inote
.namesz
= BYTE_GET (external
->namesz
);
11815 inote
.namedata
= external
->name
;
11816 inote
.descsz
= BYTE_GET (external
->descsz
);
11817 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
11818 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
11820 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
11822 if (((char *) next
) > (((char *) pnotes
) + length
))
11824 warn (_("corrupt note found at offset %lx into core notes\n"),
11825 (unsigned long) ((char *) external
- (char *) pnotes
));
11826 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
11827 inote
.type
, inote
.namesz
, inote
.descsz
);
11833 /* Verify that name is null terminated. It appears that at least
11834 one version of Linux (RedHat 6.0) generates corefiles that don't
11835 comply with the ELF spec by failing to include the null byte in
11837 if (inote
.namedata
[inote
.namesz
] != '\0')
11839 temp
= (char *) malloc (inote
.namesz
+ 1);
11843 error (_("Out of memory\n"));
11848 strncpy (temp
, inote
.namedata
, inote
.namesz
);
11849 temp
[inote
.namesz
] = 0;
11851 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
11852 inote
.namedata
= temp
;
11855 res
&= process_note (& inote
);
11870 process_corefile_note_segments (FILE * file
)
11872 Elf_Internal_Phdr
* segment
;
11876 if (! get_program_headers (file
))
11879 for (i
= 0, segment
= program_headers
;
11880 i
< elf_header
.e_phnum
;
11883 if (segment
->p_type
== PT_NOTE
)
11884 res
&= process_corefile_note_segment (file
,
11885 (bfd_vma
) segment
->p_offset
,
11886 (bfd_vma
) segment
->p_filesz
);
11893 process_note_sections (FILE * file
)
11895 Elf_Internal_Shdr
* section
;
11899 for (i
= 0, section
= section_headers
;
11900 i
< elf_header
.e_shnum
;
11902 if (section
->sh_type
== SHT_NOTE
)
11903 res
&= process_corefile_note_segment (file
,
11904 (bfd_vma
) section
->sh_offset
,
11905 (bfd_vma
) section
->sh_size
);
11911 process_notes (FILE * file
)
11913 /* If we have not been asked to display the notes then do nothing. */
11917 if (elf_header
.e_type
!= ET_CORE
)
11918 return process_note_sections (file
);
11920 /* No program headers means no NOTE segment. */
11921 if (elf_header
.e_phnum
> 0)
11922 return process_corefile_note_segments (file
);
11924 printf (_("No note segments present in the core file.\n"));
11929 process_arch_specific (FILE * file
)
11934 switch (elf_header
.e_machine
)
11937 return process_arm_specific (file
);
11939 case EM_MIPS_RS3_LE
:
11940 return process_mips_specific (file
);
11943 return process_power_specific (file
);
11946 return process_tic6x_specific (file
);
11955 get_file_header (FILE * file
)
11957 /* Read in the identity array. */
11958 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
11961 /* Determine how to read the rest of the header. */
11962 switch (elf_header
.e_ident
[EI_DATA
])
11964 default: /* fall through */
11965 case ELFDATANONE
: /* fall through */
11967 byte_get
= byte_get_little_endian
;
11968 byte_put
= byte_put_little_endian
;
11971 byte_get
= byte_get_big_endian
;
11972 byte_put
= byte_put_big_endian
;
11976 /* For now we only support 32 bit and 64 bit ELF files. */
11977 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
11979 /* Read in the rest of the header. */
11982 Elf32_External_Ehdr ehdr32
;
11984 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
11987 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
11988 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
11989 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
11990 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
11991 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
11992 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
11993 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
11994 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
11995 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
11996 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
11997 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
11998 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
11999 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
12003 Elf64_External_Ehdr ehdr64
;
12005 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12006 we will not be able to cope with the 64bit data found in
12007 64 ELF files. Detect this now and abort before we start
12008 overwriting things. */
12009 if (sizeof (bfd_vma
) < 8)
12011 error (_("This instance of readelf has been built without support for a\n\
12012 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12016 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
12019 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
12020 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
12021 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
12022 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
12023 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
12024 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
12025 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
12026 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
12027 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
12028 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
12029 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
12030 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
12031 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
12034 if (elf_header
.e_shoff
)
12036 /* There may be some extensions in the first section header. Don't
12037 bomb if we can't read it. */
12039 get_32bit_section_headers (file
, 1);
12041 get_64bit_section_headers (file
, 1);
12047 /* Process one ELF object file according to the command line options.
12048 This file may actually be stored in an archive. The file is
12049 positioned at the start of the ELF object. */
12052 process_object (char * file_name
, FILE * file
)
12056 if (! get_file_header (file
))
12058 error (_("%s: Failed to read file header\n"), file_name
);
12062 /* Initialise per file variables. */
12063 for (i
= ARRAY_SIZE (version_info
); i
--;)
12064 version_info
[i
] = 0;
12066 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
12067 dynamic_info
[i
] = 0;
12069 /* Process the file. */
12071 printf (_("\nFile: %s\n"), file_name
);
12073 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12074 Note we do this even if cmdline_dump_sects is empty because we
12075 must make sure that the dump_sets array is zeroed out before each
12076 object file is processed. */
12077 if (num_dump_sects
> num_cmdline_dump_sects
)
12078 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
12080 if (num_cmdline_dump_sects
> 0)
12082 if (num_dump_sects
== 0)
12083 /* A sneaky way of allocating the dump_sects array. */
12084 request_dump_bynumber (num_cmdline_dump_sects
, 0);
12086 assert (num_dump_sects
>= num_cmdline_dump_sects
);
12087 memcpy (dump_sects
, cmdline_dump_sects
,
12088 num_cmdline_dump_sects
* sizeof (* dump_sects
));
12091 if (! process_file_header ())
12094 if (! process_section_headers (file
))
12096 /* Without loaded section headers we cannot process lots of
12098 do_unwind
= do_version
= do_dump
= do_arch
= 0;
12100 if (! do_using_dynamic
)
12101 do_syms
= do_dyn_syms
= do_reloc
= 0;
12104 if (! process_section_groups (file
))
12106 /* Without loaded section groups we cannot process unwind. */
12110 if (process_program_headers (file
))
12111 process_dynamic_section (file
);
12113 process_relocs (file
);
12115 process_unwind (file
);
12117 process_symbol_table (file
);
12119 process_syminfo (file
);
12121 process_version_sections (file
);
12123 process_section_contents (file
);
12125 process_notes (file
);
12127 process_gnu_liblist (file
);
12129 process_arch_specific (file
);
12131 if (program_headers
)
12133 free (program_headers
);
12134 program_headers
= NULL
;
12137 if (section_headers
)
12139 free (section_headers
);
12140 section_headers
= NULL
;
12145 free (string_table
);
12146 string_table
= NULL
;
12147 string_table_length
= 0;
12150 if (dynamic_strings
)
12152 free (dynamic_strings
);
12153 dynamic_strings
= NULL
;
12154 dynamic_strings_length
= 0;
12157 if (dynamic_symbols
)
12159 free (dynamic_symbols
);
12160 dynamic_symbols
= NULL
;
12161 num_dynamic_syms
= 0;
12164 if (dynamic_syminfo
)
12166 free (dynamic_syminfo
);
12167 dynamic_syminfo
= NULL
;
12170 if (section_headers_groups
)
12172 free (section_headers_groups
);
12173 section_headers_groups
= NULL
;
12176 if (section_groups
)
12178 struct group_list
* g
;
12179 struct group_list
* next
;
12181 for (i
= 0; i
< group_count
; i
++)
12183 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
12190 free (section_groups
);
12191 section_groups
= NULL
;
12194 free_debug_memory ();
12199 /* Return the path name for a proxy entry in a thin archive, adjusted relative
12200 to the path name of the thin archive itself if necessary. Always returns
12201 a pointer to malloc'ed memory. */
12204 adjust_relative_path (char * file_name
, char * name
, int name_len
)
12206 char * member_file_name
;
12207 const char * base_name
= lbasename (file_name
);
12209 /* This is a proxy entry for a thin archive member.
12210 If the extended name table contains an absolute path
12211 name, or if the archive is in the current directory,
12212 use the path name as given. Otherwise, we need to
12213 find the member relative to the directory where the
12214 archive is located. */
12215 if (IS_ABSOLUTE_PATH (name
) || base_name
== file_name
)
12217 member_file_name
= (char *) malloc (name_len
+ 1);
12218 if (member_file_name
== NULL
)
12220 error (_("Out of memory\n"));
12223 memcpy (member_file_name
, name
, name_len
);
12224 member_file_name
[name_len
] = '\0';
12228 /* Concatenate the path components of the archive file name
12229 to the relative path name from the extended name table. */
12230 size_t prefix_len
= base_name
- file_name
;
12231 member_file_name
= (char *) malloc (prefix_len
+ name_len
+ 1);
12232 if (member_file_name
== NULL
)
12234 error (_("Out of memory\n"));
12237 memcpy (member_file_name
, file_name
, prefix_len
);
12238 memcpy (member_file_name
+ prefix_len
, name
, name_len
);
12239 member_file_name
[prefix_len
+ name_len
] = '\0';
12241 return member_file_name
;
12244 /* Structure to hold information about an archive file. */
12246 struct archive_info
12248 char * file_name
; /* Archive file name. */
12249 FILE * file
; /* Open file descriptor. */
12250 unsigned long index_num
; /* Number of symbols in table. */
12251 unsigned long * index_array
; /* The array of member offsets. */
12252 char * sym_table
; /* The symbol table. */
12253 unsigned long sym_size
; /* Size of the symbol table. */
12254 char * longnames
; /* The long file names table. */
12255 unsigned long longnames_size
; /* Size of the long file names table. */
12256 unsigned long nested_member_origin
; /* Origin in the nested archive of the current member. */
12257 unsigned long next_arhdr_offset
; /* Offset of the next archive header. */
12258 bfd_boolean is_thin_archive
; /* TRUE if this is a thin archive. */
12259 struct ar_hdr arhdr
; /* Current archive header. */
12262 /* Read the symbol table and long-name table from an archive. */
12265 setup_archive (struct archive_info
* arch
, char * file_name
, FILE * file
,
12266 bfd_boolean is_thin_archive
, bfd_boolean read_symbols
)
12269 unsigned long size
;
12271 arch
->file_name
= strdup (file_name
);
12273 arch
->index_num
= 0;
12274 arch
->index_array
= NULL
;
12275 arch
->sym_table
= NULL
;
12276 arch
->sym_size
= 0;
12277 arch
->longnames
= NULL
;
12278 arch
->longnames_size
= 0;
12279 arch
->nested_member_origin
= 0;
12280 arch
->is_thin_archive
= is_thin_archive
;
12281 arch
->next_arhdr_offset
= SARMAG
;
12283 /* Read the first archive member header. */
12284 if (fseek (file
, SARMAG
, SEEK_SET
) != 0)
12286 error (_("%s: failed to seek to first archive header\n"), file_name
);
12289 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12290 if (got
!= sizeof arch
->arhdr
)
12295 error (_("%s: failed to read archive header\n"), file_name
);
12299 /* See if this is the archive symbol table. */
12300 if (const_strneq (arch
->arhdr
.ar_name
, "/ ")
12301 || const_strneq (arch
->arhdr
.ar_name
, "/SYM64/ "))
12303 size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12304 size
= size
+ (size
& 1);
12306 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ size
;
12311 /* A buffer used to hold numbers read in from an archive index.
12312 These are always 4 bytes long and stored in big-endian format. */
12313 #define SIZEOF_AR_INDEX_NUMBERS 4
12314 unsigned char integer_buffer
[SIZEOF_AR_INDEX_NUMBERS
];
12315 unsigned char * index_buffer
;
12317 /* Check the size of the archive index. */
12318 if (size
< SIZEOF_AR_INDEX_NUMBERS
)
12320 error (_("%s: the archive index is empty\n"), file_name
);
12324 /* Read the numer of entries in the archive index. */
12325 got
= fread (integer_buffer
, 1, sizeof integer_buffer
, file
);
12326 if (got
!= sizeof (integer_buffer
))
12328 error (_("%s: failed to read archive index\n"), file_name
);
12331 arch
->index_num
= byte_get_big_endian (integer_buffer
, sizeof integer_buffer
);
12332 size
-= SIZEOF_AR_INDEX_NUMBERS
;
12334 /* Read in the archive index. */
12335 if (size
< arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
)
12337 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
12338 file_name
, arch
->index_num
);
12341 index_buffer
= (unsigned char *)
12342 malloc (arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
);
12343 if (index_buffer
== NULL
)
12345 error (_("Out of memory whilst trying to read archive symbol index\n"));
12348 got
= fread (index_buffer
, SIZEOF_AR_INDEX_NUMBERS
, arch
->index_num
, file
);
12349 if (got
!= arch
->index_num
)
12351 free (index_buffer
);
12352 error (_("%s: failed to read archive index\n"), file_name
);
12355 size
-= arch
->index_num
* SIZEOF_AR_INDEX_NUMBERS
;
12357 /* Convert the index numbers into the host's numeric format. */
12358 arch
->index_array
= (long unsigned int *)
12359 malloc (arch
->index_num
* sizeof (* arch
->index_array
));
12360 if (arch
->index_array
== NULL
)
12362 free (index_buffer
);
12363 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
12367 for (i
= 0; i
< arch
->index_num
; i
++)
12368 arch
->index_array
[i
] = byte_get_big_endian ((unsigned char *) (index_buffer
+ (i
* SIZEOF_AR_INDEX_NUMBERS
)),
12369 SIZEOF_AR_INDEX_NUMBERS
);
12370 free (index_buffer
);
12372 /* The remaining space in the header is taken up by the symbol table. */
12375 error (_("%s: the archive has an index but no symbols\n"), file_name
);
12378 arch
->sym_table
= (char *) malloc (size
);
12379 arch
->sym_size
= size
;
12380 if (arch
->sym_table
== NULL
)
12382 error (_("Out of memory whilst trying to read archive index symbol table\n"));
12385 got
= fread (arch
->sym_table
, 1, size
, file
);
12388 error (_("%s: failed to read archive index symbol table\n"), file_name
);
12394 if (fseek (file
, size
, SEEK_CUR
) != 0)
12396 error (_("%s: failed to skip archive symbol table\n"), file_name
);
12401 /* Read the next archive header. */
12402 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, file
);
12403 if (got
!= sizeof arch
->arhdr
)
12407 error (_("%s: failed to read archive header following archive index\n"), file_name
);
12411 else if (read_symbols
)
12412 printf (_("%s has no archive index\n"), file_name
);
12414 if (const_strneq (arch
->arhdr
.ar_name
, "// "))
12416 /* This is the archive string table holding long member names. */
12417 arch
->longnames_size
= strtoul (arch
->arhdr
.ar_size
, NULL
, 10);
12418 arch
->next_arhdr_offset
+= sizeof arch
->arhdr
+ arch
->longnames_size
;
12420 arch
->longnames
= (char *) malloc (arch
->longnames_size
);
12421 if (arch
->longnames
== NULL
)
12423 error (_("Out of memory reading long symbol names in archive\n"));
12427 if (fread (arch
->longnames
, arch
->longnames_size
, 1, file
) != 1)
12429 free (arch
->longnames
);
12430 arch
->longnames
= NULL
;
12431 error (_("%s: failed to read long symbol name string table\n"), file_name
);
12435 if ((arch
->longnames_size
& 1) != 0)
12442 /* Release the memory used for the archive information. */
12445 release_archive (struct archive_info
* arch
)
12447 if (arch
->file_name
!= NULL
)
12448 free (arch
->file_name
);
12449 if (arch
->index_array
!= NULL
)
12450 free (arch
->index_array
);
12451 if (arch
->sym_table
!= NULL
)
12452 free (arch
->sym_table
);
12453 if (arch
->longnames
!= NULL
)
12454 free (arch
->longnames
);
12457 /* Open and setup a nested archive, if not already open. */
12460 setup_nested_archive (struct archive_info
* nested_arch
, char * member_file_name
)
12462 FILE * member_file
;
12464 /* Have we already setup this archive? */
12465 if (nested_arch
->file_name
!= NULL
12466 && streq (nested_arch
->file_name
, member_file_name
))
12469 /* Close previous file and discard cached information. */
12470 if (nested_arch
->file
!= NULL
)
12471 fclose (nested_arch
->file
);
12472 release_archive (nested_arch
);
12474 member_file
= fopen (member_file_name
, "rb");
12475 if (member_file
== NULL
)
12477 return setup_archive (nested_arch
, member_file_name
, member_file
, FALSE
, FALSE
);
12481 get_archive_member_name_at (struct archive_info
* arch
,
12482 unsigned long offset
,
12483 struct archive_info
* nested_arch
);
12485 /* Get the name of an archive member from the current archive header.
12486 For simple names, this will modify the ar_name field of the current
12487 archive header. For long names, it will return a pointer to the
12488 longnames table. For nested archives, it will open the nested archive
12489 and get the name recursively. NESTED_ARCH is a single-entry cache so
12490 we don't keep rereading the same information from a nested archive. */
12493 get_archive_member_name (struct archive_info
* arch
,
12494 struct archive_info
* nested_arch
)
12496 unsigned long j
, k
;
12498 if (arch
->arhdr
.ar_name
[0] == '/')
12500 /* We have a long name. */
12502 char * member_file_name
;
12503 char * member_name
;
12505 arch
->nested_member_origin
= 0;
12506 k
= j
= strtoul (arch
->arhdr
.ar_name
+ 1, &endp
, 10);
12507 if (arch
->is_thin_archive
&& endp
!= NULL
&& * endp
== ':')
12508 arch
->nested_member_origin
= strtoul (endp
+ 1, NULL
, 10);
12510 while ((j
< arch
->longnames_size
)
12511 && (arch
->longnames
[j
] != '\n')
12512 && (arch
->longnames
[j
] != '\0'))
12514 if (arch
->longnames
[j
-1] == '/')
12516 arch
->longnames
[j
] = '\0';
12518 if (!arch
->is_thin_archive
|| arch
->nested_member_origin
== 0)
12519 return arch
->longnames
+ k
;
12521 /* This is a proxy for a member of a nested archive.
12522 Find the name of the member in that archive. */
12523 member_file_name
= adjust_relative_path (arch
->file_name
, arch
->longnames
+ k
, j
- k
);
12524 if (member_file_name
!= NULL
12525 && setup_nested_archive (nested_arch
, member_file_name
) == 0
12526 && (member_name
= get_archive_member_name_at (nested_arch
, arch
->nested_member_origin
, NULL
)) != NULL
)
12528 free (member_file_name
);
12529 return member_name
;
12531 free (member_file_name
);
12533 /* Last resort: just return the name of the nested archive. */
12534 return arch
->longnames
+ k
;
12537 /* We have a normal (short) name. */
12539 while ((arch
->arhdr
.ar_name
[j
] != '/') && (j
< 16))
12541 arch
->arhdr
.ar_name
[j
] = '\0';
12542 return arch
->arhdr
.ar_name
;
12545 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
12548 get_archive_member_name_at (struct archive_info
* arch
,
12549 unsigned long offset
,
12550 struct archive_info
* nested_arch
)
12554 if (fseek (arch
->file
, offset
, SEEK_SET
) != 0)
12556 error (_("%s: failed to seek to next file name\n"), arch
->file_name
);
12559 got
= fread (&arch
->arhdr
, 1, sizeof arch
->arhdr
, arch
->file
);
12560 if (got
!= sizeof arch
->arhdr
)
12562 error (_("%s: failed to read archive header\n"), arch
->file_name
);
12565 if (memcmp (arch
->arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12567 error (_("%s: did not find a valid archive header\n"), arch
->file_name
);
12571 return get_archive_member_name (arch
, nested_arch
);
12574 /* Construct a string showing the name of the archive member, qualified
12575 with the name of the containing archive file. For thin archives, we
12576 use square brackets to denote the indirection. For nested archives,
12577 we show the qualified name of the external member inside the square
12578 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
12581 make_qualified_name (struct archive_info
* arch
,
12582 struct archive_info
* nested_arch
,
12583 char * member_name
)
12588 len
= strlen (arch
->file_name
) + strlen (member_name
) + 3;
12589 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12590 len
+= strlen (nested_arch
->file_name
) + 2;
12592 name
= (char *) malloc (len
);
12595 error (_("Out of memory\n"));
12599 if (arch
->is_thin_archive
&& arch
->nested_member_origin
!= 0)
12600 snprintf (name
, len
, "%s[%s(%s)]", arch
->file_name
, nested_arch
->file_name
, member_name
);
12601 else if (arch
->is_thin_archive
)
12602 snprintf (name
, len
, "%s[%s]", arch
->file_name
, member_name
);
12604 snprintf (name
, len
, "%s(%s)", arch
->file_name
, member_name
);
12609 /* Process an ELF archive.
12610 On entry the file is positioned just after the ARMAG string. */
12613 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
12615 struct archive_info arch
;
12616 struct archive_info nested_arch
;
12622 /* The ARCH structure is used to hold information about this archive. */
12623 arch
.file_name
= NULL
;
12625 arch
.index_array
= NULL
;
12626 arch
.sym_table
= NULL
;
12627 arch
.longnames
= NULL
;
12629 /* The NESTED_ARCH structure is used as a single-item cache of information
12630 about a nested archive (when members of a thin archive reside within
12631 another regular archive file). */
12632 nested_arch
.file_name
= NULL
;
12633 nested_arch
.file
= NULL
;
12634 nested_arch
.index_array
= NULL
;
12635 nested_arch
.sym_table
= NULL
;
12636 nested_arch
.longnames
= NULL
;
12638 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
12644 if (do_archive_index
)
12646 if (arch
.sym_table
== NULL
)
12647 error (_("%s: unable to dump the index as none was found\n"), file_name
);
12651 unsigned long current_pos
;
12653 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12654 file_name
, arch
.index_num
, arch
.sym_size
);
12655 current_pos
= ftell (file
);
12657 for (i
= l
= 0; i
< arch
.index_num
; i
++)
12659 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
12661 char * member_name
;
12663 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
12665 if (member_name
!= NULL
)
12667 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
12669 if (qualified_name
!= NULL
)
12671 printf (_("Binary %s contains:\n"), qualified_name
);
12672 free (qualified_name
);
12677 if (l
>= arch
.sym_size
)
12679 error (_("%s: end of the symbol table reached before the end of the index\n"),
12683 printf ("\t%s\n", arch
.sym_table
+ l
);
12684 l
+= strlen (arch
.sym_table
+ l
) + 1;
12689 if (l
< arch
.sym_size
)
12690 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12693 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
12695 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
12701 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
12702 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
12703 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
12704 && !do_section_groups
&& !do_dyn_syms
)
12706 ret
= 0; /* Archive index only. */
12717 char * qualified_name
;
12719 /* Read the next archive header. */
12720 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
12722 error (_("%s: failed to seek to next archive header\n"), file_name
);
12725 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
12726 if (got
!= sizeof arch
.arhdr
)
12730 error (_("%s: failed to read archive header\n"), file_name
);
12734 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
12736 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
12741 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
12743 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
12744 if (archive_file_size
& 01)
12745 ++archive_file_size
;
12747 name
= get_archive_member_name (&arch
, &nested_arch
);
12750 error (_("%s: bad archive file name\n"), file_name
);
12754 namelen
= strlen (name
);
12756 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
12757 if (qualified_name
== NULL
)
12759 error (_("%s: bad archive file name\n"), file_name
);
12764 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
12766 /* This is a proxy for an external member of a thin archive. */
12767 FILE * member_file
;
12768 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
12769 if (member_file_name
== NULL
)
12775 member_file
= fopen (member_file_name
, "rb");
12776 if (member_file
== NULL
)
12778 error (_("Input file '%s' is not readable.\n"), member_file_name
);
12779 free (member_file_name
);
12784 archive_file_offset
= arch
.nested_member_origin
;
12786 ret
|= process_object (qualified_name
, member_file
);
12788 fclose (member_file
);
12789 free (member_file_name
);
12791 else if (is_thin_archive
)
12793 /* This is a proxy for a member of a nested archive. */
12794 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
12796 /* The nested archive file will have been opened and setup by
12797 get_archive_member_name. */
12798 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
12800 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
12805 ret
|= process_object (qualified_name
, nested_arch
.file
);
12809 archive_file_offset
= arch
.next_arhdr_offset
;
12810 arch
.next_arhdr_offset
+= archive_file_size
;
12812 ret
|= process_object (qualified_name
, file
);
12815 free (qualified_name
);
12819 if (nested_arch
.file
!= NULL
)
12820 fclose (nested_arch
.file
);
12821 release_archive (&nested_arch
);
12822 release_archive (&arch
);
12828 process_file (char * file_name
)
12831 struct stat statbuf
;
12832 char armag
[SARMAG
];
12835 if (stat (file_name
, &statbuf
) < 0)
12837 if (errno
== ENOENT
)
12838 error (_("'%s': No such file\n"), file_name
);
12840 error (_("Could not locate '%s'. System error message: %s\n"),
12841 file_name
, strerror (errno
));
12845 if (! S_ISREG (statbuf
.st_mode
))
12847 error (_("'%s' is not an ordinary file\n"), file_name
);
12851 file
= fopen (file_name
, "rb");
12854 error (_("Input file '%s' is not readable.\n"), file_name
);
12858 if (fread (armag
, SARMAG
, 1, file
) != 1)
12860 error (_("%s: Failed to read file's magic number\n"), file_name
);
12865 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
12866 ret
= process_archive (file_name
, file
, FALSE
);
12867 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
12868 ret
= process_archive (file_name
, file
, TRUE
);
12871 if (do_archive_index
)
12872 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12876 archive_file_size
= archive_file_offset
= 0;
12877 ret
= process_object (file_name
, file
);
12885 #ifdef SUPPORT_DISASSEMBLY
12886 /* Needed by the i386 disassembler. For extra credit, someone could
12887 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12891 print_address (unsigned int addr
, FILE * outfile
)
12893 fprintf (outfile
,"0x%8.8x", addr
);
12896 /* Needed by the i386 disassembler. */
12898 db_task_printsym (unsigned int addr
)
12900 print_address (addr
, stderr
);
12905 main (int argc
, char ** argv
)
12909 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12910 setlocale (LC_MESSAGES
, "");
12912 #if defined (HAVE_SETLOCALE)
12913 setlocale (LC_CTYPE
, "");
12915 bindtextdomain (PACKAGE
, LOCALEDIR
);
12916 textdomain (PACKAGE
);
12918 expandargv (&argc
, &argv
);
12920 parse_args (argc
, argv
);
12922 if (num_dump_sects
> 0)
12924 /* Make a copy of the dump_sects array. */
12925 cmdline_dump_sects
= (dump_type
*)
12926 malloc (num_dump_sects
* sizeof (* dump_sects
));
12927 if (cmdline_dump_sects
== NULL
)
12928 error (_("Out of memory allocating dump request table.\n"));
12931 memcpy (cmdline_dump_sects
, dump_sects
,
12932 num_dump_sects
* sizeof (* dump_sects
));
12933 num_cmdline_dump_sects
= num_dump_sects
;
12937 if (optind
< (argc
- 1))
12941 while (optind
< argc
)
12942 err
|= process_file (argv
[optind
++]);
12944 if (dump_sects
!= NULL
)
12946 if (cmdline_dump_sects
!= NULL
)
12947 free (cmdline_dump_sects
);